check NoC group compatibility during packing

Author: soheilshahrouz

vpr/src/base/vpr_context.h

@@ -352,6 +352,9 @@ struct ClusteringHelperContext : public Context {
     // A vector of unordered_sets of AtomBlockIds that are inside each clustered block [0 .. num_clustered_blocks-1]
     // unordered_set for faster insertion/deletion during the iterative improvement process of packing
     vtr::vector<ClusterBlockId, std::unordered_set<AtomBlockId>> atoms_lookup;
+
+    vtr::vector<AtomBlockId, NocGroupId> atom_noc_grp_id;
+
     ~ClusteringHelperContext() {
         delete[] primitives_list;
     }
@@ -512,7 +515,7 @@ struct FloorplanningContext : public Context {
 /**
  * @brief State of the Network on Chip (NoC)
  *
- * This should only contain data structures related to descrbing the
+ * This should only contain data structures related to describing the
  * NoC within the device.
  */
 struct NocContext : public Context {

vpr/src/base/vpr_types.h

@@ -175,6 +175,7 @@ enum class e_block_pack_status {
     BLK_FAILED_FEASIBLE,
     BLK_FAILED_ROUTE,
     BLK_FAILED_FLOORPLANNING,
+    BLK_FAILED_NOC_GROUP,
     BLK_STATUS_UNDEFINED
 };
 

vpr/src/pack/cluster.cpp

@@ -243,6 +243,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
              * Since some of the primitives might fail legality, this structure temporarily
              * stores PartitionRegion information while the cluster is packed*/
             PartitionRegion temp_cluster_pr;
+            NocGroupId temp_cluster_noc_grp_id = NocGroupId::INVALID();
 
             start_new_cluster(helper_ctx.cluster_placement_stats, helper_ctx.primitives_list,
                               clb_index, istart,
@@ -257,7 +258,8 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                               packer_opts.enable_pin_feasibility_filter,
                               balance_block_type_utilization,
                               packer_opts.feasible_block_array_size,
-                              temp_cluster_pr);
+                              temp_cluster_pr,
+                              temp_cluster_noc_grp_id);
 
             //initial molecule in cluster has been processed
             cluster_stats.num_molecules_processed++;
@@ -356,6 +358,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                  router_data,
                                  target_ext_pin_util,
                                  temp_cluster_pr,
+                                 temp_cluster_noc_grp_id,
                                  block_pack_status,
                                  clustering_data.unclustered_list_head,
                                  unclustered_list_head_size,

vpr/src/pack/cluster_util.cpp

@@ -931,7 +931,8 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
                                       bool enable_pin_feasibility_filter,
                                       int feasible_block_array_size,
                                       t_ext_pin_util max_external_pin_util,
-                                      PartitionRegion& temp_cluster_pr) {
+                                      PartitionRegion& temp_cluster_pr,
+                                      NocGroupId& temp_noc_grp_id) {
     t_pb* parent;
     t_pb* cur_pb;
 
@@ -989,6 +990,20 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
         }
     }
 
+    // check if all atoms in the molecule can be added to the cluster without NoC group conflicts
+    for (int i_mol = 0; i_mol < molecule_size; i_mol++) {
+        if (molecule->atom_block_ids[i_mol]) {
+            bool block_pack_noc_grp_status = atom_cluster_noc_group_check(molecule->atom_block_ids[i_mol],
+                                                                          verbosity, temp_noc_grp_id);
+
+            if (!block_pack_noc_grp_status) {
+                //Record the failure of this molecule in the current pb stats
+                record_molecule_failure(molecule, pb);
+                return e_block_pack_status::BLK_FAILED_NOC_GROUP;
+            }
+        }
+    }
+
     e_block_pack_status block_pack_status = e_block_pack_status::BLK_STATUS_UNDEFINED;
 
     while (block_pack_status != e_block_pack_status::BLK_PASSED) {
@@ -1362,6 +1377,28 @@ bool atom_cluster_floorplanning_check(AtomBlockId blk_id,
     }
 }
 
