Skip to content

Commit 93ec814

Browse files
ethanroj23ethanroj23
committed
First pass through for RRGraphView::node_capacity
Signed-off-by: Ethan Rogers <[email protected]>
1 parent 782ff36 commit 93ec814

File tree

11 files changed

+50
-29
lines changed

11 files changed

+50
-29
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: 8 additions & 5 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);
@@ -1359,6 +1360,7 @@ bool is_valid_skeleton_tree(const t_rt_node* root) {
13591360
bool is_valid_route_tree(const t_rt_node* root) {
13601361
// check upstream resistance
13611362
auto& device_ctx = g_vpr_ctx.device();
1363+
const auto& rr_graph = device_ctx.rr_graph;
13621364
auto& route_ctx = g_vpr_ctx.routing();
13631365

13641366
constexpr float CAP_REL_TOL = 1e-6;
@@ -1393,7 +1395,7 @@ bool is_valid_route_tree(const t_rt_node* root) {
13931395
// sink, must not be congested
13941396
if (!edge) {
13951397
int occ = route_ctx.rr_node_route_inf[inode].occ();
1396-
int capacity = device_ctx.rr_nodes[inode].capacity();
1398+
int capacity = rr_graph.node_capacity(RRNodeId(inode));
13971399
if (occ > capacity) {
13981400
VTR_LOG("SINK %d occ %d > cap %d\n", inode, occ, capacity);
13991401
return false;
@@ -1437,9 +1439,10 @@ bool is_valid_route_tree(const t_rt_node* root) {
14371439
bool is_uncongested_route_tree(const t_rt_node* root) {
14381440
auto& route_ctx = g_vpr_ctx.routing();
14391441
auto& device_ctx = g_vpr_ctx.device();
1442+
const auto& rr_graph = device_ctx.rr_graph;
14401443

14411444
int inode = root->inode;
1442-
if (route_ctx.rr_node_route_inf[inode].occ() > device_ctx.rr_nodes[inode].capacity()) {
1445+
if (route_ctx.rr_node_route_inf[inode].occ() > rr_graph.node_capacity(RRNodeId(inode))) {
14431446
//This node is congested
14441447
return false;
14451448
}

‎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

‎vpr/src/route/segment_stats.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -57,11 +57,11 @@ void get_segment_usage_stats(std::vector<t_segment_inf>& segment_inf) {
5757
length = segment_inf[seg_type].length;
5858
else
5959
length = LONGLINE;
60-
60+
const short& inode_capacity = rr_graph.node_capacity(RRNodeId(inode));
6161
seg_occ_by_length[length] += route_ctx.rr_node_route_inf[inode].occ();
62-
seg_cap_by_length[length] += device_ctx.rr_nodes[inode].capacity();
62+
seg_cap_by_length[length] += inode_capacity;
6363
seg_occ_by_type[seg_type] += route_ctx.rr_node_route_inf[inode].occ();
64-
seg_cap_by_type[seg_type] += device_ctx.rr_nodes[inode].capacity();
64+
seg_cap_by_type[seg_type] += inode_capacity;
6565
}
6666
}
6767

0 commit comments

Comments
 (0)