Skip to content

Commit c4416a7

Browse files
vaughnbetzvaughnbetz
authored
Merge pull request #1780 from ethanroj23/rr_graph_node_capacity
RRGraphView::node_capacity() Implementation
2 parents 1e2d018 + b3ea4b3 commit c4416a7

17 files changed

+62
-47
lines changed

‎utils/route_diag/src/main.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,6 +67,7 @@ static void do_one_route(int source_node, int sink_node,
6767
* to route this net, even ignoring congestion, it returns false. In this *
6868
* case the rr_graph is disconnected and you can give up. */
6969
auto& device_ctx = g_vpr_ctx.device();
70+
const auto& rr_graph = device_ctx.rr_graph;
7071
auto& route_ctx = g_vpr_ctx.routing();
7172

7273
t_rt_node* rt_root = init_route_tree_to_source_no_net(source_node);
@@ -123,7 +124,7 @@ static void do_one_route(int source_node, int sink_node,
123124
print_route_tree(rt_root);
124125
VTR_LOG("\n");
125126

126-
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= device_ctx.rr_nodes[rt_root->inode].capacity(), "SOURCE should never be congested");
127+
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= rr_graph.node_capacity(RRNodeId(rt_root->inode)), "SOURCE should never be congested");
127128
free_route_tree(rt_root);
128129
} else {
129130
VTR_LOG("Routed failed");

‎vpr/src/device/rr_graph_view.h

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,11 @@ class RRGraphView {
5757
return node_storage_.node_type(node);
5858
}
5959

60+
/* Get the capacity of a routing resource node. This function is inlined for runtime optimization. */
61+
inline short node_capacity(RRNodeId node) const {
62+
return node_storage_.node_capacity(node);
63+
}
64+
6065
/* Return the fast look-up data structure for queries from client functions */
6166
const RRSpatialLookup& node_lookup() const {
6267
return node_lookup_;

‎vpr/src/draw/draw.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1111,7 +1111,7 @@ static void draw_congestion(ezgl::renderer* g) {
11111111
std::vector<int> congested_rr_nodes = collect_congested_rr_nodes();
11121112
for (int inode : congested_rr_nodes) {
11131113
short occ = route_ctx.rr_node_route_inf[inode].occ();
1114-
short capacity = device_ctx.rr_nodes[inode].capacity();
1114+
short capacity = rr_graph.node_capacity(RRNodeId(inode));
11151115

11161116
float congestion_ratio = float(occ) / capacity;
11171117

@@ -1133,10 +1133,10 @@ static void draw_congestion(ezgl::renderer* g) {
11331133
//valued nodes are not overdrawn by lower value ones (e.g-> when zoomed-out far)
11341134
auto cmp_ascending_acc_cost = [&](int lhs_node, int rhs_node) {
11351135
short lhs_occ = route_ctx.rr_node_route_inf[lhs_node].occ();
1136-
short lhs_capacity = device_ctx.rr_nodes[lhs_node].capacity();
1136+
short lhs_capacity = rr_graph.node_capacity(RRNodeId(lhs_node));
11371137

11381138
short rhs_occ = route_ctx.rr_node_route_inf[rhs_node].occ();
1139-
short rhs_capacity = device_ctx.rr_nodes[rhs_node].capacity();
1139+
short rhs_capacity = rr_graph.node_capacity(RRNodeId(rhs_node));
11401140

11411141
float lhs_cong_ratio = float(lhs_occ) / lhs_capacity;
11421142
float rhs_cong_ratio = float(rhs_occ) / rhs_capacity;
@@ -1170,7 +1170,7 @@ static void draw_congestion(ezgl::renderer* g) {
11701170
//Draw each congested node
11711171
for (int inode : congested_rr_nodes) {
11721172
short occ = route_ctx.rr_node_route_inf[inode].occ();
1173-
short capacity = device_ctx.rr_nodes[inode].capacity();
1173+
short capacity = rr_graph.node_capacity(RRNodeId(inode));
11741174

11751175
float congestion_ratio = float(occ) / capacity;
11761176

‎vpr/src/route/check_rr_graph.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -305,7 +305,7 @@ void check_rr_node(int inode, enum e_route_type route_type, const DeviceContext&
305305
ylow = device_ctx.rr_nodes[inode].ylow();
306306
yhigh = device_ctx.rr_nodes[inode].yhigh();
307307
ptc_num = device_ctx.rr_nodes[inode].ptc_num();
308-
capacity = device_ctx.rr_nodes[inode].capacity();
308+
capacity = rr_graph.node_capacity(RRNodeId(inode));
309309
cost_index = device_ctx.rr_nodes[inode].cost_index();
310310
type = nullptr;
311311

‎vpr/src/route/overuse_report.cpp

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ static void log_single_overused_node_status(int overuse_index, RRNodeId inode);
2828
*/
2929
void log_overused_nodes_status(int max_logged_overused_rr_nodes) {
3030
const auto& device_ctx = g_vpr_ctx.device();
31+
const auto& rr_graph = device_ctx.rr_graph;
3132
const auto& route_ctx = g_vpr_ctx.routing();
3233

3334
//Print overuse info header
@@ -36,7 +37,7 @@ void log_overused_nodes_status(int max_logged_overused_rr_nodes) {
3637
//Print overuse info body
3738
int overuse_index = 0;
3839
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
39-
int overuse = route_ctx.rr_node_route_inf[inode].occ() - device_ctx.rr_nodes[inode].capacity();
40+
int overuse = route_ctx.rr_node_route_inf[inode].occ() - rr_graph.node_capacity(RRNodeId(inode));
4041

4142
if (overuse > 0) {
4243
log_single_overused_node_status(overuse_index, RRNodeId(inode));
@@ -130,6 +131,7 @@ void report_overused_nodes() {
130131
*/
131132
void generate_overused_nodes_to_congested_net_lookup(std::map<RRNodeId, std::set<ClusterNetId>>& nodes_to_nets_lookup) {
132133
const auto& device_ctx = g_vpr_ctx.device();
134+
const auto& rr_graph = device_ctx.rr_graph;
133135
const auto& route_ctx = g_vpr_ctx.routing();
134136
const auto& cluster_ctx = g_vpr_ctx.clustering();
135137

@@ -139,7 +141,7 @@ void generate_overused_nodes_to_congested_net_lookup(std::map<RRNodeId, std::set
139141
for (t_trace* tptr = route_ctx.trace[net_id].head; tptr != nullptr; tptr = tptr->next) {
140142
int inode = tptr->index;
141143

142-
int overuse = route_ctx.rr_node_route_inf[inode].occ() - device_ctx.rr_nodes[inode].capacity();
144+
int overuse = route_ctx.rr_node_route_inf[inode].occ() - rr_graph.node_capacity(RRNodeId(inode));
143145
if (overuse > 0) {
144146
nodes_to_nets_lookup[RRNodeId(inode)].insert(net_id);
145147
}

‎vpr/src/route/route_common.cpp

Lines changed: 13 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -325,10 +325,11 @@ bool feasible_routing() {
325325
* that the occupancy arrays are up to date when it is called. */
326326

327327
auto& device_ctx = g_vpr_ctx.device();
328+
const auto& rr_graph = device_ctx.rr_graph;
328329
auto& route_ctx = g_vpr_ctx.routing();
329330

330331
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
331-
if (route_ctx.rr_node_route_inf[inode].occ() > device_ctx.rr_nodes[inode].capacity()) {
332+
if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
332333
return (false);
333334
}
334335
}
@@ -339,12 +340,13 @@ bool feasible_routing() {
339340
//Returns all RR nodes in the current routing which are congested
340341
std::vector<int> collect_congested_rr_nodes() {
341342
auto& device_ctx = g_vpr_ctx.device();
343+
const auto& rr_graph = device_ctx.rr_graph;
342344
auto& route_ctx = g_vpr_ctx.routing();
343345

344346
std::vector<int> congested_rr_nodes;
345347
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
346348
short occ = route_ctx.rr_node_route_inf[inode].occ();
347-
short capacity = device_ctx.rr_nodes[inode].capacity();
349+
short capacity = rr_graph.node_capacity(RRNodeId(inode));
348350

349351
if (occ > capacity) {
350352
congested_rr_nodes.push_back(inode);
@@ -424,11 +426,12 @@ void pathfinder_update_acc_cost_and_overuse_info(float acc_fac, OveruseInfo& ove
424426
* This routine also creates a new overuse info for the current routing iteration. */
425427

426428
auto& device_ctx = g_vpr_ctx.device();
429+
const auto& rr_graph = device_ctx.rr_graph;
427430
auto& route_ctx = g_vpr_ctx.mutable_routing();
428431
size_t overused_nodes = 0, total_overuse = 0, worst_overuse = 0;
429432

430433
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
431-
int overuse = route_ctx.rr_node_route_inf[inode].occ() - device_ctx.rr_nodes[inode].capacity();
434+
int overuse = route_ctx.rr_node_route_inf[inode].occ() - rr_graph.node_capacity(RRNodeId(inode));
432435

433436
// If overused, update the acc_cost and add this node to the overuse info
434437
// If not, do nothing
@@ -1453,9 +1456,10 @@ static void adjust_one_rr_occ_and_acc_cost(int inode, int add_or_sub, float acc_
14531456

14541457
auto& route_ctx = g_vpr_ctx.mutable_routing();
14551458
auto& device_ctx = g_vpr_ctx.device();
1459+
const auto& rr_graph = device_ctx.rr_graph;
14561460

14571461
int new_occ = route_ctx.rr_node_route_inf[inode].occ() + add_or_sub;
1458-
int capacity = device_ctx.rr_nodes[inode].capacity();
1462+
int capacity = rr_graph.node_capacity(RRNodeId(inode));
14591463
route_ctx.rr_node_route_inf[inode].set_occ(new_occ);
14601464

14611465
if (new_occ < capacity) {
@@ -1512,7 +1516,7 @@ void print_traceback(const t_trace* trace) {
15121516
VTR_LOG("*"); //Reached non-configurably
15131517
}
15141518

1515-
if (route_ctx.rr_node_route_inf[inode].occ() > device_ctx.rr_nodes[inode].capacity()) {
1519+
if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
15161520
VTR_LOG(" x"); //Overused
15171521
}
15181522
VTR_LOG("\n");
@@ -1587,6 +1591,7 @@ bool validate_traceback_recurr(t_trace* trace, std::set<int>& seen_rr_nodes) {
15871591
//Print information about an invalid routing, caused by overused routing resources
15881592
void print_invalid_routing_info() {
15891593
auto& device_ctx = g_vpr_ctx.device();
1594+
const auto& rr_graph = device_ctx.rr_graph;
15901595
auto& cluster_ctx = g_vpr_ctx.clustering();
15911596
auto& route_ctx = g_vpr_ctx.routing();
15921597

@@ -1604,7 +1609,7 @@ void print_invalid_routing_info() {
16041609

16051610
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
16061611
int occ = route_ctx.rr_node_route_inf[inode].occ();
1607-
int cap = device_ctx.rr_nodes[inode].capacity();
1612+
int cap = rr_graph.node_capacity(RRNodeId(inode));
16081613
if (occ > cap) {
16091614
VTR_LOG(" %s is overused (occ=%d capacity=%d)\n", describe_rr_node(inode).c_str(), occ, cap);
16101615

@@ -1641,13 +1646,14 @@ void print_rr_node_route_inf() {
16411646
void print_rr_node_route_inf_dot() {
16421647
auto& route_ctx = g_vpr_ctx.routing();
16431648
auto& device_ctx = g_vpr_ctx.device();
1649+
const auto& rr_graph = device_ctx.rr_graph;
16441650

16451651
VTR_LOG("digraph G {\n");
16461652
VTR_LOG("\tnode[shape=record]\n");
16471653
for (size_t inode = 0; inode < route_ctx.rr_node_route_inf.size(); ++inode) {
16481654
if (!std::isinf(route_ctx.rr_node_route_inf[inode].path_cost)) {
16491655
VTR_LOG("\tnode%zu[label=\"{%zu (%s)", inode, inode, device_ctx.rr_nodes[inode].type_string());
1650-
if (route_ctx.rr_node_route_inf[inode].occ() > device_ctx.rr_nodes[inode].capacity()) {
1656+
if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
16511657
VTR_LOG(" x");
16521658
}
16531659
VTR_LOG("}\"]\n");

‎vpr/src/route/route_common.h

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -49,10 +49,11 @@ inline float get_single_rr_cong_acc_cost(int inode) {
4949
/* Returns the present congestion cost of using this rr_node */
5050
inline float get_single_rr_cong_pres_cost(int inode, float pres_fac) {
5151
auto& device_ctx = g_vpr_ctx.device();
52+
const auto& rr_graph = device_ctx.rr_graph;
5253
auto& route_ctx = g_vpr_ctx.routing();
5354

5455
int occ = route_ctx.rr_node_route_inf[inode].occ();
55-
int capacity = device_ctx.rr_nodes[inode].capacity();
56+
int capacity = rr_graph.node_capacity(RRNodeId(inode));
5657

5758
if (occ >= capacity) {
5859
return (1. + pres_fac * (occ + 1 - capacity));
@@ -65,10 +66,11 @@ inline float get_single_rr_cong_pres_cost(int inode, float pres_fac) {
6566
* *ignoring* non-configurable edges */
6667
inline float get_single_rr_cong_cost(int inode, float pres_fac) {
6768
auto& device_ctx = g_vpr_ctx.device();
69+
const auto& rr_graph = device_ctx.rr_graph;
6870
auto& route_ctx = g_vpr_ctx.routing();
6971

7072
float pres_cost;
71-
int overuse = route_ctx.rr_node_route_inf[inode].occ() - device_ctx.rr_nodes[inode].capacity();
73+
int overuse = route_ctx.rr_node_route_inf[inode].occ() - rr_graph.node_capacity(RRNodeId(inode));
7274

7375
if (overuse >= 0) {
7476
pres_cost = (1. + pres_fac * (overuse + 1));

‎vpr/src/route/route_timing.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1163,7 +1163,7 @@ bool timing_driven_route_net(ConnectionRouter& router,
11631163
}
11641164
}
11651165
}
1166-
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= device_ctx.rr_nodes[rt_root->inode].capacity(), "SOURCE should never be congested");
1166+
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= rr_graph.node_capacity(RRNodeId(rt_root->inode)), "SOURCE should never be congested");
11671167

11681168
// route tree is not kept persistent since building it from the traceback the next iteration takes almost 0 time
11691169
VTR_LOGV_DEBUG(f_router_debug, "Routed Net %zu (%zu sinks)\n", size_t(net_id), num_sinks);
@@ -1597,6 +1597,7 @@ static bool timing_driven_check_net_delays(ClbNetPinsMatrix<float>& net_delay) {
15971597
static bool should_route_net(ClusterNetId net_id, CBRR& connections_inf, bool if_force_reroute) {
15981598
auto& route_ctx = g_vpr_ctx.routing();
15991599
auto& device_ctx = g_vpr_ctx.device();
1600+
const auto& rr_graph = device_ctx.rr_graph;
16001601

16011602
t_trace* tptr = route_ctx.trace[net_id].head;
16021603

@@ -1608,7 +1609,7 @@ static bool should_route_net(ClusterNetId net_id, CBRR& connections_inf, bool if
16081609
for (;;) {
16091610
int inode = tptr->index;
16101611
int occ = route_ctx.rr_node_route_inf[inode].occ();
1611-
int capacity = device_ctx.rr_nodes[inode].capacity();
1612+
int capacity = rr_graph.node_capacity(RRNodeId(inode));
16121613

16131614
if (occ > capacity) {
16141615
return true; /* overuse detected */
@@ -1672,7 +1673,7 @@ static size_t calculate_wirelength_available() {
16721673
size_t length_x = device_ctx.rr_nodes[i].xhigh() - device_ctx.rr_nodes[i].xlow();
16731674
size_t length_y = device_ctx.rr_nodes[i].yhigh() - device_ctx.rr_nodes[i].ylow();
16741675

1675-
available_wirelength += device_ctx.rr_nodes[i].capacity() * (length_x + length_y + 1);
1676+
available_wirelength += rr_graph.node_capacity(RRNodeId(i)) * (length_x + length_y + 1);
16761677
}
16771678
}
16781679
return available_wirelength;

‎vpr/src/route/route_tree_timing.cpp

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -686,6 +686,7 @@ void print_route_tree(const t_rt_node* rt_node, int depth) {
686686
}
687687

688688
auto& device_ctx = g_vpr_ctx.device();
689+
const auto& rr_graph = device_ctx.rr_graph;
689690
VTR_LOG("%srt_node: %d (%s) \t ipin: %d \t R: %g \t C: %g \t delay: %g",
690691
indent.c_str(), rt_node->inode, device_ctx.rr_nodes[rt_node->inode].type_string(), rt_node->net_pin_index, rt_node->R_upstream, rt_node->C_downstream, rt_node->Tdel);
691692

@@ -697,7 +698,7 @@ void print_route_tree(const t_rt_node* rt_node, int depth) {
697698
}
698699

699700
auto& route_ctx = g_vpr_ctx.routing();
700-
if (route_ctx.rr_node_route_inf[rt_node->inode].occ() > device_ctx.rr_nodes[rt_node->inode].capacity()) {
701+
if (route_ctx.rr_node_route_inf[rt_node->inode].occ() > rr_graph.node_capacity(RRNodeId(rt_node->inode))) {
701702
VTR_LOG(" x");
702703
}
703704

@@ -978,7 +979,7 @@ static t_rt_node* prune_route_tree_recurr(t_rt_node* node, CBRR& connections_inf
978979
auto& device_ctx = g_vpr_ctx.device();
979980
const auto& rr_graph = device_ctx.rr_graph;
980981
auto& route_ctx = g_vpr_ctx.routing();
981-
bool congested = (route_ctx.rr_node_route_inf[node->inode].occ() > device_ctx.rr_nodes[node->inode].capacity());
982+
bool congested = (route_ctx.rr_node_route_inf[node->inode].occ() > rr_graph.node_capacity(RRNodeId(node->inode)));
982983
int node_set = -1;
983984
auto itr = device_ctx.rr_node_to_non_config_node_set.find(node->inode);
984985
if (itr != device_ctx.rr_node_to_non_config_node_set.end()) {
@@ -1175,7 +1176,7 @@ t_rt_node* prune_route_tree(t_rt_node* rt_root, CBRR& connections_inf, std::vect
11751176

11761177
VTR_ASSERT_MSG(rr_graph.node_type(RRNodeId(rt_root->inode)) == SOURCE, "Root of route tree must be SOURCE");
11771178

1178-
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= device_ctx.rr_nodes[rt_root->inode].capacity(),
1179+
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= rr_graph.node_capacity(RRNodeId(rt_root->inode)),
11791180
"Route tree root/SOURCE should never be congested");
11801181

11811182
return prune_route_tree_recurr(rt_root, connections_inf, false, non_config_node_set_usage);
@@ -1275,13 +1276,14 @@ static void print_node_inf(const t_rt_node* rt_node) {
12751276

12761277
static void print_node_congestion(const t_rt_node* rt_node) {
12771278
auto& device_ctx = g_vpr_ctx.device();
1279+
const auto& rr_graph = device_ctx.rr_graph;
12781280
auto& route_ctx = g_vpr_ctx.routing();
12791281

12801282
int inode = rt_node->inode;
12811283
const auto& node_inf = route_ctx.rr_node_route_inf[inode];
1282-
const auto& node = device_ctx.rr_nodes[inode];
1284+
const short& node_capacity = rr_graph.node_capacity(RRNodeId(inode));
12831285
VTR_LOG("%2d %2d|%-6d-> ", node_inf.acc_cost, rt_node->Tdel,
1284-
node_inf.occ(), node.capacity(), inode);
1286+
node_inf.occ(), node_capacity, inode);
12851287
}
12861288

12871289
void print_route_tree_inf(const t_rt_node* rt_root) {
@@ -1359,6 +1361,7 @@ bool is_valid_skeleton_tree(const t_rt_node* root) {
13591361
bool is_valid_route_tree(const t_rt_node* root) {
13601362
// check upstream resistance
13611363
auto& device_ctx = g_vpr_ctx.device();
1364+
const auto& rr_graph = device_ctx.rr_graph;
13621365
auto& route_ctx = g_vpr_ctx.routing();
13631366

13641367
constexpr float CAP_REL_TOL = 1e-6;
@@ -1393,7 +1396,7 @@ bool is_valid_route_tree(const t_rt_node* root) {
13931396
// sink, must not be congested
13941397
if (!edge) {
13951398
int occ = route_ctx.rr_node_route_inf[inode].occ();
1396-
int capacity = device_ctx.rr_nodes[inode].capacity();
1399+
int capacity = rr_graph.node_capacity(RRNodeId(inode));
13971400
if (occ > capacity) {
13981401
VTR_LOG("SINK %d occ %d > cap %d\n", inode, occ, capacity);
13991402
return false;
@@ -1437,9 +1440,10 @@ bool is_valid_route_tree(const t_rt_node* root) {
14371440
bool is_uncongested_route_tree(const t_rt_node* root) {
14381441
auto& route_ctx = g_vpr_ctx.routing();
14391442
auto& device_ctx = g_vpr_ctx.device();
1443+
const auto& rr_graph = device_ctx.rr_graph;
14401444

14411445
int inode = root->inode;
1442-
if (route_ctx.rr_node_route_inf[inode].occ() > device_ctx.rr_nodes[inode].capacity()) {
1446+
if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
14431447
//This node is congested
14441448
return false;
14451449
}

‎vpr/src/route/route_util.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -61,22 +61,23 @@ vtr::Matrix<float> calculate_routing_avail(t_rr_type rr_type) {
6161
vtr::Matrix<float> avail({{device_ctx.grid.width(), device_ctx.grid.height()}}, 0.);
6262
for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
6363
auto& rr_node = device_ctx.rr_nodes[inode];
64+
const short& rr_node_capacity = rr_graph.node_capacity(RRNodeId(inode));
6465

6566
if (rr_graph.node_type(RRNodeId(inode)) == CHANX && rr_type == CHANX) {
6667
VTR_ASSERT(rr_graph.node_type(RRNodeId(inode)) == CHANX);
6768
VTR_ASSERT(rr_node.ylow() == rr_node.yhigh());
6869

6970
int y = rr_node.ylow();
7071
for (int x = rr_node.xlow(); x <= rr_node.xhigh(); ++x) {
71-
avail[x][y] += rr_node.capacity();
72+
avail[x][y] += rr_node_capacity;
7273
}
7374
} else if (rr_graph.node_type(RRNodeId(inode)) == CHANY && rr_type == CHANY) {
7475
VTR_ASSERT(rr_graph.node_type(RRNodeId(inode)) == CHANY);
7576
VTR_ASSERT(rr_node.xlow() == rr_node.xhigh());
7677

7778
int x = rr_node.xlow();
7879
for (int y = rr_node.ylow(); y <= rr_node.yhigh(); ++y) {
79-
avail[x][y] += rr_node.capacity();
80+
avail[x][y] += rr_node_capacity;
8081
}
8182
}
8283
}

‎vpr/src/route/router_delay_profiling.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@ bool RouterDelayProfiler::calculate_delay(int source_node, int sink_node, const
2727
* to route this net, even ignoring congestion, it returns false. In this *
2828
* case the rr_graph is disconnected and you can give up. */
2929
auto& device_ctx = g_vpr_ctx.device();
30+
const auto& rr_graph = device_ctx.rr_graph;
3031
auto& route_ctx = g_vpr_ctx.routing();
3132

3233
//vtr::ScopedStartFinishTimer t(vtr::string_fmt("Profiling Delay from %s at %d,%d (%s) to %s at %d,%d (%s)",
@@ -79,7 +80,7 @@ bool RouterDelayProfiler::calculate_delay(int source_node, int sink_node, const
7980
//find delay
8081
*net_delay = rt_node_of_sink->Tdel;
8182

82-
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= device_ctx.rr_nodes[rt_root->inode].capacity(), "SOURCE should never be congested");
83+
VTR_ASSERT_MSG(route_ctx.rr_node_route_inf[rt_root->inode].occ() <= rr_graph.node_capacity(RRNodeId(rt_root->inode)), "SOURCE should never be congested");
8384
free_route_tree(rt_root);
8485
}
8586

0 commit comments

Comments
 (0)