Zero Overlap Solution (Hybrid Loss + Legalization) - 16s Total Runtime

[marcoshernanz]

Summary

This submission implements a robust placement optimizer that guarantees zero overlap across all test cases (including the 100k-cell test) while maintaining low runtime (~17s total) and competitive wirelength.

Key Implementation Details

1. Hybrid Overlap Loss:
   • Uses exact pairwise loss for small designs ($N \le 2000$).
   • Switches to a differentiable density-based loss (Gaussian binning) for large designs to maintain $O(N)$ memory/compute complexity.
2. Deterministic Legalization:
   • Implements a fast row-based packing algorithm (_legalize_placement) as a post-processing step.
   • Ensures 100% valid placement (0.0000 overlap) regardless of optimization convergence.
3. Wirelength Optimization:
   • Includes a dedicated fast-path for large designs (_quick_wirelength_opt) using aggressive sampling and simplified loss.
   • Runs pre- and post-legalization refinement to recover wirelength quality after overlap removal.
4. Adaptive Scheduling:
   • Dynamically scales epochs, learning rates, and penalty weights based on netlist size ($N < 200$, $N < 2000$, $N < 10000$, etc.).
   • Skips heavy training loops for massive designs (100k cells) in favor of fast legalization to keep runtime milliseconds-low.

Results

• Average Overlap: 0.0000 (Passed all 12 tests)
• Average Wirelength: 0.7480
• Total Runtime: ~16.68s (Test 12 ran in ~2.3s)

[Copilot]

Pull request overview

This PR implements a sophisticated placement optimizer that achieves zero overlap across all test cases through a hybrid approach combining differentiable overlap losses with deterministic legalization. The solution adapts its strategy based on design size, using exact pairwise overlap detection for small designs and switching to density-based approximation for larger ones.

Changes:

• Implemented hybrid overlap loss function that switches between exact pairwise (≤2048 cells) and Gaussian density-based approximation (>2048 cells)
• Added deterministic row-based legalization post-processing to guarantee zero overlaps
• Introduced adaptive hyperparameter scheduling based on design size with early stopping

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 18 comments.

File	Description
placement.py	Core implementation: hybrid overlap loss, fast wirelength optimization, legalization algorithm, adaptive training with size-dependent hyperparameters, and optimized evaluation functions for large designs
README.md	Updated leaderboard with new submission results

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The warmup schedule modifies wl_scale to be 1.0 - 0.2 * warmup. When warmup reaches 1.0 (after 20% of epochs), wl_scale becomes 0.8. This means the wirelength loss weight is permanently reduced to 80% of its intended value (lambda_wirelength * 0.8) for the remaining 80% of training. This may be intentional, but the behavior is not documented and could be confusing. Consider documenting this behavior or using a more intuitive schedule.

Suggested change

	warmup = min(1.0, (epoch + 1) / max(1, num_epochs * 0.2))
	warmup = min(1.0, (epoch + 1) / max(1, num_epochs * 0.2))
	# During the first 20% of epochs, gradually:
	# - increase overlap loss weight from 1.0x to 4.0x (overlap_scale)
	# - decrease wirelength loss weight from 1.0x to 0.8x (wl_scale)
	# After warmup (warmup == 1.0), overlap_scale stays at 4.0 and
	# wl_scale stays at 0.8 for the remaining 80% of training, so the
	# effective wirelength weight is 0.8 * lambda_wirelength by design.

[Copilot]

The overlap counting for macros may double-count macro-to-macro overlaps. When iterating through macros and checking each against all cells, if macro A overlaps with macro B, this overlap will be counted twice: once when idx=A checks against B, and again when idx=B checks against A. The original O(n²) implementation avoided this by only checking pairs where i < j. Consider modifying the logic to exclude already-processed macros from the check, similar to how mask[idx] = False excludes self-overlaps.

[Copilot]

