Skip to content

Commit 1d61007

Browse files
osamahammad21osamahammad21
authored
Merge pull request The-OpenROAD-Project#5903 from bnmfw/drt_nodes_vec_vec
drt: nodes structure refactoring and elimination of getFlatIdx
2 parents 4be68c3 + 3f22116 commit 1d61007

File tree

2 files changed

+83
-96
lines changed

2 files changed

+83
-96
lines changed

‎src/drt/src/pa/FlexPA.h

Lines changed: 17 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -564,20 +564,19 @@ class FlexPA
564564
int curr_unique_inst_idx,
565565
int max_access_point_size);
566566

567-
void genPatternsInit(std::vector<std::unique_ptr<FlexDPNode>>& nodes,
568-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
569-
std::set<std::vector<int>>& inst_access_patterns,
570-
std::set<std::pair<int, int>>& used_access_points,
571-
std::set<std::pair<int, int>>& viol_access_points,
572-
int max_access_point_size);
567+
void genPatternsInit(
568+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
569+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
570+
std::set<std::vector<int>>& inst_access_patterns,
571+
std::set<std::pair<int, int>>& used_access_points,
572+
std::set<std::pair<int, int>>& viol_access_points);
573573

574574
void genPatterns_reset(
575-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
576-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
577-
int max_access_point_size);
575+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
576+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins);
578577

579578
void genPatterns_perform(
580-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
579+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
581580
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
582581
std::vector<int>& vio_edges,
583582
const std::set<std::pair<int, int>>& used_access_points,
@@ -587,7 +586,6 @@ class FlexPA
587586

588587
int getEdgeCost(FlexDPNode* prev_node,
589588
FlexDPNode* curr_node,
590-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
591589
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
592590
std::vector<int>& vio_edges,
593591
const std::set<std::pair<int, int>>& used_access_points,
@@ -602,20 +600,17 @@ class FlexPA
602600
* @param nodes {pin,access_point} nodes of the access pattern graph
603601
* @param pins vector of pins of the unique instance
604602
* @param used_access_points a set of all used access points
605-
* @param max_access_point_size the maximum number of access points across
606-
* all instances
607603
*
608604
* @returns a vector of ints representing the access pattern in the form:
609605
* access_pattern[pin_idx] = access_point_idx of the pin
610606
*/
611607
std::vector<int> extractAccessPatternFromNodes(
612-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
608+
const std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
613609
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
614-
std::set<std::pair<int, int>>& used_access_points,
615-
int max_access_point_size);
610+
std::set<std::pair<int, int>>& used_access_points);
616611

617612
bool genPatterns_commit(
618-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
613+
const std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
619614
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
620615
bool& is_valid,
621616
std::set<std::vector<int>>& inst_access_patterns,
@@ -625,14 +620,12 @@ class FlexPA
625620
int max_access_point_size);
626621

627622
void genPatternsPrintDebug(
628-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
629-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
630-
int max_access_point_size);
623+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
624+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins);
631625

632626
void genPatterns_print(
633-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
634-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
635-
int max_access_point_size);
627+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
628+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins);
636629

637630
int getFlatIdx(int idx_1, int idx_2, int idx_2_dim);
638631

@@ -737,7 +730,7 @@ class FlexDPNode
737730
void setPathCost(int in) { pathCost_ = in; }
738731
void setNodeCost(int in) { nodeCost_ = in; }
739732
void setPrevNode(FlexDPNode* in) { prev_node_ = in; }
740-
void setIdx(std::pair<int, int> in) { idx_ = in; }
733+
void setIdx(std::pair<int, int> in) { idx_ = std::move(in); }
741734
void setAsSource() { virtual_source_ = true; }
742735
void setAsSink() { virtual_sink_ = true; }
743736

‎src/drt/src/pa/FlexPA_prep.cpp

Lines changed: 66 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -2301,21 +2301,17 @@ int FlexPA::genPatterns_helper(
23012301
int num_edge = num_node * max_access_point_size;
23022302
int num_valid_pattern = 0;
23032303

2304-
std::vector<std::unique_ptr<FlexDPNode>> nodes(num_node);
2305-
for (int i = 0; i < num_node; ++i) {
2306-
nodes[i] = std::make_unique<FlexDPNode>();
2307-
}
2304+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>> nodes(pins.size() + 2);
23082305
std::vector<int> vio_edge(num_edge, -1);
23092306

23102307
genPatternsInit(nodes,
23112308
pins,
23122309
inst_access_patterns,
23132310
used_access_points,
2314-
viol_access_points,
2315-
max_access_point_size);
2311+
viol_access_points);
23162312

