Merge pull request #725 from os-fpga/finished_packer_fix_merge

serge-dsa · web-flow · commit a4e76d96ae8e · 2024-06-19T12:54:52.000-07:00
finished packer_fix merge
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -135,7 +135,6 @@ FILE(COPY ${PACKER_SRC_DIR}/cluster.cpp
           ${PACKER_SRC_DIR}/output_clustering.h
           ${PACKER_SRC_DIR}/cluster_router.cpp
           ${PACKER_SRC_DIR}/post_routing_pb_pin_fixup.cpp
-          ${PACKER_SRC_DIR}/pack.cpp
           DESTINATION
           ${VPR_DEST_DIR}/src/pack)
 
diff --git a/include/packer_fix/cluster.cpp b/include/packer_fix/cluster.cpp
@@ -99,14 +99,12 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                                          const t_analysis_opts& analysis_opts,
                                                          const t_arch* arch,
                                                          t_pack_molecule* molecule_head,
-                                                         int num_models,
                                                          const std::unordered_set<AtomNetId>& is_clock,
+                                                         const std::unordered_set<AtomNetId>& is_global,
                                                          const std::unordered_map<AtomBlockId, t_pb_graph_node*>& expected_lowest_cost_pb_gnode,
                                                          bool allow_unrelated_clustering,
                                                          bool balance_block_type_utilization,
                                                          std::vector<t_lb_type_rr_node>* lb_type_rr_graphs,
