add comments

soheilshahrouz · soheilshahrouz · commit 2d833bfff6e5 · 2025-11-25T12:40:45.000-05:00
diff --git a/vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp b/vpr/src/route/router_lookahead/router_lookahead_map_utils.cpp
@@ -988,26 +988,26 @@ static void dijkstra_flood_to_wires(int itile,
     int ptc = rr_graph.node_ptc_num(node);
     int root_layer_num = rr_graph.node_layer_low(node);
 
-    /*
-     * Perform Dijkstra from the SOURCE/OPIN of interest, stopping at the first
-     * reachable wires (i.e. until we hit the inter-block routing network), or a SINK
-     * (via a direct-connect).
-     *
-     * Note that typical RR graphs are structured :
-     *
-     *      SOURCE ---> OPIN --> CHANX/CHANY
-     *              |
-     *              --> OPIN --> CHANX/CHANY
-     *              |
-     *             ...
-     *
-     *   possibly with direct-connects of the form:
-     *
-     *      SOURCE --> OPIN --> IPIN --> SINK
-     *
-     * and there is a small number of fixed hops from SOURCE/OPIN to CHANX/CHANY or
-     * to a SINK (via a direct-connect), so this runs very fast (i.e. O(1))
-     */
+
+    // Perform Dijkstra from the SOURCE/OPIN of interest, stopping at the first
+    // reachable wires (i.e. until we hit the inter-block routing network), or a SINK
+    // (via a direct-connect).
+    //
+    // Note that typical RR graphs are structured :
+    //
+    //      SOURCE ---> OPIN --> CHANX/CHANY/CHANZ
+    //              |
+    //              --> OPIN --> CHANX/CHANY/CHANZ
+    //              |
+    //             ...
+    //
+    //   possibly with direct-connects of the form:
+    //
+    //      SOURCE --> OPIN --> IPIN --> SINK
+    //
+    // and there is a small number of fixed hops from SOURCE/OPIN to CHANX/CHANY or
+    // to a SINK (via a direct-connect), so this runs very fast (i.e. O(1))
+
     pq.push(root);
     while (!pq.empty()) {
         t_pq_entry curr = pq.top();
@@ -1016,23 +1016,24 @@ static void dijkstra_flood_to_wires(int itile,
         e_rr_type curr_rr_type = rr_graph.node_type(curr.node);
         int curr_layer_num = rr_graph.node_layer_low(curr.node);
         if (curr_rr_type == e_rr_type::CHANX || curr_rr_type == e_rr_type::CHANY || curr_rr_type == e_rr_type::CHANZ || curr_rr_type == e_rr_type::SINK) {
-            // We stop expansion at any CHANX/CHANY/SINK
+            // We stop expansion at any CHANX/CHANY/CHANZ/SINK
             int seg_index;
             if (curr_rr_type != e_rr_type::SINK) {
-                //It's a wire, figure out its type
+                // It's a wire, figure out its type
                 RRIndexedDataId cost_index = rr_graph.node_cost_index(curr.node);
                 seg_index = device_ctx.rr_indexed_data[cost_index].seg_index;
             } else {
                 // This is a direct-connect path between an IPIN and OPIN,
                 // which terminated at a SINK.
-                //
                 // We treat this as a 'special' wire type.
                 // When the src_opin_delays data structure is queried and a SINK rr_type
                 // is found, the lookahead is not accessed to get the cost entries
                 // as this is a special case of direct connections between OPIN and IPIN.
                 seg_index = DIRECT_CONNECT_SPECIAL_SEG_TYPE;
             }
 
+            // Reaching a CHANZ nodes means that we are moving to a different layer than
+            // where root node is located. It's assumed that there are only two layers.
             if (curr_rr_type == e_rr_type::CHANZ) {
                 curr_layer_num = (root_layer_num + 1) % 2;
             }
@@ -1048,9 +1049,9 @@ static void dijkstra_flood_to_wires(int itile,
             }
 
         } else if (curr_rr_type == e_rr_type::SOURCE || curr_rr_type == e_rr_type::OPIN || curr_rr_type == e_rr_type::IPIN || curr_rr_type == e_rr_type::MUX) {
-            //We allow expansion through SOURCE/OPIN/IPIN types
+            // We allow expansion through SOURCE/OPIN/IPIN types
             RRIndexedDataId cost_index = rr_graph.node_cost_index(curr.node);
-            float incr_cong = device_ctx.rr_indexed_data[cost_index].base_cost; //Current nodes congestion cost
+            float incr_cong = device_ctx.rr_indexed_data[cost_index].base_cost; // Current nodes congestion cost
 
             for (RREdgeId edge : rr_graph.edge_range(curr.node)) {
                 int iswitch = rr_graph.rr_nodes().edge_switch(edge);
@@ -1064,8 +1065,8 @@ static void dijkstra_flood_to_wires(int itile,
                 }
 
                 t_pq_entry next;
-                next.congestion = curr.congestion + incr_cong; //Of current node
-                next.delay = curr.delay + incr_delay;          //To reach next node
+                next.congestion = curr.congestion + incr_cong; // Of current node
+                next.delay = curr.delay + incr_delay;          // To reach next node
                 next.node = next_node;
 
                 pq.push(next);
diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp
@@ -1541,8 +1541,7 @@ static void alloc_and_load_tile_rr_graph(RRGraphBuilder& rr_graph_builder,
 
 void free_rr_graph() {
     // Frees all the routing graph data structures, if they have been allocated.
-    // I use rr_mem_chunk_list_head as a flag to indicate whether or not the graph has been allocated -- if it is not NULL,
-    // a routing graph exists and can be freed.  Hence, you can call this routine even if you're not sure of whether a rr_graph exists or not.
+    // You can call this routine even if you're not sure of whether a rr_graph exists or not.
 
     // Before adding any more free calls here, be sure the data is NOT chunk allocated, as ALL the chunk allocated data is already free!
     DeviceContext& device_ctx = g_vpr_ctx.mutable_device();
@@ -1560,6 +1559,12 @@ void free_rr_graph() {
 
     device_ctx.rr_graph_is_flat = false;
 
+    device_ctx.rr_chanx_segment_width.clear();
+    device_ctx.rr_chany_segment_width.clear();
+    device_ctx.rr_chanz_segment_width.clear();
+    device_ctx.rr_chanx_width.clear();
+    device_ctx.rr_chany_width.clear();
+
     invalidate_router_lookahead_cache();
 }
 
diff --git a/vpr/src/route/rr_graph_generation/rr_graph_chan_chan_edges.cpp b/vpr/src/route/rr_graph_generation/rr_graph_chan_chan_edges.cpp
@@ -29,6 +29,24 @@ static void build_rr_chan(RRGraphBuilder& rr_graph_builder,
                           int wire_to_ipin_switch,
                           e_directionality directionality);
 
+/**
+ * @brief Collects the edges fanning-out of the 'from' track which connect to
+ *  the 'to' tracks, according to the switch block pattern.
+ *
+ * It returns the number of connections added, and updates edge_list_ptr to
+ * point at the head of the (extended) linked list giving the nodes to which
+ * this segment connects and the switch type used to connect to each.
+ *
+ * An edge is added from this segment to a y-segment if:
+ * (1) this segment should have a switch box at that location, or
+ * (2) the y-segment to which it would connect has a switch box, and the switch
+ *     type of that y-segment is unbuffered (bidirectional pass transistor).
+ *
+ * For bidirectional:
+ * If the switch in each direction is a pass transistor (unbuffered), both
+ * switches are marked as being of the types of the larger (lower R) pass
+ * transistor.
+ */
 static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
                                int layer,
                                int from_chan,
@@ -345,24 +363,6 @@ static void build_rr_chan(RRGraphBuilder& rr_graph_builder,
     }
 }
 
-/*
- * Collects the edges fanning-out of the 'from' track which connect to the 'to'
- * tracks, according to the switch block pattern.
- *
- * It returns the number of connections added, and updates edge_list_ptr to
- * point at the head of the (extended) linked list giving the nodes to which
- * this segment connects and the switch type used to connect to each.
- *
- * An edge is added from this segment to a y-segment if:
- * (1) this segment should have a switch box at that location, or
- * (2) the y-segment to which it would connect has a switch box, and the switch
- *     type of that y-segment is unbuffered (bidirectional pass transistor).
- *
- * For bidirectional:
- * If the switch in each direction is a pass transistor (unbuffered), both
- * switches are marked as being of the types of the larger (lower R) pass
- * transistor.
- */
 static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
                                int layer,
                                int from_chan,
@@ -400,12 +400,12 @@ static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
 
     int from_switch = from_seg_details[from_track].arch_wire_switch();
 
-    //The absolute coordinate along the channel where the switch block at the
-    //beginning of the current wire segment is located
+    // The absolute coordinate along the channel where the switch block at the
+    // beginning of the current wire segment is located
     int start_sb_seg = from_seg - 1;
 
-    //The absolute coordinate along the channel where the switch block at the
-    //end of the current wire segment is located
+    // The absolute coordinate along the channel where the switch block at the
+    // end of the current wire segment is located
     int end_sb_seg = get_seg_end(from_seg_details, from_track, from_seg, from_chan, chan_len);
 
     // Figure out the sides of SB the from_wire will use
@@ -430,8 +430,8 @@ static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
         end = to_seg;
     }
 
-    //Walk along the 'from' wire segment identifying if a switchblock is located
-    //at each coordinate and add any related fan-out connections to the 'from' wire segment
+    // Walk along the 'from' wire segment identifying if a switchblock is located
+    // at each coordinate and add any related fan-out connections to the 'from' wire segment
     int num_conn = 0;
     for (int sb_seg = start; sb_seg <= end; ++sb_seg) {
         if (sb_seg < start_sb_seg || sb_seg > end_sb_seg) {
@@ -454,7 +454,7 @@ static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
         // Get the coordinates of the current SB from the perspective of the destination channel.
         // i.e. for segments laid in the x-direction, sb_seg corresponds to the x coordinate and from_chan to the y,
         // but for segments in the y-direction, from_chan is the x coordinate and sb_seg is the y. So here we reverse
-        //the coordinates if necessary
+        // the coordinates if necessary
         if (from_type == to_type) {
             // Same channel
             to_chan = from_chan;
@@ -566,8 +566,8 @@ static int get_track_to_tracks(RRGraphBuilder& rr_graph_builder,
                 }
                 if (UNI_DIRECTIONAL == directionality) {
                     // No fanout if no SB.
-                    /* Also, we are connecting from the bottom or left of SB so it
-                     * makes the most sense to only get there from Direction::INC wires. */
+                    // Also, we are connecting from the bottom or left of SB so it
+                    // makes the most sense to only get there from Direction::INC wires.
                     if ((from_is_sblock)
                         && (Direction::INC == from_seg_details[from_track].direction())) {
                         num_conn += get_unidir_track_to_chan_seg(rr_graph_builder, layer, from_track, to_chan,
diff --git a/vpr/src/route/rr_graph_generation/rr_graph_sg.h b/vpr/src/route/rr_graph_generation/rr_graph_sg.h
@@ -11,10 +11,11 @@ class RRGraphView;
 struct t_bottleneck_link;
 
 /**
- * @brief builds the extra length-0 CHANX nodes to handle 3D custom switchblocks edges in the RR graph.
+ * @brief Builds CHANZ nodes to handle 3D switchblock edges in the RR graph.
  *  @param rr_graph_builder RRGraphBuilder data structure which allows data modification on a routing resource graph
  *  @param x_coord switch block x_coordinate
  *  @param y_coord switch block y-coordinate
+ *  @param interdie_3d_links 3D wires and their connectivity specification for the given location.
  *  @param const_index_offset index to the correct node type for RR node cost initialization
  */
 void build_inter_die_3d_rr_chan(RRGraphBuilder& rr_graph_builder,