23172313
for (int i = 0; i < router_cfg_->ACCESS_PATTERN_END_ITERATION_NUM; i++) {
2318-
genPatterns_reset(nodes, pins, max_access_point_size);
2314+
genPatterns_reset(nodes, pins);
23192315
genPatterns_perform(nodes,
23202316
pins,
23212317
vio_edge,
@@ -2345,61 +2341,70 @@ int FlexPA::genPatterns_helper(
23452341

23462342
// init dp node array for valid access points
23472343
void FlexPA::genPatternsInit(
2348-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2344+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
23492345
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
23502346
std::set<std::vector<int>>& inst_access_patterns,
23512347
std::set<std::pair<int, int>>& used_access_points,
2352-
std::set<std::pair<int, int>>& viol_access_points,
2353-
int max_access_point_size)
2348+
std::set<std::pair<int, int>>& viol_access_points)
23542349
{
23552350
// clear temp storage and flag
23562351
inst_access_patterns.clear();
23572352
used_access_points.clear();
23582353
viol_access_points.clear();
23592354

23602355
// init virtual nodes
2361-
int start_node_idx = getFlatIdx(-1, 0, max_access_point_size);
2362-
nodes[start_node_idx]->setNodeCost(0);
2363-
nodes[start_node_idx]->setIdx({-1, 0});
2364-
nodes[start_node_idx]->setPathCost(0);
2365-
nodes[start_node_idx]->setAsSource();
2366-
2367-
int end_node_idx = getFlatIdx(pins.size(), 0, max_access_point_size);
2368-
nodes[end_node_idx]->setNodeCost(0);
2369-
nodes[end_node_idx]->setIdx({pins.size(), 0});
2370-
nodes[end_node_idx]->setAsSink();
2356+
const int source_node_idx = pins.size() + 1;
2357+
nodes[source_node_idx] = std::vector<std::unique_ptr<FlexDPNode>>(1);
2358+
nodes[source_node_idx][0] = std::make_unique<FlexDPNode>();
2359+
FlexDPNode* source_node = nodes[source_node_idx][0].get();
2360+
source_node->setNodeCost(0);
2361+
source_node->setIdx({pins.size() + 1, 0});
2362+
source_node->setPathCost(0);
2363+
source_node->setAsSource();
2364+
2365+
const int sink_node_idx = pins.size();
2366+
nodes[sink_node_idx] = std::vector<std::unique_ptr<FlexDPNode>>(1);
2367+
nodes[sink_node_idx][0] = std::make_unique<FlexDPNode>();
2368+
FlexDPNode* sink_node = nodes[sink_node_idx][0].get();
2369+
sink_node->setNodeCost(0);
2370+
sink_node->setIdx({pins.size(), 0});
2371+
sink_node->setAsSink();
23712372
// init pin nodes
23722373
int pin_idx = 0;
23732374
int ap_idx = 0;
23742375
int pin_access_idx = unique_insts_.getPAIndex(pins[0].second->getInst());
23752376

23762377
for (auto& [pin, inst_term] : pins) {
23772378
ap_idx = 0;
2379+
auto size = pin->getPinAccess(pin_access_idx)->getAccessPoints().size();
2380+
nodes[pin_idx] = std::vector<std::unique_ptr<FlexDPNode>>(size);
23782381
for (auto& ap : pin->getPinAccess(pin_access_idx)->getAccessPoints()) {
2379-
int node_idx = getFlatIdx(pin_idx, ap_idx, max_access_point_size);
2380-
nodes[node_idx]->setIdx({pin_idx, ap_idx});
2381-
nodes[node_idx]->setNodeCost(ap->getCost());
2382+
nodes[pin_idx][ap_idx] = std::make_unique<FlexDPNode>();
2383+
nodes[pin_idx][ap_idx]->setIdx({pin_idx, ap_idx});
2384+
nodes[pin_idx][ap_idx]->setNodeCost(ap->getCost());
23822385
ap_idx++;
23832386
}
23842387
pin_idx++;
23852388
}
23862389
}
23872390

23882391
void FlexPA::genPatterns_reset(
2389-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2390-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
2391-
int max_access_point_size)
2392+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
2393+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins)
23922394
{
2393-
for (auto& node : nodes) {
2394-
node->setPathCost(std::numeric_limits<int>::max());
2395-
node->setPrevNode(nullptr);
2395+
for (auto& pin_nodes : nodes) {
2396+
for (auto& node : pin_nodes) {
2397+
node->setPathCost(std::numeric_limits<int>::max());
2398+
node->setPrevNode(nullptr);
2399+
}
23962400
}
23972401

2398-
int start_node_idx = getFlatIdx(-1, 0, max_access_point_size);
2399-
int end_node_idx = getFlatIdx(pins.size(), 0, max_access_point_size);
2400-
nodes[start_node_idx]->setNodeCost(0);
2401-
nodes[start_node_idx]->setPathCost(0);
2402-
nodes[end_node_idx]->setNodeCost(0);
2402+
FlexDPNode* source_node = nodes[pins.size() + 1][0].get();
2403+
source_node->setNodeCost(0);
2404+
source_node->setPathCost(0);
2405+
2406+
FlexDPNode* sink_node = nodes[pins.size()][0].get();
2407+
sink_node->setNodeCost(0);
24032408
}
24042409

24052410
bool FlexPA::genPatterns_gc(
@@ -2463,38 +2468,35 @@ bool FlexPA::genPatterns_gc(
24632468
}
24642469

24652470
void FlexPA::genPatterns_perform(
2466-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2471+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
24672472
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
24682473
std::vector<int>& vio_edges,
24692474
const std::set<std::pair<int, int>>& used_access_points,
24702475
const std::set<std::pair<int, int>>& viol_access_points,
24712476
const int curr_unique_inst_idx,
24722477
const int max_access_point_size)
24732478
{
2479+
const int source_node_idx = pins.size() + 1;
24742480
for (int curr_pin_idx = 0; curr_pin_idx <= (int) pins.size();
24752481
curr_pin_idx++) {
2476-
for (int curr_acc_point_idx = 0; curr_acc_point_idx < max_access_point_size;
2482+
for (int curr_acc_point_idx = 0;
2483+
curr_acc_point_idx < (int) nodes[curr_pin_idx].size();
24772484
curr_acc_point_idx++) {
2478-
auto curr_node_idx
2479-
= getFlatIdx(curr_pin_idx, curr_acc_point_idx, max_access_point_size);
2480-
FlexDPNode* curr_node = nodes[curr_node_idx].get();
2485+
FlexDPNode* curr_node = nodes[curr_pin_idx][curr_acc_point_idx].get();
24812486
if (curr_node->getNodeCost() == std::numeric_limits<int>::max()) {
24822487
continue;
24832488
}
2484-
int prev_pin_idx = curr_pin_idx - 1;
2489+
int prev_pin_idx = curr_pin_idx > 0 ? curr_pin_idx - 1 : source_node_idx;
24852490
for (int prev_acc_point_idx = 0;
2486-
prev_acc_point_idx < max_access_point_size;
2491+
prev_acc_point_idx < nodes[prev_pin_idx].size();
24872492
prev_acc_point_idx++) {
2488-
const int prev_node_idx = getFlatIdx(
2489-
prev_pin_idx, prev_acc_point_idx, max_access_point_size);
2490-
FlexDPNode* prev_node = nodes[prev_node_idx].get();
2493+
FlexDPNode* prev_node = nodes[prev_pin_idx][prev_acc_point_idx].get();
24912494
if (prev_node->getPathCost() == std::numeric_limits<int>::max()) {
24922495
continue;
24932496
}
24942497

24952498
const int edge_cost = getEdgeCost(prev_node,
24962499
curr_node,
2497-
nodes,
24982500
pins,
24992501
vio_edges,
25002502
used_access_points,
@@ -2505,7 +2507,6 @@ void FlexPA::genPatterns_perform(
25052507
|| curr_node->getPathCost()
25062508
> prev_node->getPathCost() + edge_cost) {
25072509
curr_node->setPathCost(prev_node->getPathCost() + edge_cost);
2508-
prev_node = nodes[prev_node_idx].get();
25092510
curr_node->setPrevNode(prev_node);
25102511
}
25112512
}
@@ -2516,7 +2517,6 @@ void FlexPA::genPatterns_perform(
25162517
int FlexPA::getEdgeCost(
25172518
FlexDPNode* prev_node,
25182519
FlexDPNode* curr_node,
2519-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
25202520
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
25212521
std::vector<int>& vio_edges,
25222522
const std::set<std::pair<int, int>>& used_access_points,
@@ -2583,13 +2583,13 @@ int FlexPA::getEdgeCost(
25832583
vio_edges[edge_idx] = has_vio;
25842584

25852585
// look back for GN14
2586-
if (!has_vio && prev_node != nullptr) {
2586+
if (!has_vio) {
25872587
// check one more back
25882588
if (prev_node->hasPrevNode()) {
25892589
auto prev_prev_node = prev_node->getPrevNode();
25902590
auto [prev_prev_pin_idx, prev_prev_acc_point_idx]
25912591
= prev_prev_node->getIdx();
2592-
if (prev_prev_pin_idx != -1) {
2592+
if (!prev_prev_node->isSource()) {
25932593
const auto& [pin_3, inst_term_3] = pins[prev_prev_pin_idx];
25942594
auto pa_3 = pin_3->getPinAccess(pin_access_idx);
25952595
std::unique_ptr<frVia> via3;
@@ -2631,7 +2631,7 @@ int FlexPA::getEdgeCost(
26312631
std::make_pair(curr_pin_idx, curr_acc_point_idx))
26322632
!= viol_access_points.end()) {
26332633
edge_cost = 1000;
2634-
} else if (prev_node != nullptr) {
2634+
} else {
26352635
const int prev_node_cost = prev_node->getNodeCost();
26362636
const int curr_node_cost = curr_node->getNodeCost();
26372637
edge_cost = (prev_node_cost + curr_node_cost) / 2;
@@ -2644,18 +2644,14 @@ int FlexPA::getEdgeCost(
26442644
}
26452645

26462646
std::vector<int> FlexPA::extractAccessPatternFromNodes(
2647-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2647+
const std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
26482648
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
2649-
std::set<std::pair<int, int>>& used_access_points,
2650-
const int max_access_point_size)
2649+
std::set<std::pair<int, int>>& used_access_points)
26512650
{
26522651
std::vector<int> access_pattern(pins.size(), -1);
26532652

2654-
const int source_node_idx = getFlatIdx(-1, 0, max_access_point_size);
2655-
const FlexDPNode* source_node = nodes[source_node_idx].get();
2656-
2657-
const int sink_node_idx = getFlatIdx(pins.size(), 0, max_access_point_size);
2658-
const FlexDPNode* sink_node = nodes[sink_node_idx].get();
2653+
const FlexDPNode* source_node = nodes[pins.size() + 1][0].get();
2654+
const FlexDPNode* sink_node = nodes[pins.size()][0].get();
26592655

26602656
FlexDPNode* curr_node = sink_node->getPrevNode();
26612657

@@ -2674,7 +2670,7 @@ std::vector<int> FlexPA::extractAccessPatternFromNodes(
26742670
}
26752671

26762672
bool FlexPA::genPatterns_commit(
2677-
const std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2673+
const std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
26782674
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
26792675
bool& is_valid,
26802676
std::set<std::vector<int>>& inst_access_patterns,
@@ -2683,8 +2679,8 @@ bool FlexPA::genPatterns_commit(
26832679
const int curr_unique_inst_idx,
26842680
const int max_access_point_size)
26852681
{
2686-
std::vector<int> access_pattern = extractAccessPatternFromNodes(
2687-
nodes, pins, used_access_points, max_access_point_size);
2682+
std::vector<int> access_pattern
2683+
= extractAccessPatternFromNodes(nodes, pins, used_access_points);
26882684
// not a new access pattern
26892685
if (inst_access_patterns.find(access_pattern) != inst_access_patterns.end()) {
26902686
return false;
@@ -2773,7 +2769,7 @@ bool FlexPA::genPatterns_commit(
27732769
pin_access_pattern->updateCost();
27742770
unique_inst_patterns_[curr_unique_inst_idx].push_back(
27752771
std::move(pin_access_pattern));
2776-
// genPatterns_print(nodes, pins, max_access_point_size);
2772+
// genPatterns_print(nodes, pins);
27772773
is_valid = true;
27782774
} else {
27792775
for (int idx_1 = 0; idx_1 < (int) pins.size(); idx_1++) {
@@ -2796,12 +2792,11 @@ bool FlexPA::genPatterns_commit(
27962792
}
27972793

27982794
void FlexPA::genPatternsPrintDebug(
2799-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2800-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
2801-
int max_access_point_size)
2795+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
2796+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins)
28022797
{
2803-
int curr_node_idx = getFlatIdx(pins.size(), 0, max_access_point_size);
2804-
FlexDPNode* curr_node = nodes[curr_node_idx].get();
2798+
FlexDPNode* sink_node = nodes[pins.size() + 1][0].get();
2799+
FlexDPNode* curr_node = sink_node;
28052800
int pin_cnt = pins.size();
28062801

28072802
dbTransform xform;
@@ -2838,12 +2833,11 @@ void FlexPA::genPatternsPrintDebug(
28382833
}
28392834

28402835
void FlexPA::genPatterns_print(
2841-
std::vector<std::unique_ptr<FlexDPNode>>& nodes,
2842-
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins,
2843-
const int max_access_point_size)
2836+
std::vector<std::vector<std::unique_ptr<FlexDPNode>>>& nodes,
2837+
const std::vector<std::pair<frMPin*, frInstTerm*>>& pins)
28442838
{
2845-
int curr_node_idx = getFlatIdx(pins.size(), 0, max_access_point_size);
2846-
FlexDPNode* curr_node = nodes[curr_node_idx].get();
2839+
FlexDPNode* sink_node = nodes[pins.size() + 1][0].get();
2840+
FlexDPNode* curr_node = sink_node;
28472841
int pin_cnt = pins.size();
28482842

28492843
std::cout << "new pattern\n";

0 commit comments

Comments
 (0)