The magic number 2.0 used as the weight for macro overlap loss is not documented. This weight determines the relative importance of macro overlaps vs density-based overlap loss. Consider extracting as a named constant or documenting why this specific weight was chosen.

[Copilot]

The grid size thresholds (50000, 20000, 10000) and their corresponding values (16, 20, 24) are magic numbers without clear documentation. Consider extracting these as named constants or providing documentation explaining the rationale for these specific thresholds and grid sizes.

[Copilot]

The spatial hashing implementation for large designs uses a dictionary with tuple keys (gx, gy) for binning. While functional, this could be optimized by using a more efficient data structure or pre-allocating a 2D array. Additionally, the neighbor range calculation could potentially miss overlaps if cells are larger than expected. Consider adding validation to ensure the neighbor range is sufficient to capture all potential overlaps.

[Copilot]

The magic numbers used for adaptive scheduling (e.g., 650, 450, 220, 90 for epochs; 0.025, 28.0, 0.5 for hyperparameters; 50000, 80000 for edge sampling) lack documentation explaining why these specific values were chosen. This makes it difficult to understand the reasoning behind the adaptive strategy and to tune or debug the algorithm. Consider adding inline comments explaining the rationale for these thresholds and values.

[Copilot]

When macro_mask results in zero macros being selected, macro_positions will be an empty tensor with shape [0, 2]. This causes dx_macro and dy_macro to have shape [0, num_cells], and subsequently macro_overlap will be computed as division by zero (0 / 1e-6), resulting in 0.0. While this works, it performs unnecessary computation. Consider adding an early check to skip macro overlap computation when no macros exist.

Suggested change

	dx_macro = torch.abs(macro_positions[:, None, 0] - positions[None, :, 0])
	dy_macro = torch.abs(macro_positions[:, None, 1] - positions[None, :, 1])
	min_sep_x = (macro_widths[:, None] + widths[None, :]) / 2
	min_sep_y = (macro_heights[:, None] + heights[None, :]) / 2
	overlap_x = torch.relu(min_sep_x - dx_macro)
	overlap_y = torch.relu(min_sep_y - dy_macro)
	macro_overlap = (overlap_x * overlap_y).sum()
	macro_overlap = macro_overlap / (macro_positions.shape[0] * num_cells + 1e-6)
	if macro_positions.shape[0] == 0:
	# No macros present; skip macro overlap computation.
	macro_overlap = torch.tensor(0.0, device=positions.device)
	else:
	dx_macro = torch.abs(macro_positions[:, None, 0] - positions[None, :, 0])
	dy_macro = torch.abs(macro_positions[:, None, 1] - positions[None, :, 1])
	min_sep_x = (macro_widths[:, None] + widths[None, :]) / 2
	min_sep_y = (macro_heights[:, None] + heights[None, :]) / 2
	overlap_x = torch.relu(min_sep_x - dx_macro)
	overlap_y = torch.relu(min_sep_y - dy_macro)
	macro_overlap = (overlap_x * overlap_y).sum()
	macro_overlap = macro_overlap / (macro_positions.shape[0] * num_cells + 1e-6)

[Copilot]

The statement del pin_features, edge_list explicitly deletes unused parameters. While this can help clarify that these parameters are not used in this function, using del on function parameters is uncommon in Python and can be confusing. A more conventional approach would be to prefix the parameters with an underscore (e.g., _pin_features, _edge_list) or simply not use them without explicitly deleting them. The Python garbage collector will handle cleanup automatically when the function exits.

Suggested change

del pin_features, edge_list

[Copilot]

The function _legalize_placement converts tensors to numpy, performs operations in numpy, then converts back to tensors. This is inefficient as it breaks the computational graph and requires multiple data transfers between GPU and CPU. Consider implementing this functionality directly in PyTorch to maintain the computational graph and avoid unnecessary data transfers, especially since the placement optimization is already using PyTorch tensors.

[Copilot]

Variable pin_cell is not used.

Suggested change

pin_cell = int(pin_to_cell[pin_idx].item())