cts: tie-break dummy-cell sort for deterministic output

[oharboe]

findCandidateDummyCells() gathers dummyCandidates by iterating the STA libraries, then std::ranges::sorts them by getInputCap() alone.

std::ranges::sort is not stable, and findBestDummyCell() subsequently takes the first candidate with the minimal |cap - deltaCap|. So among candidates with equal input cap, the selected dummy cell depends on the unspecified sort order and varies run to run — a source of nondeterminism in CTS output.

This tie-breaks the sort on the cell name so equal-cap candidates get a stable, reproducible order. Same shape as the previously-merged OptMirror tie-break.

[gemini-code-assist]

Code Review

This pull request updates the sorting logic for dummyCandidates in TritonCTS::findCandidateDummyCells to include a tie-breaker based on cell names when input capacities are equal, ensuring stable output. The review feedback suggests optimizing this tie-breaker by using std::strcmp instead of constructing std::string objects to avoid unnecessary dynamic memory allocations.

[gemini-code-assist]

Constructing std::string objects inside the sort comparator on every comparison is inefficient because it can trigger dynamic memory allocations. Since <cstring> is already included, using std::strcmp is a much more efficient way to compare the cell names without any heap allocation overhead.

        return std::strcmp(cell1->name(), cell2->name()) < 0;

[gadfort]

We really should be using return cell1->id() < cell2->id()
string compares are by far the most expensive tie break.

[oharboe]

/gemini propose fixes

[gemini-code-assist]

The proposed fix correctly addresses the non-determinism by adding a tie-break on the cell name. The logic is sound and effectively ensures a stable sort order.

If you prefer a more concise implementation, you could use std::tie with std::string_view to avoid creating std::string objects during every comparison:

std::ranges::sort(
    dummyCandidates,
    [](const sta::LibertyCell* cell1, const sta::LibertyCell* cell2) {
      return std::tie(getInputCap(cell1), std::string_view(cell1->name())) <
             std::tie(getInputCap(cell2), std::string_view(cell2->name()));
    });

This approach is functionally equivalent and slightly more idiomatic for multi-key comparisons.

[oharboe]

Thanks @gadfort — switched both the cts and rsz (#10655) tie-breaks to cell->id() < cell->id(). Integer compare, no string construction, and it matches the existing buffer comparator in Resizer.cc (findFastBuffers). Pushed as a follow-up commit.

[oharboe]

/gemini review

[gemini-code-assist]

Code Review

This pull request updates the sorting comparator for dummy candidates in TritonCTS.cpp to ensure a deterministic sort order. When the input capacitances of two cells are equal, it now falls back to comparing their cell IDs. I have no further feedback to provide as there are no review comments.

[oharboe]

Simplified the comparator to a single std::make_tuple((input-cap, id)) compare. (Used make_tuple rather than std::tie — getInputCap()/id() return prvalues, which can't bind to tie's lvalue references.)

[oharboe]

/gemini review

[gemini-code-assist]

Code Review

This pull request updates the sorting logic for dummy candidate cells in TritonCTS.cpp to ensure a deterministic sort order. By using std::tuple with both the input capacitance and the cell ID, the comparator now has a stable fallback when capacitances are equal. I have no feedback to provide.

[oharboe]

/gemini review

[gemini-code-assist]

Code Review

This pull request updates the sorting comparator for dummy cell candidates in TritonCTS to ensure a deterministic sort order. When the input capacitances of two cells are equal, it now falls back to comparing their cell IDs. There are no review comments, so no additional feedback is provided.

[oharboe]

@maliberty This was pr merge green, so should be irrelevant