dpl: negotiation dynamic window

[gudeh]

Summary

Makes the Negotiation Legalizer search window range adaptive instead of fixed X and Y dimensions.

We apply two extensions:

1. An extension is applied depending on instance size.
   • For Y direction we guarantee at least the cell height times the tunable constant (kRowSearchWindow, default 5).
     • We consider for at least kRowSearchWindow valid rows. Multi-height rows may require more rows included.
   • For the X direction we guarantee at least 1 full instance width on each side.
   • Both X and Y are clamped at the same max displacement used for Diamond Search.

Experiments showed far more problems on the Y direction with multi-height and hybrid row structures, requiring more extensions on such dimension.

2. A second extension may be applied if an instance is close to an off-core or macro border, we apply an extension to the search window on the opposite side overlapping the off-core or macro.
   • Experiments showed problems with instances close to borders and neighboring fixed instances.

Type of Change

• New feature

Impact

This solves convergence issues Negotiation Legalizer was having with multi-height cells designs. We were getting search windows too small, and a few instances never moving.

Verification

• I have verified that the local build succeeds (./etc/Build.sh).
• I have run the relevant tests and they pass.
• My code follows the repository's formatting guidelines.
• I have included tests to prevent regressions.
• I have signed my commits (DCO).

Related Issues

This is one of multiple PRs splitting up PR #10226 to make Negotiation the default algorithm at DPL.

This is the last PR to solve all known issues with Negotiation Legalizer. After this one I expect only to make cosmetic modifications and actually switching to the new default.

[gudeh]

The diffs here should be more clear after #10681 is merged.

[gemini-code-assist]

Code Review

This pull request enhances the detailed_placement command in OpenDP by introducing configurable search windows (-site_search_window, -row_search_window) and DRC penalties (-drc_penalty) for the NegotiationLegalizer. It also adds stuck-cell diagnostics, improves GUI debugging with a negotiation violations chart, and updates the observer to track current-iteration movers. Feedback is provided regarding a potential null pointer dereference when retrieving the master of an instance in Opendp::detailedPlacement, which should be guarded to prevent segmentation faults.

[gemini-code-assist]

In the calculation of total_inst_area, inst->getMaster() is called and dereferenced directly without checking if it is nullptr. While instances in a placed design typically have a master, it is safer to add a null check to prevent potential segmentation faults in edge cases or during intermediate database states.

    for (odb::dbInst* inst : block_->getInsts()) {
      odb::dbMaster* master = inst->getMaster();
      if (master != nullptr) {
        total_inst_area += static_cast<int64_t>(master->getWidth())
                           * static_cast<int64_t>(master->getHeight());
      }
    }

[eder-matheus]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9a14e87477

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[gudeh]

@eder-matheus @osamahammad21 This one should be our priority considering DPL. With this PR merged we have solved all known issues with Negotiation legalizer.

[stefanottili]

@gudeh please give ispd15_mgc_superblue12 a try.
Last time tried with/without negotiation legalizer it failed because gpl placed a cell wider then the stdcell row width between two macros and then dpl was not able to move this cell.

[osamahammad21]

Instead of the per-side deficit-and-reallocate logic, model each axis as one budget of 2 * window positions explored by two pointers walking outward from the anchor. Each consumes from the shared budget until it runs out or hits a wall; when one side walls early, the other naturally absorbs the rest. No separate deficit computation, nothing explored past a wall, and the both-walls case falls out for free. disable_window_extension reduces to just the per-side cap (window vs max_displacement).

Also, Can we get a multi-height test here? All the negotiation tests are single-height gcd, so none of the new code paths actually run.

[osamahammad21]

what if both ends are hitting a wall? or what if the extended window itself is hitting a wall?

[gudeh]

I see an example with only a 2 row strip sandwiched by macros. The window fits nicely on the available space.

And if it were to overlap with the macro (as it did before) is a problem because before we accept any actual movement we check for site validity, even after the window extension.

[osamahammad21]

how do you plan to test this?

[osamahammad21]

why not?

Suggested change

	int dx_lo = -(site_window + right_deficit);
	int dx_lo = -(left_avail + right_deficit);

[osamahammad21]

@gudeh
I think the deficit calculation has an inconsistency. Take this layout (site_window = 40):

• Left: sites −1..−4 open, then a macro covering −5..−14 (10 sites), then open again from −15 out to −40.
• Right: fully open.

The availability scan stops at the first wall, so left_avail = 4 and right_avail = 40. That gives left_deficit = 36, right_deficit = 0, and:

dx_lo = -(site_window + right_deficit) = -40
dx_hi =  (site_window + left_deficit) = +76

Window = [−40, +76].

The inconsistency: left_avail stops at the first blocked site, so site_window − left_avail counts everything past the macro as lost, the 10 macro sites and the 26 open sites at −15..−40. But those 26 aren't lost, the left bound stays at −40 and walks right through the macro, so we keep them. So the same 26 sites are counted twice: kept on the left and handed to the right as deficit.

The macro only covers 10 sites, but we extend the right by 36. The cell ends up eligible to move +76 on the strength of open space it never actually lost.

If the deficit measured how much the macro actually covers (10), it'd be dx_hi = +50, window [−40, +50], which conserves usable candidates. WDYT?

I think a two-pointer walk out from BASE would avoid this entirely: each side keeps walking through walls (a blocked site just doesn't count, it doesn't stop the pointer), collecting usable sites up to window per side, capped at 2 * window (and max_displacement). That way each wall inflates the reach on its own side by exactly what it covers, no phantom deficit dumped across, and the both-ends-walled case naturally lands on the real window instead of inflating it.

[gudeh]

• included a test which is the same as an existing one with multiple height cells.
• fixed the disabling of the window extension to actually disable every extension.
• made the requested change to the extension based on walls (macro and off-core).
  • I also realized a bug and fixed it, the extension based on walls was not happening vertically.

[gudeh]

I should push my latest changes. And I will review the last situation you described. I do not think we could have such a small macro, but a fixed instance is possible definetevely.

While I was implementing the change you requested, I also realized this limitation, we were early stopping.

[gudeh]

Latest secure-CI requires updates on two designs, PR is already open.

[maliberty]

@osamahammad21 your comments can be taken up in another PR