[Prepacker] Changed Internal Maps to VTR Vectors

For improved performance (and to simplify the interface further),
changed the internal maps to VTR Vectors.

Added asserts to ensure assumptions are maintained.

Author: AlexandreSinger

vpr/src/pack/prepack.cpp

@@ -29,6 +29,7 @@
 #include "vtr_assert.h"
 #include "vtr_range.h"
 #include "vtr_util.h"
+#include "vtr_vector.h"
 
 /*****************************************/
 /*Local Function Declaration			 */
@@ -40,7 +41,7 @@ static void free_list_of_pack_patterns(std::vector<t_pack_patterns>& list_of_pac
 static void free_pack_pattern(t_pack_patterns* pack_pattern);
 
 static t_pack_molecule* alloc_and_load_pack_molecules(t_pack_patterns* list_of_pack_patterns,
-                                                      std::unordered_map<AtomBlockId, t_pb_graph_node*>& expected_lowest_cost_pb_gnode,
+                                                      vtr::vector<AtomBlockId, t_pb_graph_node*>& expected_lowest_cost_pb_gnode,
                                                       const int num_packing_patterns,
                                                       std::multimap<AtomBlockId, t_pack_molecule*>& atom_molecules,
                                                       const AtomNetlist& atom_nlist,
@@ -800,7 +801,7 @@ static void backward_expand_pack_pattern_from_edge(const t_pb_graph_edge* expans
  *     ie. a single linear chain that can be split across multiple complex blocks
  */
 static t_pack_molecule* alloc_and_load_pack_molecules(t_pack_patterns* list_of_pack_patterns,
-                                                      std::unordered_map<AtomBlockId, t_pb_graph_node*>& expected_lowest_cost_pb_gnode,
+                                                      vtr::vector<AtomBlockId, t_pb_graph_node*>& expected_lowest_cost_pb_gnode,
                                                       const int num_packing_patterns,
                                                       std::multimap<AtomBlockId, t_pack_molecule*>& atom_molecules,
                                                       const AtomNetlist& atom_nlist,
@@ -1705,15 +1706,30 @@ static void free_pack_molecules(t_pack_molecule* list_of_pack_molecules) {
 
 void Prepacker::init(const AtomNetlist& atom_nlist, const std::vector<t_logical_block_type>& logical_block_types) {
     VTR_ASSERT(list_of_pack_molecules == nullptr && "Prepacker cannot be initialized twice.");
+
     // Allocate the pack patterns from the logical block types.
     list_of_pack_patterns = alloc_and_load_pack_patterns(logical_block_types);
     // Use the pack patterns to allocate and load the pack molecules.
+    std::multimap<AtomBlockId, t_pack_molecule*> atom_molecules_multimap;
+    expected_lowest_cost_pb_gnode.resize(atom_nlist.blocks().size(), nullptr);
     list_of_pack_molecules = alloc_and_load_pack_molecules(list_of_pack_patterns.data(),
                                                            expected_lowest_cost_pb_gnode,
                                                            list_of_pack_patterns.size(),
-                                                           atom_molecules,
+                                                           atom_molecules_multimap,
                                                            atom_nlist,
                                                            logical_block_types);
+
+    // The multimap is a legacy thing. Since blocks can be part of multiple pack
+    // patterns, during prepacking a block may be contained within multiple
+    // molecules. However, by the end of prepacking, molecules should be
+    // combined such that each block is contained in one and only one molecule.
+    atom_molecules.resize(atom_nlist.blocks().size(), nullptr);
+    for (AtomBlockId blk_id : atom_nlist.blocks()) {
+        // Every atom block should be packed into a single molecule (no more
+        // or less).
+        VTR_ASSERT(atom_molecules_multimap.count(blk_id) == 1);
+        atom_molecules[blk_id] = atom_molecules_multimap.find(blk_id)->second;
+    }
 }
 
 t_molecule_stats Prepacker::calc_max_molecule_stats(const AtomNetlist& atom_nlist) const {

vpr/src/pack/prepack.h

@@ -12,10 +12,9 @@
 
 #include <algorithm>
 #include <map>
-#include <unordered_map>
 #include "vpr_types.h"
 #include "vtr_assert.h"
-#include "vtr_range.h"
+#include "vtr_vector.h"
 
 class AtomNetlist;
 class AtomBlockId;
@@ -28,7 +27,7 @@ struct t_logical_block_type;
  * This class maintains the prepacking state, allowing the use of molecules
  * (prepacked atoms) while this object exists. After prepacking, every atom will
  * be part of a molecule (with a large number being part of single-atom
- * molecules.
+ * molecules).
  *
  * Molecules currently come from pack patterns in the architecture file. For
  * example, a 3-bit carry chain in most architectures would turn into a molecule
@@ -72,18 +71,16 @@ class Prepacker {
     void init(const AtomNetlist& atom_nlist, const std::vector<t_logical_block_type> &logical_block_types);
 
     /**
-     * @brief Get the cluster molecules containing the given atom block.
+     * @brief Get the cluster molecule containing the given atom block.
      *
-     *  @param blk_id       The atom block to get the molecules of.
+     *  @param blk_id       The atom block to get the molecule of.
      */
     inline t_pack_molecule* get_atom_molecule(AtomBlockId blk_id) const {
-        // Internally the prepacker maintains multiple molecules per atom, since
-        // some atoms may be part of multiple pack patterns; however, the
-        // prepacker should merge these eventually into one single molecule.
-        // TODO: If this can be 100% verified, this should be turned into a
-        //       debug assert.
-        VTR_ASSERT(atom_molecules.count(blk_id) == 1);
-        return atom_molecules.find(blk_id)->second;
+        // Safety debug to ensure the blk is valid and has a molecule entry.
+        VTR_ASSERT_SAFE(blk_id.is_valid() && (size_t)blk_id < atom_molecules.size());
+        // Safety debug to ensure the molecule is valid
+        VTR_ASSERT_DEBUG(atom_molecules[blk_id] != nullptr);
+        return atom_molecules[blk_id];
     }
 
     /**
@@ -93,11 +90,11 @@ class Prepacker {
      *  @param blk_id       The atom block to get the pb graph node of.
      */
     inline t_pb_graph_node* get_expected_lowest_cost_pb_gnode(AtomBlockId blk_id) const {
-        auto iter = expected_lowest_cost_pb_gnode.find(blk_id);
-        VTR_ASSERT(iter != expected_lowest_cost_pb_gnode.end());
-        t_pb_graph_node* pb_gnode = iter->second;
-        VTR_ASSERT(pb_gnode != nullptr);
-        return pb_gnode;
+        // Safety debug to ensure the blk is valid and has an entry.
+        VTR_ASSERT_SAFE(blk_id.is_valid() && (size_t)blk_id < expected_lowest_cost_pb_gnode.size());
+        // Ensure the entry is valid.
+        VTR_ASSERT(expected_lowest_cost_pb_gnode[blk_id] != nullptr);
+        return expected_lowest_cost_pb_gnode[blk_id];
     }
 
     /**
@@ -186,14 +183,13 @@ class Prepacker {
     /**
      * @brief The molecules associated with each atom block.
      *
-     * This map is loaded in the prepacking stage and freed at the very end of
-     * vpr flow run. The pointers in this multimap is shared with
-     * list_of_pack_molecules.
+     * This vector is loaded in the init method and cleared in the reset method.
+     * The pointers in this vector are shared with list_of_pack_molecules.
      */
-    std::multimap<AtomBlockId, t_pack_molecule*> atom_molecules;
+    vtr::vector<AtomBlockId, t_pack_molecule*> atom_molecules;
 
-    /// @brief A map for the expected lowest cost physical block graph node.
-    std::unordered_map<AtomBlockId, t_pb_graph_node*> expected_lowest_cost_pb_gnode;
+    /// @brief A vector of the expected lowest cost physical block graph node.
+    vtr::vector<AtomBlockId, t_pb_graph_node*> expected_lowest_cost_pb_gnode;
 
     /// @brief A list of the pack patterns used for prepacking. I think the
     ///        molecules keep pointers to this vector, so this needs to remain