diff --git a/utils/fasm/test/test_fasm.cpp b/utils/fasm/test/test_fasm.cpp
index 963bc8ca602..91bf57d99cf 100644
--- a/utils/fasm/test/test_fasm.cpp
+++ b/utils/fasm/test/test_fasm.cpp
@@ -255,7 +255,7 @@ TEST_CASE("fasm_integration_test", "[fasm]") {
         auto &device_ctx = g_vpr_ctx.mutable_device();
         const auto& rr_graph = device_ctx.rr_graph;
         for(size_t inode = 0; inode < device_ctx.rr_nodes.size(); ++inode) {
-            for(t_edge_size iedge = 0; iedge < device_ctx.rr_nodes[inode].num_edges(); ++iedge) {
+            for(t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(inode)); ++iedge) {
                 auto sink_inode = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
                 auto switch_id = device_ctx.rr_nodes[inode].edge_switch(iedge);
                 auto value = vtr::string_fmt("%d_%d_%zu",
diff --git a/vpr/src/device/rr_graph_view.h b/vpr/src/device/rr_graph_view.h
index 8b7712379df..c5647c06c90 100644
--- a/vpr/src/device/rr_graph_view.h
+++ b/vpr/src/device/rr_graph_view.h
@@ -249,6 +249,36 @@ class RRGraphView {
         return node_storage_.node_side_string(node);
     }
 
+    /** @brief Get the number of configurable edges. This function is inlined for runtime optimization. */
+    inline t_edge_size num_configurable_edges(RRNodeId node) const {
+        return node_storage_.num_configurable_edges(node);
+    }
+
+    /** @brief Get the number of non-configurable edges. This function is inlined for runtime optimization. */
+    inline t_edge_size num_non_configurable_edges(RRNodeId node) const {
+        return node_storage_.num_non_configurable_edges(node);
+    }
+
+    /** @brief Get ID range for configurable edges. This function is inlined for runtime optimization. */
+    inline edge_idx_range configurable_edges(RRNodeId node) const {
+        return node_storage_.configurable_edges(node);
+    }
+
+    /** @brief Get ID range for non-configurable edges. This function is inlined for runtime optimization. */
+    inline edge_idx_range non_configurable_edges(RRNodeId node) const {
+        return node_storage_.non_configurable_edges(node);
+    }
+
+    /** @brief Get ID range for edges. This function is inlined for runtime optimization. */
+    inline edge_idx_range edges(RRNodeId node) const {
+        return node_storage_.edges(node);
+    }
+
+    /** @brief Get the number of edges. This function is inlined for runtime optimization. */
+    inline t_edge_size num_edges(RRNodeId node) const {
+        return node_storage_.num_edges(node);
+    }
+
     /** @brief The ptc_num carries different meanings for different node types 
      * (true in VPR RRG that is currently supported, may not be true in customized RRG) 
      * CHANX or CHANY: the track id in routing channels 
diff --git a/vpr/src/draw/draw.cpp b/vpr/src/draw/draw.cpp
index 72e37a056b1..896e6b66698 100644
--- a/vpr/src/draw/draw.cpp
+++ b/vpr/src/draw/draw.cpp
@@ -1688,7 +1688,7 @@ static void draw_rr_edges(int inode, ezgl::renderer* g) {
 
     from_ptc_num = rr_graph.node_ptc_num(RRNodeId(inode));
 
-    for (t_edge_size iedge = 0, l = device_ctx.rr_nodes[inode].num_edges(); iedge < l; iedge++) {
+    for (t_edge_size iedge = 0, l = rr_graph.num_edges(RRNodeId(inode)); iedge < l; iedge++) {
         to_node = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
         to_type = rr_graph.node_type(RRNodeId(to_node));
         to_ptc_num = rr_graph.node_ptc_num(RRNodeId(to_node));
@@ -2697,10 +2697,11 @@ void highlight_nets(char* message, int hit_node) {
 void draw_highlight_fan_in_fan_out(const std::set<int>& nodes) {
     t_draw_state* draw_state = get_draw_state_vars();
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
 
     for (auto node : nodes) {
         /* Highlight the fanout nodes in red. */
-        for (t_edge_size iedge = 0, l = device_ctx.rr_nodes[node].num_edges();
+        for (t_edge_size iedge = 0, l = rr_graph.num_edges(RRNodeId(node));
              iedge < l; iedge++) {
             int fanout_node = device_ctx.rr_nodes[node].edge_sink_node(iedge);
 
@@ -2719,7 +2720,7 @@ void draw_highlight_fan_in_fan_out(const std::set<int>& nodes) {
 
         /* Highlight the nodes that can fanin to this node in blue. */
         for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
-            for (t_edge_size iedge = 0, l = device_ctx.rr_nodes[inode].num_edges(); iedge < l;
+            for (t_edge_size iedge = 0, l = rr_graph.num_edges(RRNodeId(inode)); iedge < l;
                  iedge++) {
                 int fanout_node = device_ctx.rr_nodes[inode].edge_sink_node(
                     iedge);
@@ -2823,11 +2824,12 @@ std::set<int> draw_expand_non_configurable_rr_nodes(int from_node) {
 void draw_expand_non_configurable_rr_nodes_recurr(int from_node,
                                                   std::set<int>& expanded_nodes) {
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
 
     expanded_nodes.insert(from_node);
 
     for (t_edge_size iedge = 0;
-         iedge < device_ctx.rr_nodes[from_node].num_edges(); ++iedge) {
+         iedge < rr_graph.num_edges(RRNodeId(from_node)); ++iedge) {
         bool edge_configurable = device_ctx.rr_nodes[from_node].edge_is_configurable(iedge);
         int to_node = device_ctx.rr_nodes[from_node].edge_sink_node(iedge);
 
@@ -3783,8 +3785,9 @@ bool trace_routed_connection_rr_nodes_recurr(const t_rt_node* rt_node,
 //Find the edge between two rr nodes
 static t_edge_size find_edge(int prev_inode, int inode) {
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
     for (t_edge_size iedge = 0;
-         iedge < device_ctx.rr_nodes[prev_inode].num_edges(); ++iedge) {
+         iedge < rr_graph.num_edges(RRNodeId(prev_inode)); ++iedge) {
         if (device_ctx.rr_nodes[prev_inode].edge_sink_node(iedge) == inode) {
             return iedge;
         }
diff --git a/vpr/src/place/timing_place_lookup.cpp b/vpr/src/place/timing_place_lookup.cpp
index 7dfbed7d686..28b818b3d3d 100644
--- a/vpr/src/place/timing_place_lookup.cpp
+++ b/vpr/src/place/timing_place_lookup.cpp
@@ -1166,16 +1166,16 @@ bool directconnect_exists(int src_rr_node, int sink_rr_node) {
     VTR_ASSERT(rr_graph.node_type(RRNodeId(src_rr_node)) == SOURCE && rr_graph.node_type(RRNodeId(sink_rr_node)) == SINK);
 
     //TODO: This is a constant depth search, but still may be too slow
-    for (t_edge_size i_src_edge = 0; i_src_edge < rr_nodes[src_rr_node].num_edges(); ++i_src_edge) {
+    for (t_edge_size i_src_edge = 0; i_src_edge < rr_graph.num_edges(RRNodeId(src_rr_node)); ++i_src_edge) {
         int opin_rr_node = rr_nodes[src_rr_node].edge_sink_node(i_src_edge);
 
         if (rr_graph.node_type(RRNodeId(opin_rr_node)) != OPIN) continue;
 
-        for (t_edge_size i_opin_edge = 0; i_opin_edge < rr_nodes[opin_rr_node].num_edges(); ++i_opin_edge) {
+        for (t_edge_size i_opin_edge = 0; i_opin_edge < rr_graph.num_edges(RRNodeId(opin_rr_node)); ++i_opin_edge) {
             int ipin_rr_node = rr_nodes[opin_rr_node].edge_sink_node(i_opin_edge);
             if (rr_graph.node_type(RRNodeId(ipin_rr_node)) != IPIN) continue;
 
-            for (t_edge_size i_ipin_edge = 0; i_ipin_edge < rr_nodes[ipin_rr_node].num_edges(); ++i_ipin_edge) {
+            for (t_edge_size i_ipin_edge = 0; i_ipin_edge < rr_graph.num_edges(RRNodeId(ipin_rr_node)); ++i_ipin_edge) {
                 if (sink_rr_node == rr_nodes[ipin_rr_node].edge_sink_node(i_ipin_edge)) {
                     return true;
                 }
diff --git a/vpr/src/power/power.cpp b/vpr/src/power/power.cpp
index 3fce2e3c391..92900115c1a 100644
--- a/vpr/src/power/power.cpp
+++ b/vpr/src/power/power.cpp
@@ -821,7 +821,7 @@ static void power_usage_routing(t_power_usage* power_usage,
                 continue;
             }
 
-            for (t_edge_size edge_idx = 0; edge_idx < node.num_edges(); edge_idx++) {
+            for (t_edge_size edge_idx = 0; edge_idx < rr_graph.num_edges(RRNodeId(trace->index)); edge_idx++) {
                 const auto& next_node_id = node.edge_sink_node(edge_idx);
                 if (next_node_id != OPEN) {
                     t_rr_node_power* next_node_power = &rr_node_power[next_node_id];
@@ -981,7 +981,7 @@ static void power_usage_routing(t_power_usage* power_usage,
                 /* Determine types of switches that this wire drives */
                 connectionbox_fanout = 0;
                 switchbox_fanout = 0;
-                for (t_edge_size iedge = 0; iedge < node.num_edges(); iedge++) {
+                for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(rr_node); iedge++) {
                     if (node.edge_switch(iedge) == routing_arch->wire_to_rr_ipin_switch) {
                         connectionbox_fanout++;
                     } else if (node.edge_switch(iedge) == routing_arch->delayless_switch) {
@@ -1225,7 +1225,7 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
                 break;
             case CHANX:
             case CHANY:
-                for (t_edge_size iedge = 0; iedge < node.num_edges(); iedge++) {
+                for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(rr_node_idx)); iedge++) {
                     if (node.edge_switch(iedge) == routing_arch->wire_to_rr_ipin_switch) {
                         fanout_to_IPIN++;
                     } else if (node.edge_switch(iedge) != routing_arch->delayless_switch) {
@@ -1260,7 +1260,7 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     for (size_t rr_node_idx = 0; rr_node_idx < device_ctx.rr_nodes.size(); rr_node_idx++) {
         auto node = device_ctx.rr_nodes[rr_node_idx];
 
-        for (t_edge_size edge_idx = 0; edge_idx < node.num_edges(); edge_idx++) {
+        for (t_edge_size edge_idx = 0; edge_idx < rr_graph.num_edges(RRNodeId(rr_node_idx)); edge_idx++) {
             if (node.edge_sink_node(edge_idx) != OPEN) {
                 if (rr_node_power[node.edge_sink_node(edge_idx)].driver_switch_type == OPEN) {
                     rr_node_power[node.edge_sink_node(edge_idx)].driver_switch_type = node.edge_switch(edge_idx);
@@ -1274,13 +1274,11 @@ void power_routing_init(const t_det_routing_arch* routing_arch) {
     /* Find Max Fanout of Routing Buffer	 */
     t_edge_size max_seg_fanout = 0;
     for (size_t rr_node_idx = 0; rr_node_idx < device_ctx.rr_nodes.size(); rr_node_idx++) {
-        auto node = device_ctx.rr_nodes[rr_node_idx];
-
         switch (rr_graph.node_type(RRNodeId(rr_node_idx))) {
             case CHANX:
             case CHANY:
-                if (node.num_edges() > max_seg_fanout) {
-                    max_seg_fanout = node.num_edges();
+                if (rr_graph.num_edges(RRNodeId(rr_node_idx)) > max_seg_fanout) {
+                    max_seg_fanout = rr_graph.num_edges(RRNodeId(rr_node_idx));
                 }
                 break;
             default:
diff --git a/vpr/src/route/check_route.cpp b/vpr/src/route/check_route.cpp
index cb1995a00e0..e352a1fcdf0 100644
--- a/vpr/src/route/check_route.cpp
+++ b/vpr/src/route/check_route.cpp
@@ -309,7 +309,7 @@ static bool check_adjacent(int from_node, int to_node) {
 
     reached = false;
 
-    for (t_edge_size iconn = 0; iconn < device_ctx.rr_nodes[from_node].num_edges(); iconn++) {
+    for (t_edge_size iconn = 0; iconn < rr_graph.num_edges(RRNodeId(from_node)); iconn++) {
         if (device_ctx.rr_nodes[from_node].edge_sink_node(iconn) == to_node) {
             reached = true;
             break;
diff --git a/vpr/src/route/check_rr_graph.cpp b/vpr/src/route/check_rr_graph.cpp
index a9d2811d5e2..c778741f22d 100644
--- a/vpr/src/route/check_rr_graph.cpp
+++ b/vpr/src/route/check_rr_graph.cpp
@@ -71,7 +71,7 @@ void check_rr_graph(const t_graph_type graph_type,
         }
 
         t_rr_type rr_type = rr_graph.node_type(rr_node);
-        int num_edges = device_ctx.rr_nodes[inode].num_edges();
+        int num_edges = rr_graph.num_edges(RRNodeId(inode));
 
         check_rr_node(inode, route_type, device_ctx);
 
@@ -184,14 +184,14 @@ void check_rr_graph(const t_graph_type graph_type,
         check_unbuffered_edges(inode);
 
         //Check that all config/non-config edges are appropriately organized
-        for (auto edge : device_ctx.rr_nodes[inode].configurable_edges()) {
+        for (auto edge : rr_graph.configurable_edges(RRNodeId(inode))) {
             if (!device_ctx.rr_nodes[inode].edge_is_configurable(edge)) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "in check_rr_graph: node %d edge %d is non-configurable, but in configurable edges",
                                 inode, edge);
             }
         }
 
-        for (auto edge : device_ctx.rr_nodes[inode].non_configurable_edges()) {
+        for (auto edge : rr_graph.non_configurable_edges(RRNodeId(inode))) {
             if (device_ctx.rr_nodes[inode].edge_is_configurable(edge)) {
                 VPR_FATAL_ERROR(VPR_ERROR_ROUTE, "in check_rr_graph: node %d edge %d is configurable, but in non-configurable edges",
                                 inode, edge);
@@ -483,7 +483,7 @@ void check_rr_node(int inode, enum e_route_type route_type, const DeviceContext&
     }
 
     /* Check that the number of (out) edges is reasonable. */
-    num_edges = device_ctx.rr_nodes[inode].num_edges();
+    num_edges = rr_graph.num_edges(RRNodeId(inode));
 
     if (rr_type != SINK && rr_type != IPIN) {
         if (num_edges <= 0) {
@@ -544,7 +544,7 @@ static void check_unbuffered_edges(int from_node) {
     if (from_rr_type != CHANX && from_rr_type != CHANY)
         return;
 
-    from_num_edges = device_ctx.rr_nodes[from_node].num_edges();
+    from_num_edges = rr_graph.num_edges(RRNodeId(from_node));
 
     for (from_edge = 0; from_edge < from_num_edges; from_edge++) {
         to_node = device_ctx.rr_nodes[from_node].edge_sink_node(from_edge);
@@ -562,7 +562,7 @@ static void check_unbuffered_edges(int from_node) {
          * check that there is a corresponding edge from to_node back to         *
          * from_node.                                                            */
 
-        to_num_edges = device_ctx.rr_nodes[to_node].num_edges();
+        to_num_edges = rr_graph.num_edges(RRNodeId(to_node));
         trans_matched = false;
 
         for (to_edge = 0; to_edge < to_num_edges; to_edge++) {
diff --git a/vpr/src/route/route_common.cpp b/vpr/src/route/route_common.cpp
index 909e0612303..e8f9622a6c3 100644
--- a/vpr/src/route/route_common.cpp
+++ b/vpr/src/route/route_common.cpp
@@ -627,7 +627,8 @@ static std::pair<t_trace*, t_trace*> add_trace_non_configurable_recurr(int node,
     //Record the non-configurable out-going edges
     std::vector<t_edge_size> unvisited_non_configurable_edges;
     auto& device_ctx = g_vpr_ctx.device();
-    for (auto iedge : device_ctx.rr_nodes[node].non_configurable_edges()) {
+    const auto& rr_graph = device_ctx.rr_graph;
+    for (auto iedge : rr_graph.non_configurable_edges(RRNodeId(node))) {
         VTR_ASSERT_SAFE(!device_ctx.rr_nodes[node].edge_is_configurable(iedge));
 
         int to_node = device_ctx.rr_nodes[node].edge_sink_node(iedge);
@@ -1424,7 +1425,7 @@ void reserve_locally_used_opins(HeapInterface* heap, float pres_fac, float acc_f
             //the reserved OPINs to move out of the way of congestion, by preferring
             //to reserve OPINs with lower congestion costs).
             from_node = route_ctx.rr_blk_source[blk_id][iclass];
-            num_edges = device_ctx.rr_nodes[from_node].num_edges();
+            num_edges = rr_graph.num_edges(RRNodeId(from_node));
             for (iconn = 0; iconn < num_edges; iconn++) {
                 to_node = device_ctx.rr_nodes[from_node].edge_sink_node(iconn);
 
@@ -1561,9 +1562,10 @@ bool validate_traceback_recurr(t_trace* trace, std::set<int>& seen_rr_nodes) {
             //Check there is an edge connecting trace and next
 
             auto& device_ctx = g_vpr_ctx.device();
+            const auto& rr_graph = device_ctx.rr_graph;
 
             bool found = false;
-            for (t_edge_size iedge = 0; iedge < device_ctx.rr_nodes[trace->index].num_edges(); ++iedge) {
+            for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(trace->index)); ++iedge) {
                 int to_node = device_ctx.rr_nodes[trace->index].edge_sink_node(iedge);
 
                 if (to_node == next->index) {
diff --git a/vpr/src/route/route_tree_timing.cpp b/vpr/src/route/route_tree_timing.cpp
index 7cb35ca7aea..fb510f7de8c 100644
--- a/vpr/src/route/route_tree_timing.cpp
+++ b/vpr/src/route/route_tree_timing.cpp
@@ -418,7 +418,7 @@ static t_rt_node* add_non_configurable_to_route_tree(const int rr_node, const bo
                 VTR_ASSERT(rt_node->inode == rr_node);
             }
         }
-        for (int iedge : device_ctx.rr_nodes[rr_node].non_configurable_edges()) {
+        for (int iedge : rr_graph.non_configurable_edges(RRNodeId(rr_node))) {
             //Recursive case: expand children
             VTR_ASSERT(!device_ctx.rr_nodes[rr_node].edge_is_configurable(iedge));
 
diff --git a/vpr/src/route/router_lookahead_map_utils.cpp b/vpr/src/route/router_lookahead_map_utils.cpp
index 6d4fad5a7e3..ceeeeb67829 100644
--- a/vpr/src/route/router_lookahead_map_utils.cpp
+++ b/vpr/src/route/router_lookahead_map_utils.cpp
@@ -259,11 +259,13 @@ void expand_dijkstra_neighbours(const t_rr_graph_storage& rr_nodes,
                                 std::priority_queue<Entry,
                                                     std::vector<Entry>,
                                                     std::greater<Entry>>* pq) {
+    auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
     RRNodeId parent = parent_entry.rr_node;
 
     auto& parent_node = rr_nodes[size_t(parent)];
 
-    for (int iedge = 0; iedge < parent_node.num_edges(); iedge++) {
+    for (int iedge = 0; iedge < rr_graph.num_edges(RRNodeId(parent)); iedge++) {
         int child_node_ind = parent_node.edge_sink_node(iedge);
         int switch_ind = parent_node.edge_switch(iedge);
 
diff --git a/vpr/src/route/router_lookahead_sampling.cpp b/vpr/src/route/router_lookahead_sampling.cpp
index a1101b834b3..1cafebacfae 100644
--- a/vpr/src/route/router_lookahead_sampling.cpp
+++ b/vpr/src/route/router_lookahead_sampling.cpp
@@ -134,7 +134,7 @@ static std::tuple<int, int, int> get_node_info(const t_rr_node& node, int num_se
         return std::tuple<int, int, int>(OPEN, OPEN, OPEN);
     }
 
-    if (rr_graph.node_capacity(rr_node) == 0 || node.num_edges() == 0) {
+    if (rr_graph.node_capacity(rr_node) == 0 || rr_graph.num_edges(rr_node) == 0) {
         return std::tuple<int, int, int>(OPEN, OPEN, OPEN);
     }
 
@@ -205,7 +205,7 @@ std::vector<SampleRegion> find_sample_regions(int num_segments) {
     std::vector<vtr::Rect<int>> bounding_box_for_segment(num_segments, vtr::Rect<int>());
     for (auto& node : rr_nodes) {
         if (rr_graph.node_type(node.id()) != CHANX && rr_graph.node_type(node.id()) != CHANY) continue;
-        if (rr_graph.node_capacity(node.id()) == 0 || node.num_edges() == 0) continue;
+        if (rr_graph.node_capacity(node.id()) == 0 || rr_graph.num_edges(node.id()) == 0) continue;
         int seg_index = device_ctx.rr_indexed_data[rr_graph.node_cost_index(node.id())].seg_index;
 
         VTR_ASSERT(seg_index != OPEN);
diff --git a/vpr/src/route/rr_graph.cpp b/vpr/src/route/rr_graph.cpp
index 4327ebf5e63..74bffebf50d 100644
--- a/vpr/src/route/rr_graph.cpp
+++ b/vpr/src/route/rr_graph.cpp
@@ -375,9 +375,11 @@ void create_rr_graph(const t_graph_type graph_type,
 void print_rr_graph_stats() {
     auto& device_ctx = g_vpr_ctx.device();
 
+    const auto& rr_graph = device_ctx.rr_graph;
+
     size_t num_rr_edges = 0;
     for (auto& rr_node : device_ctx.rr_nodes) {
-        num_rr_edges += rr_node.edges().size();
+        num_rr_edges += rr_graph.edges(rr_node.id()).size();
     }
 
     VTR_LOG("  RR Graph Nodes: %zu\n", device_ctx.rr_nodes.size());
@@ -2460,7 +2462,7 @@ std::string describe_rr_node(int inode) {
 
     msg += vtr::string_fmt(" capacity: %d", rr_graph.node_capacity(RRNodeId(inode)));
     msg += vtr::string_fmt(" fan-in: %d", rr_graph.node_fan_in(RRNodeId(inode)));
-    msg += vtr::string_fmt(" fan-out: %d", rr_node.num_edges());
+    msg += vtr::string_fmt(" fan-out: %d", rr_graph.num_edges(RRNodeId(inode)));
 
     msg += " " + rr_graph.node_coordinate_to_string(RRNodeId(inode));
 
diff --git a/vpr/src/route/rr_graph_area.cpp b/vpr/src/route/rr_graph_area.cpp
index 1a1919d1b6a..4afbb05eafc 100644
--- a/vpr/src/route/rr_graph_area.cpp
+++ b/vpr/src/route/rr_graph_area.cpp
@@ -164,7 +164,7 @@ void count_bidir_routing_transistors(int num_switch, int wire_to_ipin_switch, fl
         switch (from_rr_type) {
             case CHANX:
             case CHANY:
-                num_edges = device_ctx.rr_nodes[from_node].num_edges();
+                num_edges = rr_graph.num_edges(RRNodeId(from_node));
 
                 for (iedge = 0; iedge < num_edges; iedge++) {
                     RRNodeId to_node = RRNodeId(device_ctx.rr_nodes[from_node].edge_sink_node(iedge));
@@ -249,7 +249,7 @@ void count_bidir_routing_transistors(int num_switch, int wire_to_ipin_switch, fl
                 break;
 
             case OPIN:
-                num_edges = device_ctx.rr_nodes[from_node].num_edges();
+                num_edges = rr_graph.num_edges(RRNodeId(from_node));
                 shared_opin_buffer_trans = 0.;
 
                 for (iedge = 0; iedge < num_edges; iedge++) {
@@ -361,7 +361,7 @@ void count_unidir_routing_transistors(std::vector<t_segment_inf>& /*segment_inf*
         switch (from_rr_type) {
             case CHANX:
             case CHANY:
-                num_edges = device_ctx.rr_nodes[from_node].num_edges();
+                num_edges = rr_graph.num_edges(RRNodeId(from_node));
 
                 /* Increment number of inputs per cblock if IPIN */
                 for (iedge = 0; iedge < num_edges; iedge++) {
diff --git a/vpr/src/route/rr_graph_timing_params.cpp b/vpr/src/route/rr_graph_timing_params.cpp
index 9b383e32378..15bf7cdf997 100644
--- a/vpr/src/route/rr_graph_timing_params.cpp
+++ b/vpr/src/route/rr_graph_timing_params.cpp
@@ -54,7 +54,7 @@ void add_rr_graph_C_from_switches(float C_ipin_cblock) {
         from_rr_type = rr_graph.node_type(RRNodeId(inode));
 
         if (from_rr_type == CHANX || from_rr_type == CHANY) {
-            for (t_edge_size iedge = 0; iedge < device_ctx.rr_nodes[inode].num_edges(); iedge++) {
+            for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(inode)); iedge++) {
                 to_node = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
                 to_rr_type = rr_graph.node_type(RRNodeId(to_node));
 
@@ -149,7 +149,7 @@ void add_rr_graph_C_from_switches(float C_ipin_cblock) {
         }
         /* End node is CHANX or CHANY */
         else if (from_rr_type == OPIN) {
-            for (t_edge_size iedge = 0; iedge < device_ctx.rr_nodes[inode].num_edges(); iedge++) {
+            for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(inode)); iedge++) {
                 switch_index = device_ctx.rr_nodes[inode].edge_switch(iedge);
                 to_node = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
                 to_rr_type = rr_graph.node_type(RRNodeId(to_node));
@@ -173,7 +173,7 @@ void add_rr_graph_C_from_switches(float C_ipin_cblock) {
      * out what the Cout's should be */
     Couts_to_add = (float*)vtr::calloc(device_ctx.rr_nodes.size(), sizeof(float));
     for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
-        for (t_edge_size iedge = 0; iedge < device_ctx.rr_nodes[inode].num_edges(); iedge++) {
+        for (t_edge_size iedge = 0; iedge < rr_graph.num_edges(RRNodeId(inode)); iedge++) {
             switch_index = device_ctx.rr_nodes[inode].edge_switch(iedge);
             to_node = device_ctx.rr_nodes[inode].edge_sink_node(iedge);
             to_rr_type = rr_graph.node_type(RRNodeId(to_node));
diff --git a/vpr/src/route/rr_graph_uxsdcxx_serializer.h b/vpr/src/route/rr_graph_uxsdcxx_serializer.h
index c5c172df9b3..7454d24a5a7 100644
--- a/vpr/src/route/rr_graph_uxsdcxx_serializer.h
+++ b/vpr/src/route/rr_graph_uxsdcxx_serializer.h
@@ -145,15 +145,17 @@ class t_metadata_dict_iterator {
 
 class EdgeWalker {
   public:
-    void initialize(const t_rr_graph_storage* nodes) {
+    void initialize(const t_rr_graph_storage* nodes, const RRGraphView* rr_graph) {
         nodes_ = nodes;
+        rr_graph_ = rr_graph;
         num_edges_ = 0;
         current_src_inode_ = 0;
         current_edge_ = 0;
         current_idx_ = 0;
 
+        // TODO: Once rr_graph_storage is fully shadowed by RRGraphView, the cached nodes_ will be removed.
         for (const auto& node : *nodes) {
-            num_edges_ += node.num_edges();
+            num_edges_ += rr_graph_->num_edges(node.id());
         }
     }
 
@@ -181,7 +183,7 @@ class EdgeWalker {
             current_edge_ += 1;
         }
 
-        if (current_edge_ >= (*nodes_)[current_src_inode_].num_edges()) {
+        if (current_edge_ >= rr_graph_->num_edges(RRNodeId(current_src_inode_))) {
             // Done with current_src_inode_, advance to the end of the
             // node list, or the next node with at least 1 edge.
             current_edge_ = 0;
@@ -194,7 +196,7 @@ class EdgeWalker {
                     VTR_ASSERT(current_idx_ + 1 == num_edges_);
                     return current_idx_++;
                 }
-            } while ((*nodes_)[current_src_inode_].num_edges() < 1);
+            } while (rr_graph_->num_edges(RRNodeId(current_src_inode_)) < 1);
         }
 
         VTR_ASSERT(current_src_inode_ < nodes_->size());
@@ -204,6 +206,7 @@ class EdgeWalker {
 
   private:
     const t_rr_graph_storage* nodes_;
+    const RRGraphView* rr_graph_;
     size_t num_edges_;
     size_t current_src_inode_;
     size_t current_edge_;
@@ -999,7 +1002,7 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
 
     inline EdgeWalker get_rr_graph_rr_edges(void*& /*ctx*/) final {
         EdgeWalker walker;
-        walker.initialize(rr_nodes_);
+        walker.initialize(rr_nodes_, rr_graph_);
         return walker;
     }
 
diff --git a/vpr/src/route/rr_node.cpp b/vpr/src/route/rr_node.cpp
index 8d3e3b6dbae..33154dc6d00 100644
--- a/vpr/src/route/rr_node.cpp
+++ b/vpr/src/route/rr_node.cpp
@@ -2,6 +2,7 @@
 #include "rr_graph_storage.h"
 #include "globals.h"
 #include "vpr_error.h"
+#include "rr_graph.h"
 
 //Returns the max 'length' over the x or y direction
 short t_rr_node::length() const {
@@ -20,6 +21,7 @@ bool t_rr_node::edge_is_configurable(t_edge_size iedge) const {
 
 bool t_rr_node::validate() const {
     //Check internal assumptions about RR node are valid
+
     t_edge_size iedge = 0;
     for (auto edge : edges()) {
         if (edge < num_configurable_edges()) {
diff --git a/vpr/src/route/rr_node_impl.h b/vpr/src/route/rr_node_impl.h
index c050f3e68bb..85482f878c8 100644
--- a/vpr/src/route/rr_node_impl.h
+++ b/vpr/src/route/rr_node_impl.h
@@ -79,17 +79,6 @@ inline edge_idx_range t_rr_node::edges() const {
     return storage_->edges(id_);
 }
 
-inline edge_idx_range t_rr_node::configurable_edges() const {
-    return storage_->configurable_edges(id_);
-}
-inline edge_idx_range t_rr_node::non_configurable_edges() const {
-    return storage_->non_configurable_edges(id_);
-}
-
-inline t_edge_size t_rr_node::num_non_configurable_edges() const {
-    return storage_->num_non_configurable_edges(id_);
-}
-
 inline t_edge_size t_rr_node::num_configurable_edges() const {
     return storage_->num_configurable_edges(id_);
 }
diff --git a/vpr/src/util/vpr_utils.cpp b/vpr/src/util/vpr_utils.cpp
index 6e128958872..1da873d0ec5 100644
--- a/vpr/src/util/vpr_utils.cpp
+++ b/vpr/src/util/vpr_utils.cpp
@@ -1788,6 +1788,7 @@ static int convert_switch_index(int* switch_index, int* fanin) {
  */
 void print_switch_usage() {
     auto& device_ctx = g_vpr_ctx.device();
+    const auto& rr_graph = device_ctx.rr_graph;
 
     if (device_ctx.switch_fanin_remap.empty()) {
         VTR_LOG_WARN("Cannot print switch usage stats: device_ctx.switch_fanin_remap is empty\n");
@@ -1802,7 +1803,7 @@ void print_switch_usage() {
     std::map<int, int>* inward_switch_inf = new std::map<int, int>[device_ctx.rr_nodes.size()];
     for (size_t inode = 0; inode < device_ctx.rr_nodes.size(); inode++) {
         const t_rr_node& from_node = device_ctx.rr_nodes[inode];
-        int num_edges = from_node.num_edges();
+        int num_edges = rr_graph.num_edges(RRNodeId(inode));
         for (int iedge = 0; iedge < num_edges; iedge++) {
             int switch_index = from_node.edge_switch(iedge);
             int to_node_index = from_node.edge_sink_node(iedge);
diff --git a/vpr/test/test_vpr.cpp b/vpr/test/test_vpr.cpp
index f025495e322..5e13977ce85 100644
--- a/vpr/test/test_vpr.cpp
+++ b/vpr/test/test_vpr.cpp
@@ -136,7 +136,7 @@ TEST_CASE("read_rr_graph_metadata", "[vpr]") {
         const auto& rr_graph = device_ctx.rr_graph;
 
         for (int inode = 0; inode < (int)device_ctx.rr_nodes.size(); ++inode) {
-            if ((rr_graph.node_type(RRNodeId(inode)) == CHANX || rr_graph.node_type(RRNodeId(inode)) == CHANY) && device_ctx.rr_nodes[inode].num_edges() > 0) {
+            if ((rr_graph.node_type(RRNodeId(inode)) == CHANX || rr_graph.node_type(RRNodeId(inode)) == CHANY) && rr_graph.num_edges(RRNodeId(inode)) > 0) {
                 src_inode = inode;
                 break;
             }