Finish initial implementation of explicit port definitions.

Signed-off-by: Keith Rothman <[email protected]>

Author: litghost

libs/libarchfpga/src/physical_types.cpp

@@ -110,7 +110,12 @@ std::vector<int> t_physical_tile_type::get_clock_pins_indices() const {
     int clock_pins_start_idx = 0;
     int clock_pins_stop_idx = 0;
 
-    for (int capacity_num = 0; capacity_num < this->capacity; capacity_num++) {
+    int num_capacity = 1;
+    if (capacity_type == e_capacity_type::DUPLICATE) {
+        num_capacity = this->capacity;
+    }
+
+    for (int capacity_num = 0; capacity_num < num_capacity; capacity_num++) {
         // Ranges are picked on the basis that pins are ordered: inputs, outputs, then clock pins
         // This is because ProcessPb_type assigns pb_type port indices in that order and
         // SetupPinLocationsAndPinClasses assigns t_logical_block_type_ptr pin indices in the order of port indices

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -912,7 +912,6 @@ static std::pair<int, std::pair<int, int>> ProcessPinString(pugi::xml_node Locat
 
         token_index++;
         token = tokens[token_index];
-
     }
 
     if (token.type != TOKEN_DOT) {

vpr/src/base/read_route.cpp

@@ -23,6 +23,7 @@
 #include "rr_graph.h"
 #include "vtr_assert.h"
 #include "vtr_util.h"
+#include "vtr_time.h"
 #include "tatum/echo_writer.hpp"
 #include "vtr_log.h"
 #include "check_route.h"
@@ -40,6 +41,7 @@
 #include "echo_files.h"
 #include "route_common.h"
 #include "read_route.h"
+#include "rr_graph2.h"
 
 /*************Functions local to this module*************/
 static void process_route(std::ifstream& fp, const char* filename, int& lineno);
@@ -192,7 +194,7 @@ static void process_nets(std::ifstream& fp, ClusterNetId inet, std::string name,
 static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* filename, int& lineno) {
     /* Not a global net. Goes through every node and add it into trace.head*/
 
-    auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
+    auto& cluster_ctx = g_vpr_ctx.clustering();
     auto& device_ctx = g_vpr_ctx.mutable_device();
     auto& route_ctx = g_vpr_ctx.mutable_routing();
     auto& place_ctx = g_vpr_ctx.placement();
@@ -206,6 +208,45 @@ static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* file
     std::string input;
     std::vector<std::string> tokens;
 
+    // Build lookup from SOURCE/SINK node to ClusterBlockId.
+    std::unordered_map<int, ClusterBlockId> node_to_block;
+
+    {
+        vtr::ScopedStartFinishTimer timer("Building ClusterBlockId lookup");
+
+        for (auto net_id : cluster_ctx.clb_nlist.nets()) {
+            int pin_count = 0;
+            for (auto pin_id : cluster_ctx.clb_nlist.net_pins(net_id)) {
+                auto block_id = cluster_ctx.clb_nlist.pin_block(pin_id);
+
+                const auto* logical_tile = cluster_ctx.clb_nlist.block_type(block_id);
+                const auto* physical_tile = physical_tile_type(block_id);
+                VTR_ASSERT(block_id);
+                int i = place_ctx.block_locs[block_id].loc.x;
+                int j = place_ctx.block_locs[block_id].loc.y;
+
+                int logical_pin_index = cluster_ctx.clb_nlist.pin_logical_index(pin_id);
+                int physical_pin_index = get_physical_pin(
+                    physical_tile, place_ctx.block_locs[block_id].loc.z,
+                    logical_tile, logical_pin_index);
+                int physical_pin_class = physical_tile->pin_class[physical_pin_index];
+                int class_inode = get_rr_node_index(device_ctx.rr_node_indices,
+                                                    i, j, (pin_count == 0 ? SOURCE : SINK), /* First pin is driver */
+                                                    physical_pin_class);
+
+                auto result = node_to_block.insert(std::make_pair(class_inode, block_id));
+                if (!result.second && result.first->second != block_id) {
+                    vpr_throw(VPR_ERROR_ROUTE, filename, lineno,
+                              "Clustered netlist has inconsistent rr node mapping, class rr node %d has two block ids %zu and %zu?",
+                              class_inode, (size_t)block_id, result.first->second);
+                }
+                pin_count++;
+            }
+        }
+
+        VTR_LOG("ClusterBlockId lookup has %zu entries\n", node_to_block.size());
+    }
+
     /*Walk through every line that begins with Node:*/
     while (std::getline(fp, input)) {
         ++lineno;
@@ -285,9 +326,22 @@ 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")) {
+                    // Convert this IPIN/OPIN back to class.
+                    auto rr_type = device_ctx.rr_nodes[inode].type();
+                    VTR_ASSERT(rr_type == IPIN || rr_type == OPIN);
                     int pin_num = device_ctx.rr_nodes[inode].ptc_num();
-                    int height_offset = device_ctx.grid[x][y].height_offset;
-                    ClusterBlockId iblock = place_ctx.grid_blocks[x][y - height_offset].blocks[0];
+                    int iclass = device_ctx.grid[x][y].type->pin_class[pin_num];
+                    int class_inode = get_rr_node_index(device_ctx.rr_node_indices,
+                                                        x, y, (rr_type == OPIN ? SOURCE : SINK), iclass);
+
+                    auto itr = node_to_block.find(class_inode);
+                    if (itr == node_to_block.end()) {
+                        vpr_throw(VPR_ERROR_ROUTE, filename, lineno,
+                                  "Class RR node %d does not have an associated ClusterBlockId?", class_inode);
+                    }
+
+                    ClusterBlockId iblock = itr->second;
+                    VTR_ASSERT(iblock);
                     t_pb_graph_pin* pb_pin = get_pb_graph_node_pin_from_block_pin(iblock, pin_num);
                     t_pb_type* pb_type = pb_pin->parent_node->pb_type;
 

vpr/src/base/vpr_context.h

@@ -282,6 +282,7 @@ struct RoutingContext : public Context {
     vtr::vector<ClusterNetId, std::unordered_set<int>> trace_nodes;
 
     vtr::vector<ClusterNetId, std::vector<int>> net_rr_terminals; /* [0..num_nets-1][0..num_pins-1] */
+    std::unordered_map<int, ClusterBlockId> rr_net_map;
 
     vtr::vector<ClusterBlockId, std::vector<int>> rr_blk_source; /* [0..num_blocks-1][0..num_class-1] */
 

vpr/src/route/route_common.cpp

@@ -96,7 +96,8 @@ static t_trace_branch traceback_branch(int node, std::unordered_set<int>& main_b
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable(t_trace* head, t_trace* tail, int node, std::unordered_set<int>& visited);
 static std::pair<t_trace*, t_trace*> add_trace_non_configurable_recurr(int node, std::unordered_set<int>& visited, int depth = 0);
 
-static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t_rr_node_indices& L_rr_node_indices);
+static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t_rr_node_indices& L_rr_node_indices,
+                                                                         std::unordered_map<int, ClusterBlockId>* rr_net_map);
 static vtr::vector<ClusterBlockId, std::vector<int>> load_rr_clb_sources(const t_rr_node_indices& L_rr_node_indices);
 
 static t_clb_opins_used alloc_and_load_clb_opins_used_locally();
@@ -496,7 +497,7 @@ void init_route_structs(int bb_factor) {
     init_heap(device_ctx.grid);
 
     //Various look-ups
-    route_ctx.net_rr_terminals = load_net_rr_terminals(device_ctx.rr_node_indices);
+    route_ctx.net_rr_terminals = load_net_rr_terminals(device_ctx.rr_node_indices, &route_ctx.rr_net_map);
     route_ctx.route_bb = load_route_bb(bb_factor);
     route_ctx.rr_blk_source = load_rr_clb_sources(device_ctx.rr_node_indices);
     route_ctx.clb_opins_used_locally = alloc_and_load_clb_opins_used_locally();
@@ -1031,7 +1032,11 @@ void reset_rr_node_route_structs() {
 /* Allocates and loads the route_ctx.net_rr_terminals data structure. For each net it stores the rr_node   *
  * index of the SOURCE of the net and all the SINKs of the net [clb_nlist.nets()][clb_nlist.net_pins()].    *
  * Entry [inet][pnum] stores the rr index corresponding to the SOURCE (opin) or SINK (ipin) of the pin.     */
-static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t_rr_node_indices& L_rr_node_indices) {
+static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(
+    const t_rr_node_indices& L_rr_node_indices,
+    std::unordered_map<int, ClusterBlockId>* rr_net_map) {
+    VTR_ASSERT(rr_net_map != nullptr);
+    rr_net_map->clear();
     vtr::vector<ClusterNetId, std::vector<int>> net_rr_terminals;
 
     auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -1061,6 +1066,16 @@ static vtr::vector<ClusterNetId, std::vector<int>> load_net_rr_terminals(const t
             int inode = get_rr_node_index(L_rr_node_indices, i, j, (pin_count == 0 ? SOURCE : SINK), /* First pin is driver */
                                           iclass);
             net_rr_terminals[net_id][pin_count] = inode;
+
+            auto result = rr_net_map->insert(std::make_pair(inode, block_id));
+            // If the map already contains an entry for inode, make sure it
+            // is consistent with the existing entry.
+            if (!result.second && block_id != result.first->second) {
+                VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                                "Clustered netlist has inconsistent rr node mapping, class rr node %d has two block ids %zu and %zu?",
+                                inode, (size_t)block_id, (size_t)result.first->second);
+            }
+
             pin_count++;
         }
     }
@@ -1513,11 +1528,18 @@ void print_route(FILE* fp, const vtr::vector<ClusterNetId, t_traceback>& traceba
                     fprintf(fp, "%d  ", device_ctx.rr_nodes[inode].ptc_num());
 
                     if (!is_io_type(device_ctx.grid[ilow][jlow].type) && (rr_type == IPIN || rr_type == OPIN)) {
+                        // Go from IPIN/OPIN to SOURCE/SINK
+                        auto* type = device_ctx.grid[ilow][jlow].type;
                         int pin_num = device_ctx.rr_nodes[inode].ptc_num();
-                        int xoffset = device_ctx.grid[ilow][jlow].width_offset;
-                        int yoffset = device_ctx.grid[ilow][jlow].height_offset;
-                        ClusterBlockId iblock = place_ctx.grid_blocks[ilow - xoffset][jlow - yoffset].blocks[0];
-                        VTR_ASSERT(iblock);
+                        int iclass = type->pin_class[pin_num];
+                        int class_inode = get_rr_node_index(device_ctx.rr_node_indices,
+                                                            ilow, jlow, (rr_type == OPIN ? SOURCE : SINK), iclass);
+
+                        // Use the rr_net_map to go from class inode back to ClusterBlockId.
+                        auto itr = route_ctx.rr_net_map.find(class_inode);
+                        VTR_ASSERT(itr != route_ctx.rr_net_map.end());
+                        ClusterBlockId iblock = itr->second;
+
                         t_pb_graph_pin* pb_pin = get_pb_graph_node_pin_from_block_pin(iblock, pin_num);
                         t_pb_type* pb_type = pb_pin->parent_node->pb_type;
                         fprintf(fp, " %s.%s[%d] ", pb_type->name, pb_pin->port->name, pb_pin->pin_number);

vpr/src/util/vpr_utils.cpp

@@ -192,15 +192,21 @@ std::string block_type_pin_index_to_name(t_physical_tile_type_ptr type, int pin_
 
     std::string pin_name = type->name;
 
-    if (type->capacity > 1) {
-        int pins_per_inst = type->num_pins / type->capacity;
-        int inst_num = pin_index / pins_per_inst;
-        pin_index %= pins_per_inst;
+    if (type->capacity_type == e_capacity_type::DUPLICATE) {
+        if (type->capacity > 1) {
+            int pins_per_inst = type->num_pins / type->capacity;
+            int inst_num = pin_index / pins_per_inst;
+            pin_index %= pins_per_inst;
 
-        pin_name += "[" + std::to_string(inst_num) + "]";
-    }
+            pin_name += "[" + std::to_string(inst_num) + "]";
+        }
 
-    pin_name += ".";
+        pin_name += ".";
+    } else {
+        VTR_ASSERT(type->capacity_type == e_capacity_type::EXPLICIT);
+        VTR_ASSERT(pin_index < type->num_pins);
+        pin_name += ".";
+    }
 
     int curr_index = 0;
     for (auto const& port : type->ports) {
@@ -2058,18 +2064,18 @@ void place_sync_external_block_connections(ClusterBlockId iblk) {
     auto physical_tile = physical_tile_type(iblk);
     auto logical_block = clb_nlist.block_type(iblk);
 
-    VTR_ASSERT(physical_tile->num_pins % physical_tile->capacity == 0);
     for (auto pin : clb_nlist.block_pins(iblk)) {
         int logical_pin_index = clb_nlist.pin_logical_index(pin);
-        int new_physical_pin_index = get_physical_pin(
+
+        int new_physical_pin = get_physical_pin(
             physical_tile, place_ctx.block_locs[iblk].loc.z,
             logical_block, logical_pin_index);
-
-        auto result = place_ctx.physical_pins.find(pin);
-        if (result != place_ctx.physical_pins.end()) {
-            place_ctx.physical_pins[pin] = new_physical_pin_index;
+        auto iter = place_ctx.physical_pins.find(pin);
+        if (iter != place_ctx.physical_pins.end()) {
+            *iter = new_physical_pin;
         } else {
-            place_ctx.physical_pins.insert(pin, new_physical_pin_index);
+            place_ctx.physical_pins.insert(
+                pin, new_physical_pin);
         }
     }
 }