add update_noc_reachability_partitions()

Author: soheilshahrouz

vpr/src/pack/pack.cpp

@@ -5,6 +5,8 @@
 #include <fstream>
 #include <cstdlib>
 #include <sstream>
+#include <limits>
+#include <queue>
 
 #include "vtr_assert.h"
 #include "vtr_log.h"
@@ -60,6 +62,104 @@ static std::vector<AtomBlockId> find_noc_router_atoms() {
     return noc_router_atoms;
 }
 
+static 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;
+    const auto& high_fanout_thresholds = g_vpr_ctx.cl_helper().high_fanout_thresholds;
+
+    const size_t high_fanout_threshold = high_fanout_thresholds.get_threshold("");
+
+    // get the total number of atoms
+    const size_t n_atoms = atom_ctx.nlist.blocks().size();
+
+    vtr::vector<AtomBlockId, bool> atom_visited(n_atoms, false);
+
+    int exclusivity_cnt = 0;
+
+    RegionRectCoord unconstrained_rect{std::numeric_limits<int>::min(),
+                                       std::numeric_limits<int>::min(),
+                                       std::numeric_limits<int>::max(),
+                                       std::numeric_limits<int>::max(),
+                                       -1};
+    Region unconstrained_region;
+    unconstrained_region.set_region_rect(unconstrained_rect);
+
+    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++;
+
+        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);
+        atom_visited[noc_atom_id] = true;
+
+        while (!q.empty()) {
+            AtomBlockId current_atom = q.front();
+            q.pop();
+
+            PartitionId atom_partition_id = constraints.get_atom_partition(noc_atom_id);
+            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);
+                atom_partition_region.set_exclusivity_index(exclusivity_cnt);
+            }
+
+            for(auto pin : atom_ctx.nlist.block_pins(current_atom)) {
+                AtomNetId net_id = atom_ctx.nlist.pin_net(pin);
+                size_t net_fanout = atom_ctx.nlist.net_sinks(net_id).size();
+
+                if (net_fanout >= high_fanout_threshold) {
+                    continue;
+                }
+
+                AtomBlockId driver_atom_id = atom_ctx.nlist.net_driver_block(net_id);
+                if (!atom_visited[driver_atom_id]) {
+                    q.push(driver_atom_id);
+                    atom_visited[driver_atom_id] = true;
+                }
+
+                for (auto sink_pin : atom_ctx.nlist.net_sinks(net_id)) {
+                    AtomBlockId sink_atom_id = atom_ctx.nlist.pin_block(sink_pin);
+                    if (!atom_visited[sink_atom_id]) {
+                        q.push(sink_atom_id);
+                        atom_visited[sink_atom_id] = true;
+                    }
+                }
+
+            }
+        }
+
+    }
+}
+
+
 bool try_pack(t_packer_opts* packer_opts,
               const t_analysis_opts* analysis_opts,
               const t_arch* arch,
@@ -151,10 +251,9 @@ bool try_pack(t_packer_opts* packer_opts,
     int pack_iteration = 1;
     bool floorplan_regions_overfull = false;
 
+    // find all NoC router atoms
     auto noc_atoms = find_noc_router_atoms();
-    for (auto noc_atom : noc_atoms) {
-        std::cout << "NoC Atom: " << atom_ctx.nlist.block_name(noc_atom) << std::endl;
-    }
+    update_noc_reachability_partitions(noc_atoms);
 
     while (true) {
         free_clustering_data(*packer_opts, clustering_data);