+bool atom_cluster_noc_group_check(AtomBlockId blk_id,
+                                  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];
+
+
+    if (temp_cluster_noc_grp_id == NocGroupId::INVALID()) {
+        // the cluster does not have a NoC group
+        // assign the atom's NoC group to cluster
+        temp_cluster_noc_grp_id = atom_noc_grp_id;
+        return true;
+    } else if (temp_cluster_noc_grp_id == atom_noc_grp_id) {
+        // the cluster has the same NoC group ID as the atom,
+        // so they are compatible
+        return true;
+    } else {
+        // the cluster belongs to a different NoC group than the atom's group,
+        // so they are incompatible
+        return false;
+    }
+}
+
 /* Revert trial atom block iblock and free up memory space accordingly
  */
 void revert_place_atom_block(const AtomBlockId blk_id, t_lb_router_data* router_data) {
@@ -1497,6 +1534,7 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       t_lb_router_data* router_data,
                       t_ext_pin_util target_ext_pin_util,
                       PartitionRegion& temp_cluster_pr,
+                      NocGroupId& temp_noc_grp_id,
                       e_block_pack_status& block_pack_status,
                       t_molecule_link* unclustered_list_head,
                       const int& unclustered_list_head_size,
@@ -1519,7 +1557,8 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                                           packer_opts.enable_pin_feasibility_filter,
                                           packer_opts.feasible_block_array_size,
                                           target_ext_pin_util,
-                                          temp_cluster_pr);
+                                          temp_cluster_pr,
+                                          temp_noc_grp_id);
 
     auto blk_id = next_molecule->atom_block_ids[next_molecule->root];
     VTR_ASSERT(blk_id);
@@ -2041,7 +2080,8 @@ void start_new_cluster(t_cluster_placement_stats* cluster_placement_stats,
                        bool enable_pin_feasibility_filter,
                        bool balance_block_type_utilization,
                        const int feasible_block_array_size,
-                       PartitionRegion& temp_cluster_pr) {
+                       PartitionRegion& temp_cluster_pr,
+                       NocGroupId& temp_noc_grp_id) {
     /* Given a starting seed block, start_new_cluster determines the next cluster type to use
      * It expands the FPGA if it cannot find a legal cluster for the atom block
      */
@@ -2123,7 +2163,8 @@ void start_new_cluster(t_cluster_placement_stats* cluster_placement_stats,
                                             enable_pin_feasibility_filter,
                                             feasible_block_array_size,
                                             FULL_EXTERNAL_PIN_UTIL,
-                                            temp_cluster_pr);
+                                            temp_cluster_pr,
+                                            temp_noc_grp_id);
 
             success = (pack_result == e_block_pack_status::BLK_PASSED);
         }

vpr/src/pack/cluster_util.h

