Adjusted some of the instances of node_ptc_num() to node_class_num(), node_track_num(), node_pin_num()

Signed-off-by: Ethan Rogers <[email protected]>

Author: ethanroj23

utils/fasm/test/test_fasm.cpp

@@ -192,7 +192,7 @@ static std::string get_pin_feature (size_t inode) {
     int ilow = rr_graph.node_xlow(RRNodeId(inode));
     int jlow = rr_graph.node_ylow(RRNodeId(inode));
     auto physical_tile = device_ctx.grid[ilow][jlow].type;
-    int pin_num = rr_graph.node_ptc_num(RRNodeId(inode));
+    int pin_num = rr_graph.node_pin_num(RRNodeId(inode));
 
     // Get the sub tile (type, not instance) and index of its pin that matches
     // the node index.

vpr/src/base/read_route.cpp

@@ -317,7 +317,7 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
             if (tokens[6 + offset] != "Switch:") {
                 /*This is an opin or ipin, process its pin nums*/
                 if (!is_io_type(device_ctx.grid[x][y].type) && (tokens[2] == "IPIN" || tokens[2] == "OPIN")) {
-                    int pin_num = rr_graph.node_ptc_num(RRNodeId(inode));
+                    int pin_num = rr_graph.node_pin_num(RRNodeId(inode));
 
                     auto type = device_ctx.grid[x][y].type;
                     int height_offset = device_ctx.grid[x][y].height_offset;

vpr/src/device/rr_graph_view.h

@@ -248,23 +248,35 @@ class RRGraphView {
     inline const char* node_side_string(RRNodeId node) const {
         return node_storage_.node_side_string(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 
+      * OPIN or IPIN: the index of pins in the logic block data structure 
+      * SOURCE and SINK: the class id of a pin (indicating logic equivalence of pins) in the logic block data structure  
+      * @note  
+      * This API is very powerful and developers should not use it unless it is necessary, 
+      * e.g the node type is unknown. If the node type is known, the more specific routines, `node_pin_num()`, 
+      * `node_track_num()`and `node_class_num()`, for different types of nodes should be used.*/ 
 
-    /** @brief Get the ptc num of a routing resource node. This function is inlined for runtime optimization. */
     inline short node_ptc_num(RRNodeId node) const {
         return node_storage_.node_ptc_num(node);
     }
 
-    /** @brief Get the pin num of a routing resource node. This function is inlined for runtime optimization. */
+    /** @brief Get the pin num of a routing resource node. This is designed for logic blocks, 
+     * which are IPIN and OPIN nodes. This function is inlined for runtime optimization. */
     inline short node_pin_num(RRNodeId node) const {
         return node_storage_.node_pin_num(node);
     }
 
-    /** @brief Get the track num of a routing resource node. This function is inlined for runtime optimization. */
+    /** @brief Get the track num of a routing resource node. This is designed for routing tracks, 
+     * which are CHANX and CHANY nodes. This function is inlined for runtime optimization. */
     inline short node_track_num(RRNodeId node) const {
         return node_storage_.node_track_num(node);
     }
-
-    /** @brief Get the class num of a routing resource node. This function is inlined for runtime optimization. */
+    
+    /** @brief Get the class num of a routing resource node. This is designed for routing source and sinks,
+     *  which are SOURCE and SINK nodes. This function is inlined for runtime optimization. */
     inline short node_class_num(RRNodeId node) const {
         return node_storage_.node_class_num(node);
     }

vpr/src/draw/draw.cpp

@@ -2193,18 +2193,18 @@ ezgl::rectangle draw_get_rr_chan_bbox(int inode) {
                     + draw_coords->get_tile_width();
             bottom = draw_coords->tile_y[rr_graph.node_ylow(rr_node)]
                      + draw_coords->get_tile_width()
-                     + (1. + rr_graph.node_ptc_num(rr_node));
+                     + (1. + rr_graph.node_track_num(rr_node));
             top = draw_coords->tile_y[rr_graph.node_ylow(rr_node)]
                   + draw_coords->get_tile_width()
-                  + (1. + rr_graph.node_ptc_num(rr_node));
+                  + (1. + rr_graph.node_track_num(rr_node));
             break;
         case CHANY:
             left = draw_coords->tile_x[rr_graph.node_xlow(rr_node)]
                    + draw_coords->get_tile_width()
-                   + (1. + rr_graph.node_ptc_num(rr_node));
+                   + (1. + rr_graph.node_track_num(rr_node));
             right = draw_coords->tile_x[rr_graph.node_xlow(rr_node)]
                     + draw_coords->get_tile_width()
-                    + (1. + rr_graph.node_ptc_num(rr_node));
+                    + (1. + rr_graph.node_track_num(rr_node));
             bottom = draw_coords->tile_y[rr_graph.node_ylow(rr_node)];
             top = draw_coords->tile_y[rr_graph.node_yhigh(rr_node)]
                   + draw_coords->get_tile_width();
@@ -2257,7 +2257,7 @@ static void draw_rr_pin(int inode, const ezgl::color& color, ezgl::renderer* g)
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
-    int ipin = rr_graph.node_ptc_num(RRNodeId(inode));
+    int ipin = rr_graph.node_pin_num(RRNodeId(inode));
 
     g->set_color(color);
 
@@ -2305,7 +2305,7 @@ void draw_get_rr_pin_coords(const t_rr_node& node, float* xcen, float* ycen, con
     xc = draw_coords->tile_x[i];
     yc = draw_coords->tile_y[j];
 
-    ipin = rr_graph.node_ptc_num(rr_node);
+    ipin = rr_graph.node_pin_num(rr_node);
     type = device_ctx.grid[i][j].type;
     pins_per_sub_tile = type->num_pins / type->capacity;
     k = ipin / pins_per_sub_tile;
@@ -2364,7 +2364,7 @@ static void draw_rr_src_sink(int inode, ezgl::color color, ezgl::renderer* g) {
         {xcen + draw_coords->pin_size, ycen + draw_coords->pin_size});
 
     std::string str = vtr::string_fmt("%d",
-                                      rr_graph.node_ptc_num(RRNodeId(inode)));
+                                      rr_graph.node_class_num(RRNodeId(inode)));
     g->set_color(ezgl::BLACK);
     g->draw_text({xcen, ycen}, str.c_str(), 2 * draw_coords->pin_size,
                  2 * draw_coords->pin_size);
@@ -2620,7 +2620,7 @@ static int get_track_num(int inode, const vtr::OffsetMatrix<int>& chanx_track, c
     RRNodeId rr_node = RRNodeId(inode);
 
     if (get_draw_state_vars()->draw_route_type == DETAILED)
-        return (rr_graph.node_ptc_num(rr_node));
+        return (rr_graph.node_track_num(rr_node));
 
     /* GLOBAL route stuff below. */
 
@@ -2766,7 +2766,7 @@ static int draw_check_rr_node_hit(float click_x, float click_y) {
                 t_physical_tile_type_ptr type = device_ctx.grid[i][j].type;
                 int width_offset = device_ctx.grid[i][j].width_offset;
                 int height_offset = device_ctx.grid[i][j].height_offset;
-                int ipin = rr_graph.node_ptc_num(rr_node);
+                int ipin = rr_graph.node_pin_num(rr_node);
                 float xcen, ycen;
                 for (const e_side& iside : SIDES) {
                     // If pin exists on this side of the block, then get pin coordinates

vpr/src/route/check_route.cpp

@@ -214,7 +214,7 @@ static void check_source(RRNodeId inode, ClusterNetId net_id) {
     int i = rr_graph.node_xlow(inode);
     int j = rr_graph.node_ylow(inode);
     /* for sinks and sources, ptc_num is class */
-    int ptc_num = rr_graph.node_ptc_num(inode);
+    int ptc_num = rr_graph.node_class_num(inode);
     /* First node_block for net is the source */
     ClusterBlockId blk_id = cluster_ctx.clb_nlist.net_driver_block(net_id);
     auto type = device_ctx.grid[i][j].type;
@@ -574,7 +574,7 @@ static void check_locally_used_clb_opins(const t_clb_opins_used& clb_opins_used_
                                     size_t(blk_id), cluster_ctx.clb_nlist.block_name(blk_id).c_str(), iclass, inode, rr_type);
                 }
 
-                ipin = rr_graph.node_ptc_num(RRNodeId(inode));
+                ipin = rr_graph.node_pin_num(RRNodeId(inode));
                 if (physical_tile_type(blk_id)->pin_class[ipin] != iclass) {
                     VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
                                     "in check_locally_used_opins: block #%lu (%s):\n"

vpr/src/route/check_rr_graph.cpp

@@ -282,7 +282,7 @@ static bool rr_node_is_global_clb_ipin(RRNodeId inode) {
     if (rr_graph.node_type(inode) != IPIN)
         return (false);
 
-    ipin = rr_graph.node_ptc_num(inode);
+    ipin = rr_graph.node_pin_num(inode);
 
     return type->is_ignored_pin[ipin];
 }

vpr/src/route/clock_connection_builders.cpp

@@ -103,7 +103,7 @@ RRNodeId RoutingToClockConnection::create_virtual_clock_network_sink_node(int x,
 
     int max_ptc = 0;
     for (RRNodeId inode : nodes_at_loc) {
-        max_ptc = std::max<int>(max_ptc, temp_rr_graph.node_ptc_num(inode));
+        max_ptc = std::max<int>(max_ptc, temp_rr_graph.node_class_num(inode));
     }
     int ptc = max_ptc + 1;
 

vpr/src/route/clock_network_builders.cpp

@@ -350,7 +350,7 @@ int ClockRib::create_chanx_wire(int x_start,
     for (int ix = rr_graph.node_xlow(chanx_node); ix <= rr_graph.node_xhigh(chanx_node); ++ix) {
         for (int iy = rr_graph.node_ylow(chanx_node); iy <= rr_graph.node_yhigh(chanx_node); ++iy) {
             //TODO: CHANX uses odd swapped x/y indices here. Will rework once rr_node_indices is shadowed
-            rr_graph_builder.node_lookup().add_node(chanx_node, iy, ix, rr_graph.node_type(chanx_node), rr_graph.node_ptc_num(chanx_node));
+            rr_graph_builder.node_lookup().add_node(chanx_node, iy, ix, rr_graph.node_type(chanx_node), rr_graph.node_track_num(chanx_node));
         }
     }
 

vpr/src/route/route_common.cpp

@@ -1283,7 +1283,7 @@ void print_route(FILE* fp, const vtr::vector<ClusterNetId, t_traceback>& traceba
 
                     auto physical_tile = device_ctx.grid[ilow][jlow].type;
                     if (!is_io_type(physical_tile) && (rr_type == IPIN || rr_type == OPIN)) {
-                        int pin_num = rr_graph.node_ptc_num(rr_node);
+                        int pin_num = rr_graph.node_pin_num(rr_node);
                         int xoffset = device_ctx.grid[ilow][jlow].width_offset;
                         int yoffset = device_ctx.grid[ilow][jlow].height_offset;
                         int sub_tile_offset = physical_tile->get_sub_tile_loc_from_pin(pin_num);

vpr/src/util/vpr_utils.cpp

@@ -199,11 +199,11 @@ std::string rr_node_arch_name(int inode) {
     if (rr_graph.node_type(RRNodeId(inode)) == OPIN || rr_graph.node_type(RRNodeId(inode)) == IPIN) {
         //Pin names
         auto type = device_ctx.grid[rr_graph.node_xlow(rr_node)][rr_graph.node_ylow(rr_node)].type;
-        rr_node_arch_name += block_type_pin_index_to_name(type, rr_graph.node_ptc_num(rr_node));
+        rr_node_arch_name += block_type_pin_index_to_name(type, rr_graph.node_pin_num(rr_node));
     } else if (rr_graph.node_type(RRNodeId(inode)) == SOURCE || rr_graph.node_type(RRNodeId(inode)) == SINK) {
         //Set of pins associated with SOURCE/SINK
         auto type = device_ctx.grid[rr_graph.node_xlow(rr_node)][rr_graph.node_ylow(rr_node)].type;
-        auto pin_names = block_type_class_index_to_pin_names(type, rr_graph.node_ptc_num(rr_node));
+        auto pin_names = block_type_class_index_to_pin_names(type, rr_graph.node_class_num(rr_node));
         if (pin_names.size() > 1) {
             rr_node_arch_name += rr_graph.node_type_string(RRNodeId(inode));
             rr_node_arch_name += " connected to ";