-                                                         const t_ext_pin_util_targets& ext_pin_util_targets,
-                                                         const t_pack_high_fanout_thresholds& high_fanout_thresholds,
                                                          AttractionInfo& attraction_groups,
                                                          bool& floorplan_regions_overfull,
                                                          t_clustering_data& clustering_data) {
@@ -237,7 +235,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
 
     auto seed_atoms = initialize_seed_atoms(packer_opts.cluster_seed_type, max_molecule_stats, atom_criticality);
 
-    istart = get_highest_gain_seed_molecule(&seedindex, seed_atoms);
+    istart = get_highest_gain_seed_molecule(seedindex, seed_atoms);
 
     print_pack_status_header();
 
@@ -405,7 +403,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                     clb_index, istart,
                                     num_used_type_instances,
                                     packer_opts.target_device_utilization,
-                                    num_models, helper_ctx.max_cluster_size,
+                                    helper_ctx.num_models, helper_ctx.max_cluster_size,
                                     arch, packer_opts.device_layout,
                                     lb_type_rr_graphs, &router_data,
                                     detailed_routing_stage, &cluster_ctx.clb_nlist,
@@ -435,11 +433,11 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                     //Progress dot for seed-block
                     fflush(stdout);
 
-                    t_ext_pin_util target_ext_pin_util = ext_pin_util_targets.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_index)->name);
-                    int high_fanout_threshold = high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
+                    t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_index)->name);
+                    int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
                     update_cluster_stats(istart, clb_index,
                                         is_clock, //Set of clock nets
-                                        is_clock, //Set of global nets (currently all clocks)
+                                        is_global, //Set of global nets (currently all clocks)
                                         packer_opts.global_clocks,
                                         packer_opts.alpha, packer_opts.beta,
                                         packer_opts.timing_driven, packer_opts.connection_driven,
@@ -505,7 +503,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                         helper_ctx.primitives_list,
                                         cluster_stats,
                                         helper_ctx.total_clb_num,
-                                        num_models,
+                                        helper_ctx.num_models,
                                         helper_ctx.max_cluster_size,
                                         clb_index,
                                         detailed_routing_stage,
@@ -514,6 +512,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                         allow_unrelated_clustering,
                                         high_fanout_threshold,
                                         is_clock,
+                                        is_global,
                                         timing_info,
                                         router_data,
                                         target_ext_pin_util,
@@ -627,7 +626,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                   clb_index, istart,
                                   num_used_type_instances,
                                   packer_opts.target_device_utilization,
-                                  num_models, helper_ctx.max_cluster_size,
+                                  helper_ctx.num_models, helper_ctx.max_cluster_size,
                                   arch, packer_opts.device_layout,
                                   lb_type_rr_graphs, &router_data,
                                   detailed_routing_stage, &cluster_ctx.clb_nlist,
@@ -657,11 +656,11 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                 //Progress dot for seed-block
                 fflush(stdout);
 
-                t_ext_pin_util target_ext_pin_util = ext_pin_util_targets.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_index)->name);
-                int high_fanout_threshold = high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
+                t_ext_pin_util target_ext_pin_util = helper_ctx.target_external_pin_util.get_pin_util(cluster_ctx.clb_nlist.block_type(clb_index)->name);
+                int high_fanout_threshold = helper_ctx.high_fanout_thresholds.get_threshold(cluster_ctx.clb_nlist.block_type(clb_index)->name);
                 update_cluster_stats(istart, clb_index,
                                      is_clock, //Set of clock nets
-                                     is_clock, //Set of global nets (currently all clocks)
+                                     is_global, //Set of global nets (currently all clocks)
                                      packer_opts.global_clocks,
                                      packer_opts.alpha, packer_opts.beta,
                                      packer_opts.timing_driven, packer_opts.connection_driven,
@@ -721,7 +720,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                      helper_ctx.primitives_list,
                                      cluster_stats,
                                      helper_ctx.total_clb_num,
-                                     num_models,
+                                     helper_ctx.num_models,
                                      helper_ctx.max_cluster_size,
                                      clb_index,
                                      detailed_routing_stage,
@@ -730,6 +729,7 @@ std::map<t_logical_block_type_ptr, size_t> do_clustering(const t_packer_opts& pa
                                      allow_unrelated_clustering,
                                      high_fanout_threshold,
                                      is_clock,
+                                     is_global,
                                      timing_info,
                                      router_data,
                                      target_ext_pin_util,
diff --git a/include/packer_fix/cluster_util.cpp b/include/packer_fix/cluster_util.cpp
@@ -1519,6 +1519,7 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       bool allow_unrelated_clustering,
                       const int& high_fanout_threshold,
                       const std::unordered_set<AtomNetId>& is_clock,
+                      const std::unordered_set<AtomNetId>& is_global,
                       const std::shared_ptr<SetupTimingInfo>& timing_info,
                       t_lb_router_data* router_data,
                       t_ext_pin_util target_ext_pin_util,
@@ -1613,8 +1614,8 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       attraction_groups);
 
     update_cluster_stats(next_molecule, clb_index,
-                         is_clock, //Set of all clocks
-                         is_clock, //Set of all global signals (currently clocks)
+                         is_clock,  //Set of all clocks
+                         is_global, //Set of all global signals (currently clocks)
                          packer_opts.global_clocks, packer_opts.alpha, packer_opts.beta, packer_opts.timing_driven,
                          packer_opts.connection_driven,
                          high_fanout_threshold,
@@ -1664,7 +1665,7 @@ t_pack_molecule* save_cluster_routing_and_pick_new_seed(const t_packer_opts& pac
 
     //Pick a new seed
     if (not packer_opts.use_partitioning_in_pack or partitioning_status_NOP()) {
-        next_seed = get_highest_gain_seed_molecule(&seedindex, seed_atoms);
+        next_seed = get_highest_gain_seed_molecule(seedindex, seed_atoms);
     }
 
     if (packer_opts.timing_driven) {
@@ -2124,9 +2125,7 @@ void start_new_cluster(t_cluster_placement_stats* cluster_placement_stats,
 
     //Try packing into each candidate type
     bool success = false;
-    for (size_t i = 0; i < candidate_types.size(); i++) {
-        auto type = candidate_types[i];
-
+    for (auto type : candidate_types) {
         t_pb* pb = new t_pb;
         pb->pb_graph_node = type->pb_graph_head;
         alloc_and_load_pb_stats(pb, feasible_block_array_size);
@@ -2693,13 +2692,10 @@ t_molecule_stats calc_max_molecules_stats(const t_pack_molecule* molecule_head)
 std::vector<AtomBlockId> initialize_seed_atoms(const e_cluster_seed seed_type,
                                                const t_molecule_stats& max_molecule_stats,
                                                const vtr::vector<AtomBlockId, float>& atom_criticality) {
-    std::vector<AtomBlockId> seed_atoms;
+    auto& atom_ctx = g_vpr_ctx.atom();
 
     //Put all atoms in seed list
-    auto& atom_ctx = g_vpr_ctx.atom();
-    for (auto blk : atom_ctx.nlist.blocks()) {
-        seed_atoms.emplace_back(blk);
-    }
+    std::vector<AtomBlockId> seed_atoms(atom_ctx.nlist.blocks().begin(), atom_ctx.nlist.blocks().end());
 
     //Initially all gains are zero
     vtr::vector<AtomBlockId, float> atom_gains(atom_ctx.nlist.blocks().size(), 0.);
@@ -2849,15 +2845,18 @@ std::vector<AtomBlockId> initialize_seed_atoms(const e_cluster_seed seed_type,
     return seed_atoms;
 }
 
-t_pack_molecule* get_highest_gain_seed_molecule(int* seedindex, const std::vector<AtomBlockId> seed_atoms) {
+t_pack_molecule* get_highest_gain_seed_molecule(int& seed_index, const std::vector<AtomBlockId>& seed_atoms) {
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    while (*seedindex < static_cast<int>(seed_atoms.size())) {
-        AtomBlockId blk_id = seed_atoms[(*seedindex)++];
+    while (seed_index < static_cast<int>(seed_atoms.size())) {
+        AtomBlockId blk_id = seed_atoms[seed_index++];
 
+        // Check if the atom has already been assigned to a cluster
         if (atom_ctx.lookup.atom_clb(blk_id) == ClusterBlockId::INVALID()) {
             t_pack_molecule* best = nullptr;
 
+            // Iterate over all the molecules associated with the selected atom
+            // and select the one with the highest gain
             auto rng = atom_ctx.atom_molecules.equal_range(blk_id);
             for (const auto& kv : vtr::make_range(rng.first, rng.second)) {
                 t_pack_molecule* molecule = kv.second;
@@ -3369,11 +3368,15 @@ std::map<const t_model*, std::vector<t_logical_block_type_ptr>> identify_primiti
     auto& device_ctx = g_vpr_ctx.device();
 
     std::set<const t_model*> unique_models;
+    // Find all logic models used in the netlist
     for (auto blk : atom_nlist.blocks()) {
         auto model = atom_nlist.block_model(blk);
         unique_models.insert(model);
     }
 
+    /* For each technology-mapped logic model, find logical block types
+     * that can accommodate that logic model
+     */
     for (auto model : unique_models) {
         model_candidates[model] = {};
 
@@ -3712,6 +3715,11 @@ void init_clb_atoms_lookup(vtr::vector<ClusterBlockId, std::unordered_set<AtomBl
     for (auto atom_blk_id : atom_ctx.nlist.blocks()) {
         ClusterBlockId clb_index = atom_ctx.lookup.atom_clb(atom_blk_id);
 
-        atoms_lookup[clb_index].insert(atom_blk_id);
+        /* if this data structure is being built alongside the clustered netlist    */
+        /* e.g. when ingesting and legalizing a flat placement solution, some atoms */
+        /* may not yet be mapped to a valid clb_index                               */
+        if (clb_index != ClusterBlockId::INVALID()) {
+            atoms_lookup[clb_index].insert(atom_blk_id);
+        }
     }
 }
diff --git a/include/packer_fix/cluster_util.h b/include/packer_fix/cluster_util.h
@@ -240,6 +240,7 @@ void try_fill_cluster(const t_packer_opts& packer_opts,
                       bool allow_unrelated_clustering,
                       const int& high_fanout_threshold,
                       const std::unordered_set<AtomNetId>& is_clock,
+                      const std::unordered_set<AtomNetId>& is_global,
                       const std::shared_ptr<SetupTimingInfo>& timing_info,
                       t_lb_router_data* router_data,
                       t_ext_pin_util target_ext_pin_util,
@@ -415,7 +416,7 @@ std::vector<AtomBlockId> initialize_seed_atoms(const e_cluster_seed seed_type,
                                                const t_molecule_stats& max_molecule_stats,
                                                const vtr::vector<AtomBlockId, float>& atom_criticality);
 
-t_pack_molecule* get_highest_gain_seed_molecule(int* seedindex, const std::vector<AtomBlockId> seed_atoms);
+t_pack_molecule* get_highest_gain_seed_molecule(int& seed_index, const std::vector<AtomBlockId>& seed_atoms);
 
 float get_molecule_gain(t_pack_molecule* molecule, std::map<AtomBlockId, float>& blk_gain, AttractGroupId cluster_attraction_group_id, AttractionInfo& attraction_groups, int num_molecule_failures);
 
diff --git a/include/packer_fix/pack.cpp b/include/packer_fix/pack.cpp