@@ -213,7 +213,8 @@ e_block_pack_status try_pack_molecule(t_cluster_placement_stats* cluster_placeme
                                       bool enable_pin_feasibility_filter,
                                       int feasible_block_array_size,
                                       t_ext_pin_util max_external_pin_util,
-                                      PartitionRegion& temp_cluster_pr);
+                                      PartitionRegion& temp_cluster_pr,
+                                      NocGroupId& temp_noc_grp_id);
 
 void try_fill_cluster(const t_packer_opts& packer_opts,
                       t_cluster_placement_stats* cur_cluster_placement_stats_ptr,
@@ -237,6 +238,7 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       t_lb_router_data* router_data,
                       t_ext_pin_util target_ext_pin_util,
                       PartitionRegion& temp_cluster_pr,
+                      NocGroupId& temp_noc_grp_id,
                       e_block_pack_status& block_pack_status,
                       t_molecule_link* unclustered_list_head,
                       const int& unclustered_list_head_size,
@@ -284,6 +286,10 @@ bool atom_cluster_floorplanning_check(AtomBlockId blk_id,
                                       PartitionRegion& temp_cluster_pr,
                                       bool& cluster_pr_needs_update);
 
+bool atom_cluster_noc_group_check(AtomBlockId blk_id,
+                                  int verbosity,
+                                  NocGroupId& temp_cluster_noc_grp_id);
+
 void revert_place_atom_block(const AtomBlockId blk_id, t_lb_router_data* router_data);
 
 void update_connection_gain_values(const AtomNetId net_id, const AtomBlockId clustered_blk_id, t_pb* cur_pb, enum e_net_relation_to_clustered_block net_relation_to_clustered_block);
@@ -341,7 +347,8 @@ void start_new_cluster(t_cluster_placement_stats* cluster_placement_stats,
                        bool enable_pin_feasibility_filter,
                        bool balance_block_type_utilization,
                        const int feasible_block_array_size,
-                       PartitionRegion& temp_cluster_pr);
+                       PartitionRegion& temp_cluster_pr,
+                       NocGroupId& temp_noc_grp_id);
 
 t_pack_molecule* get_highest_gain_molecule(t_pb* cur_pb,
                                            AttractionInfo& attraction_groups,

vpr/src/pack/noc_aware_cluster_util.cpp

@@ -26,10 +26,9 @@ std::vector<AtomBlockId> find_noc_router_atoms() {
 
 void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atoms) {
     const auto& atom_ctx = g_vpr_ctx.atom();
-    auto& constraints = g_vpr_ctx.mutable_floorplanning().constraints;
+    auto& cl_helper_ctx = g_vpr_ctx.mutable_cl_helper();
     const auto& high_fanout_thresholds = g_vpr_ctx.cl_helper().high_fanout_thresholds;
-    const auto& device_ctx = g_vpr_ctx.device();
-    const auto& grid = device_ctx.grid;
+    const auto& grid = g_vpr_ctx.device().grid;
 
     t_logical_block_type_ptr logic_block_type = infer_logic_block_type(grid);
     const size_t high_fanout_threshold = high_fanout_thresholds.get_threshold(logic_block_type->name);
@@ -39,44 +38,19 @@ void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atom
 
     vtr::vector<AtomBlockId, bool> atom_visited(n_atoms, false);
 
-    int exclusivity_cnt = 0;
+    cl_helper_ctx.atom_noc_grp_id.resize(n_atoms, NocGroupId::INVALID());
 
-    RegionRectCoord unconstrained_rect{0,
-                                       0,
-                                       std::numeric_limits<int>::max(),
-                                       std::numeric_limits<int>::max(),
-                                       0};
-    Region unconstrained_region;
-    unconstrained_region.set_region_rect(unconstrained_rect);
+    int noc_grp_id_cnt = 0;
 
     for (auto noc_atom_id : noc_atoms) {
         // check if this NoC router has already been visited
         if (atom_visited[noc_atom_id]) {
             continue;
         }
 
-        exclusivity_cnt++;
+        auto noc_grp_id = (NocGroupId)noc_grp_id_cnt;
+        noc_grp_id_cnt++;
 
-        PartitionRegion associated_noc_partition_region;
-        associated_noc_partition_region.set_exclusivity_index(exclusivity_cnt);
-        associated_noc_partition_region.add_to_part_region(unconstrained_region);
-
-        Partition associated_noc_partition;
-        associated_noc_partition.set_name(atom_ctx.nlist.block_name(noc_atom_id));
-        associated_noc_partition.set_part_region(associated_noc_partition_region);
-        auto associated_noc_partition_id = (PartitionId)constraints.get_num_partitions();
-        constraints.add_partition(associated_noc_partition);
-
-        const PartitionId noc_partition_id = constraints.get_atom_partition(noc_atom_id);
-
-        if (noc_partition_id == PartitionId::INVALID()) {
-            constraints.add_constrained_atom(noc_atom_id, associated_noc_partition_id);
-        } else {    // noc atom is already in a partition
-            auto& noc_partition = constraints.get_mutable_partition(noc_partition_id);
-            auto& noc_partition_region = noc_partition.get_mutable_part_region();
-            VTR_ASSERT(noc_partition_region.get_exclusivity_index() < 0);
-            noc_partition_region.set_exclusivity_index(exclusivity_cnt);
-        }
 
         std::queue<AtomBlockId> q;
         q.push(noc_atom_id);
@@ -86,15 +60,7 @@ void update_noc_reachability_partitions(const std::vector<AtomBlockId>& noc_atom
             AtomBlockId current_atom = q.front();
             q.pop();
 
-            PartitionId atom_partition_id = constraints.get_atom_partition(current_atom);
-            if (atom_partition_id == PartitionId::INVALID()) {
-                constraints.add_constrained_atom(current_atom, associated_noc_partition_id);
-            } else {
-                auto& atom_partition = constraints.get_mutable_partition(atom_partition_id);
-                auto& atom_partition_region = atom_partition.get_mutable_part_region();
-                VTR_ASSERT(atom_partition_region.get_exclusivity_index() < 0 || current_atom == noc_atom_id);
-                atom_partition_region.set_exclusivity_index(exclusivity_cnt);
-            }
+            cl_helper_ctx.atom_noc_grp_id[current_atom] = noc_grp_id;
 
             for(auto pin : atom_ctx.nlist.block_pins(current_atom)) {
                 AtomNetId net_id = atom_ctx.nlist.pin_net(pin);

vpr/src/pack/pack.cpp

@@ -272,21 +272,6 @@ bool try_pack(t_packer_opts* packer_opts,
     //check clustering and output it
     check_and_output_clustering(*packer_opts, is_clock, arch, helper_ctx.total_clb_num, clustering_data.intra_lb_routing);
 
-
-    g_vpr_ctx.mutable_floorplanning().constraints = constraints_backup;
-    const int max_y = (int)g_vpr_ctx.device().grid.height();
-    const int max_x = (int)g_vpr_ctx.device().grid.width();
-    for (auto& cluster_partition_region : g_vpr_ctx.mutable_floorplanning().cluster_constraints) {
-        const auto& regions = cluster_partition_region.get_regions();
-        if (regions.size() == 1) {
-            const auto rect = regions[0].get_region_rect();
-
-            if (rect.xmin <= 0 && rect.ymin <= 0 && rect.xmax >= max_x && rect.ymax >= max_y) {
-                cluster_partition_region = PartitionRegion();
-            }
-        }
-    }
-
     // Free Data Structures
     free_clustering_data(*packer_opts, clustering_data);
 

vpr/src/pack/re_cluster.cpp

@@ -16,6 +16,7 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
     ClusterBlockId old_clb = atom_to_cluster(molecule->atom_block_ids[molecule->root]);
     int molecule_size = get_array_size_of_molecule(molecule);
 
+    NocGroupId temp_noc_grp_id = NocGroupId::INVALID();
     PartitionRegion temp_cluster_pr;
     t_lb_router_data* old_router_data = nullptr;
     t_lb_router_data* router_data = nullptr;
@@ -66,7 +67,8 @@ bool move_mol_to_new_cluster(t_pack_molecule* molecule,
                                            verbosity,
                                            clustering_data,
                                            &router_data,
-                                           temp_cluster_pr);
+                                           temp_cluster_pr,
+                                           temp_noc_grp_id);
 
     //Commit or revert the move
     if (is_created) {

vpr/src/pack/re_cluster_util.cpp

@@ -8,6 +8,7 @@
 #include "initial_placement.h"
 #include "read_netlist.h"
 
+
 //The name suffix of the new block (if exists)
 const char* name_suffix = "_m";
 
@@ -122,7 +123,8 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
                                int verbosity,
                                t_clustering_data& clustering_data,
                                t_lb_router_data** router_data,
-                               PartitionRegion& temp_cluster_pr) {
+                               PartitionRegion& temp_cluster_pr,
+                               NocGroupId& temp_cluster_noc_grp_id) {
     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,7 +164,8 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
                                     enable_pin_feasibility_filter,
                                     0,
                                     FULL_EXTERNAL_PIN_UTIL,
-                                    temp_cluster_pr);
+                                    temp_cluster_pr,
+                                    temp_cluster_noc_grp_id);
 
     // If clustering succeeds, add it to the clb netlist
     if (pack_result == e_block_pack_status::BLK_PASSED) {
@@ -206,6 +209,7 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
 
+    NocGroupId temp_cluster_noc_grp_id;
     PartitionRegion temp_cluster_pr;
     e_block_pack_status pack_result = e_block_pack_status::BLK_STATUS_UNDEFINED;
     t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(new_clb)->name);
@@ -235,7 +239,8 @@ bool pack_mol_in_existing_cluster(t_pack_molecule* molecule,
                                     //false,
                                     helper_ctx.feasible_block_array_size,
                                     target_ext_pin_util,
-                                    temp_cluster_pr);
+                                    temp_cluster_pr,
+                                    temp_cluster_noc_grp_id);
 
     // If clustering succeeds, add it to the clb netlist
     if (pack_result == e_block_pack_status::BLK_PASSED) {
@@ -282,6 +287,7 @@ void revert_mol_move(const ClusterBlockId& old_clb,
     auto& helper_ctx = g_vpr_ctx.mutable_cl_helper();
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
 
+    NocGroupId temp_cluster_noc_grp_id_original;
     PartitionRegion temp_cluster_pr_original;
     e_block_pack_status pack_result = try_pack_molecule(&(helper_ctx.cluster_placement_stats[cluster_ctx.clb_nlist.block_type(old_clb)->index]),
                                                         molecule,
@@ -296,7 +302,8 @@ void revert_mol_move(const ClusterBlockId& old_clb,
                                                         helper_ctx.enable_pin_feasibility_filter,
                                                         helper_ctx.feasible_block_array_size,
                                                         helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(old_clb)->name),
-                                                        temp_cluster_pr_original);
+                                                        temp_cluster_pr_original,
+                                                        temp_cluster_noc_grp_id_original);
 
     VTR_ASSERT(pack_result == e_block_pack_status::BLK_PASSED);
     //If you are still in packing, update the clustering data. Otherwise, update the clustered netlist.

vpr/src/pack/re_cluster_util.h

@@ -87,7 +87,8 @@ bool start_new_cluster_for_mol(t_pack_molecule* molecule,
                                int verbosity,
                                t_clustering_data& clustering_data,
                                t_lb_router_data** router_data,
-                               PartitionRegion& temp_cluster_pr);
+                               PartitionRegion& temp_cluster_pr,
+                               NocGroupId& temp_cluster_noc_grp_id);
 
 /**
  * @brief A function that packs a molecule into an existing cluster