Merge branch 'master' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into placement_move_primitive

Author: amin1377

libs/libarchfpga/src/physical_types.h

@@ -1225,6 +1225,12 @@ struct t_pin_to_pin_annotation {
  *      parent_pb_graph_node  : parent pb graph node
  *      total_primitive_count : Total number of this primitive type in the cluster. If there are 10 ALMs per cluster
  *                              and 2 FFs per ALM (given the mode of the parent of this primitive) then the total is 20.
+ *                              This member is only used by nodes corresponding to primitive sites.
+ *      flat_site_index       : Index of this primitive site within its primitive type within this cluster type.
+ *                              Values are in [0...total_primitive_count-1], e.g. if there are 10 ALMs per cluster, 2 FFS
+ *                              and 2 LUTs per ALM, then flat site indices for FFs would run from 0 to 19, and flat site
+                                indices for LUTs would run from 0 to 19. This member is only used by nodes corresponding
+                                to primitive sites. It is used when reconstructing clusters from a flat placement file.
  *      illegal_modes         : vector containing illegal modes that result in conflicts during routing
  */
 class t_pb_graph_node {
@@ -1287,6 +1293,8 @@ class t_pb_graph_node {
     int num_output_pin_class;   /* number of output pin classes that this pb_graph_node has */
 
     int total_primitive_count; /* total number of this primitive type in the cluster */
+    int flat_site_index;       /* index of this primitive within sites of its type in this cluster  */
+
 
     /* Interconnect instances for this pb
      * Only used for power

libs/libvtrutil/src/vtr_assert.cpp

@@ -16,6 +16,8 @@ void handle_assert(const char* expr, const char* file, unsigned int line, const
         fprintf(stderr, " (%s)", msg);
     }
     fprintf(stderr, ".\n");
+    fflush(stdout);
+    fflush(stderr);
     std::abort();
 }
 

vpr/src/pack/cluster_placement.cpp

@@ -86,10 +86,14 @@ t_cluster_placement_stats* alloc_and_load_cluster_placement_stats() {
  * primitives_list - a list of primitives indexed to match atom_block_ids of molecule.
  *                   Expects an allocated array of primitives ptrs as inputs.
  *                   This function loads the array with the lowest cost primitives that implement molecule
+ * force_site - optional user-specified primitive site on which to place the molecule; if a force_site
+ *              argument is provided, the function either selects the specified site or reports failure.
+ *              If the force_site argument is set to its default value (-1), vpr selects an available site.
  */
 bool get_next_primitive_list(t_cluster_placement_stats* cluster_placement_stats,
                              const t_pack_molecule* molecule,
-                             t_pb_graph_node** primitives_list) {
+                             t_pb_graph_node** primitives_list,
+                             int force_site) {
     std::unordered_multimap<int, t_cluster_placement_primitive*>::iterator best;
 
     int i;
@@ -136,6 +140,23 @@ bool get_next_primitive_list(t_cluster_placement_stats* cluster_placement_stats,
                         continue;
                     }
 
+
+                    /* check for force site match, if applicable */
+                    if (force_site > -1) {
+                        if (force_site == it->second->pb_graph_node->flat_site_index) {
+                            cost = try_place_molecule(molecule, it->second->pb_graph_node, primitives_list);
+                            if (cost < HUGE_POSITIVE_FLOAT) {
+                                cluster_placement_stats->move_primitive_to_inflight(i, it);
+                                return true;
+                            } else {
+                                break;
+                            }
+                        } else {
+                            ++it;
+                            continue;
+                        }
+                    }
+
                     /* try place molecule at root location cur */
                     cost = try_place_molecule(molecule, it->second->pb_graph_node, primitives_list);
 
@@ -153,6 +174,11 @@ bool get_next_primitive_list(t_cluster_placement_stats* cluster_placement_stats,
         }
     }
 
+    /* if force_site was specified but not found, fail */
+    if (force_site > -1) {
+        found_best = false;
+    }
+
     if (!found_best) {
         /* failed to find a placement */
         for (i = 0; i < molecule->num_blocks; i++) {

vpr/src/pack/cluster_placement.h

@@ -6,12 +6,14 @@
 #ifndef CLUSTER_PLACEMENT_H
 #define CLUSTER_PLACEMENT_H
 #include "arch_types.h"
+#include "vpr_types.h"
 
 t_cluster_placement_stats* alloc_and_load_cluster_placement_stats();
 bool get_next_primitive_list(
     t_cluster_placement_stats* cluster_placement_stats,
     const t_pack_molecule* molecule,
-    t_pb_graph_node** primitives_list);
+    t_pb_graph_node** primitives_list,
+    int force_site = -1);
 void commit_primitive(t_cluster_placement_stats* cluster_placement_stats,
                       const t_pb_graph_node* primitive);
 void set_mode_cluster_placement_stats(const t_pb_graph_node* complex_block,

vpr/src/pack/cluster_util.cpp

@@ -932,7 +932,8 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
                                       int feasible_block_array_size,
                                       t_ext_pin_util max_external_pin_util,
                                       PartitionRegion& temp_cluster_pr,
-                                      NocGroupId& temp_noc_grp_id) {
+                                      NocGroupId& temp_noc_grp_id,
+                                      int force_site) {
     t_pb* parent;
     t_pb* cur_pb;
 
@@ -1009,7 +1010,7 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
 
     while (block_pack_status != e_block_pack_status::BLK_PASSED) {
         if (get_next_primitive_list(cluster_placement_stats_ptr, molecule,
-                                    primitives_list)) {
+                                    primitives_list, force_site)) {
             block_pack_status = e_block_pack_status::BLK_PASSED;
 
             int failed_location = 0;
@@ -1383,7 +1384,8 @@ bool atom_cluster_noc_group_check(AtomBlockId blk_id,
                                   ClusterBlockId clb_index,
                                   int verbosity,
                                   NocGroupId& temp_cluster_noc_grp_id) {
-    const NocGroupId atom_noc_grp_id = g_vpr_ctx.cl_helper().atom_noc_grp_id[blk_id];
+    const auto& atom_noc_grp_ids = g_vpr_ctx.cl_helper().atom_noc_grp_id;
+    const NocGroupId atom_noc_grp_id = atom_noc_grp_ids.empty() ? NocGroupId::INVALID() : atom_noc_grp_ids[blk_id];
 
     if (temp_cluster_noc_grp_id == NocGroupId::INVALID()) {
         // the cluster does not have a NoC group

vpr/src/pack/cluster_util.h

@@ -214,7 +214,8 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
                                       int feasible_block_array_size,
                                       t_ext_pin_util max_external_pin_util,
                                       PartitionRegion& temp_cluster_pr,
-                                      NocGroupId& temp_noc_grp_id);
+                                      NocGroupId& temp_noc_grp_id,
+                                      int force_site = -1);
 
 void try_fill_cluster(const t_packer_opts& packer_opts,
                       t_cluster_placement_stats* cur_cluster_placement_stats_ptr,
@@ -493,4 +494,4 @@ bool cleanup_pb(t_pb* pb);
 void alloc_and_load_pb_stats(t_pb* pb, const int feasible_block_array_size);
 
 void init_clb_atoms_lookup(vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>>& atoms_lookup);
-#endif
+#endif

vpr/src/pack/pb_type_graph.cpp

@@ -48,6 +48,7 @@ static void alloc_and_load_pb_graph(t_pb_graph_node* pb_graph_node,
                                     t_pb_graph_node* parent_pb_graph_node,
                                     t_pb_type* pb_type,
                                     const int index,
+                                    const int flat_index,
                                     bool load_power_structures,
                                     int& pin_count_in_cluster,
                                     int& primitive_num);
@@ -135,6 +136,11 @@ static bool check_input_pins_equivalence(const t_pb_graph_pin* cur_pin,
                                          std::map<int, int>& edges_map,
                                          int* line_num);
 
+/* computes the index of a pb graph node at its level of the pb hierarchy */
+static int compute_flat_index_for_child_node(int num_children_of_type,
+                                             int parent_flat_index,
+                                             int child_index);
+
 /**
  * Allocate memory into types and load the pb graph with interconnect edges
  */
@@ -153,6 +159,7 @@ void alloc_and_load_all_pb_graphs(bool load_power_structures, bool is_flat) {
                                     nullptr,
                                     type.pb_type,
                                     0,
+                                    0,
                                     load_power_structures,
                                     pin_count_in_cluster,
                                     primitive_num);
@@ -227,6 +234,7 @@ static void alloc_and_load_pb_graph(t_pb_graph_node* pb_graph_node,
                                     t_pb_graph_node* parent_pb_graph_node,
                                     t_pb_type* pb_type,
                                     const int index,
+                                    const int flat_index,
                                     bool load_power_structures,
                                     int& pin_count_in_cluster,
                                     int& primitive_num) {
@@ -240,6 +248,9 @@ static void alloc_and_load_pb_graph(t_pb_graph_node* pb_graph_node,
     pb_graph_node->num_output_ports = 0;
     pb_graph_node->num_clock_ports = 0;
 
+    pb_graph_node->total_primitive_count = 0;
+    pb_graph_node->flat_site_index = 0;
+
     /* Generate ports for pb graph node */
     for (i = 0; i < pb_type->num_ports; i++) {
         if (pb_type->ports[i].type == IN_PORT && !pb_type->ports[i].is_clock) {
@@ -356,11 +367,15 @@ static void alloc_and_load_pb_graph(t_pb_graph_node* pb_graph_node,
                                                                                 sizeof(t_pb_graph_node*));
         for (j = 0; j < pb_type->modes[i].num_pb_type_children; j++) {
             pb_graph_node->child_pb_graph_nodes[i][j] = (t_pb_graph_node*)vtr::calloc(pb_type->modes[i].pb_type_children[j].num_pb, sizeof(t_pb_graph_node));
-            for (k = 0; k < pb_type->modes[i].pb_type_children[j].num_pb; k++) {
+            int num_children_of_type = pb_type->modes[i].pb_type_children[j].num_pb;
+
+            for (k = 0; k < num_children_of_type; k++) {
+                int child_flat_index = compute_flat_index_for_child_node(num_children_of_type, flat_index, k);
                 alloc_and_load_pb_graph(&pb_graph_node->child_pb_graph_nodes[i][j][k],
                                         pb_graph_node,
                                         &pb_type->modes[i].pb_type_children[j],
                                         k,
+                                        child_flat_index,
                                         load_power_structures,
                                         pin_count_in_cluster,
                                         primitive_num);
@@ -378,6 +393,22 @@ static void alloc_and_load_pb_graph(t_pb_graph_node* pb_graph_node,
                                          &pb_type->modes[i],
                                          load_power_structures);
     }
+
+
+    // update the total number of primitives of that type
+    if (pb_graph_node->is_primitive()) {
+        int total_count = 1;
+        auto pb_node = pb_graph_node;
+        while (!pb_node->is_root()) {
+            total_count *= pb_node->pb_type->num_pb;
+            pb_node = pb_node->parent_pb_graph_node;
+        }
+        pb_graph_node->total_primitive_count = total_count;
+
+        // if this is a primitive, then flat_index corresponds
+        // to its index within all primitives of this type
+        pb_graph_node->flat_site_index = flat_index;
+    }
 }
 
 static void alloc_and_load_pb_graph_pin_sinks(t_pb_graph_node* pb_graph_node) {
@@ -1911,3 +1942,22 @@ const t_pb_graph_edge* get_edge_between_pins(const t_pb_graph_pin* driver_pin, c
 
     return nullptr;
 }
+
+/* Date:June 8th, 2024
+ * Author: Kate Thurmer
+ * Purpose: This subroutine computes the index of a pb graph node at its
+            level of the pb hierarchy; it is computed by the parent and
+            passed to each child of each child pb type. When the child is
+            a primitive, the computed indes is its flat site index.
+            For example, if there are 10 ALMs, each with 2 FFs and 2 LUTs,
+            then the ALM at index N, when calling this function for
+            its FF child at index M, would compute the child's index as:
+                N*(FFs per ALM) + M
+            e.g. for FF[1] in ALM[5], this returns
+                5*(2 FFS per ALM) + 1 = 11
+ */
+static int compute_flat_index_for_child_node(int num_children_of_type,
+                                             int parent_flat_index,
+                                             int child_index) {
+    return parent_flat_index*num_children_of_type + child_index;
+}

vpr/src/pack/re_cluster.cpp

@@ -73,14 +73,6 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
     //Commit or revert the move
     if (is_created) {
         commit_mol_move(old_clb, new_clb, during_packing, true);
-        // Update the clb-->atoms lookup table
-        helper_ctx.atoms_lookup.resize(helper_ctx.total_clb_num);
-        for (int i_atom = 0; i_atom < molecule_size; ++i_atom) {
-            if (molecule->atom_block_ids[i_atom]) {
-                helper_ctx.atoms_lookup[new_clb].insert(molecule->atom_block_ids[i_atom]);
-            }
-        }
-
         VTR_LOGV(verbosity > 4, "Atom:%zu is moved to a new cluster\n", molecule->atom_block_ids[molecule->root]);
     } else {
         revert_mol_move(old_clb, molecule, old_router_data, during_packing, clustering_data);

vpr/src/pack/re_cluster_util.cpp

@@ -127,7 +127,9 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
                                t_clustering_data& clustering_data,
                                t_lb_router_data** router_data,
                                PartitionRegion& temp_cluster_pr,
-                               NocGroupId& temp_cluster_noc_grp_id) {
+                               NocGroupId& temp_cluster_noc_grp_id,
+                               enum e_detailed_routing_stages detailed_routing_stage,
+                               int force_site) {
     auto& atom_ctx = g_vpr_ctx.atom();
     auto& floorplanning_ctx = g_vpr_ctx.mutable_floorplanning();
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
@@ -162,14 +164,15 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
                                     helper_ctx.num_models,
                                     helper_ctx.max_cluster_size,
                                     clb_index,
-                                    E_DETAILED_ROUTE_FOR_EACH_ATOM,
+                                    detailed_routing_stage,
                                     *router_data,
                                     0,
                                     enable_pin_feasibility_filter,
                                     0,
                                     FULL_EXTERNAL_PIN_UTIL,
                                     temp_cluster_pr,
-                                    temp_cluster_noc_grp_id);
+                                    temp_cluster_noc_grp_id,
+                                    force_site);
 
     // If clustering succeeds, add it to the clb netlist
     if (pack_result == e_block_pack_status::BLK_PASSED) {
@@ -185,6 +188,14 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
         int molecule_size = get_array_size_of_molecule(molecule);
         update_cluster_pb_stats(molecule, molecule_size, clb_index, true);
 
+        // Update the clb-->atoms lookup table
+        helper_ctx.atoms_lookup.resize(helper_ctx.total_clb_num);
+        for (int i_atom = 0; i_atom < molecule_size; ++i_atom) {
+            if (molecule->atom_block_ids[i_atom]) {
+                helper_ctx.atoms_lookup[clb_index].insert(molecule->atom_block_ids[i_atom]);
+            }
+        }
+
         //If you are still in packing, update the clustering data. Otherwise, update the clustered netlist.
         if (during_packing) {
             clustering_data.intra_lb_routing.push_back((*router_data)->saved_lb_nets);
@@ -211,7 +222,10 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
                                   bool during_packing,
                                   t_clustering_data& clustering_data,
                                   t_lb_router_data*& router_data,
-                                  bool enable_pin_feasibility_filter) {
+                                  enum e_detailed_routing_stages detailed_routing_stage,
+                                  bool enable_pin_feasibility_filter,
+                                  int force_site) {
+
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
 
@@ -237,15 +251,16 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
                                     helper_ctx.num_models,
                                     helper_ctx.max_cluster_size,
                                     new_clb,
-                                    E_DETAILED_ROUTE_FOR_EACH_ATOM,
+                                    detailed_routing_stage,
                                     router_data,
                                     0,
                                     enable_pin_feasibility_filter,
                                     //false,
                                     helper_ctx.feasible_block_array_size,
                                     target_ext_pin_util,
                                     temp_cluster_pr,
-                                    temp_cluster_noc_grp_id);
+                                    temp_cluster_noc_grp_id,
+                                    force_site);
 
     // If clustering succeeds, add it to the clb netlist
     if (pack_result == e_block_pack_status::BLK_PASSED) {