add blk_loc_registry.cpp/.h

vpr/src/base/blk_loc_registry.cpp

@@ -0,0 +1,40 @@
+
+#include "blk_loc_registry.h"
+#include "globals.h"
+
+const vtr::vector_map<ClusterBlockId, t_block_loc>& BlkLocRegistry::block_locs() const {
+    return  block_locs_;
+}
+
+vtr::vector_map<ClusterBlockId, t_block_loc>& BlkLocRegistry::mutable_block_locs() {
+    return  block_locs_;
+}
+
+const GridBlock& BlkLocRegistry::grid_blocks() const {
+    return grid_blocks_;
+}
+
+GridBlock& BlkLocRegistry::mutable_grid_blocks() {
+    return grid_blocks_;
+}
+
+const vtr::vector_map<ClusterPinId, int>& BlkLocRegistry::physical_pins() const {
+    return physical_pins_;
+}
+
+vtr::vector_map<ClusterPinId, int>& BlkLocRegistry::mutable_physical_pins() {
+    return physical_pins_;
+}
+
+int BlkLocRegistry::tile_pin_index(const ClusterPinId pin) const {
+    return physical_pins_[pin];
+}
+
+int BlkLocRegistry::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const {
+    auto& cluster_ctx = g_vpr_ctx.clustering();
+
+    // Get the logical pin index of pin within its logical block type
+    ClusterPinId pin_id = cluster_ctx.clb_nlist.net_pin(net_id, net_pin_index);
+
+    return this->tile_pin_index(pin_id);
+}

vpr/src/base/blk_loc_registry.h

@@ -0,0 +1,46 @@
+#ifndef VTR_BLK_LOC_REGISTRY_H
+#define VTR_BLK_LOC_REGISTRY_H
+
+#include "clustered_netlist_fwd.h"
+#include "vtr_vector_map.h"
+#include "vpr_types.h"
+
+struct t_block_loc;
+
+class BlkLocRegistry {
+  public:
+    BlkLocRegistry() = default;
+    ~BlkLocRegistry() = default;
+    BlkLocRegistry(const BlkLocRegistry&) = delete;
+    BlkLocRegistry& operator=(const BlkLocRegistry&) = default;
+    BlkLocRegistry(BlkLocRegistry&&) = delete;
+    BlkLocRegistry& operator=(BlkLocRegistry&&) = delete;
+
+  private:
+    ///@brief Clustered block placement locations
+    vtr::vector_map<ClusterBlockId, t_block_loc> block_locs_;
+
+    ///@brief Clustered block associated with each grid location (i.e. inverse of block_locs)
+    GridBlock grid_blocks_;
+
+    ///@brief Clustered pin placement mapping with physical pin
+    vtr::vector_map<ClusterPinId, int> physical_pins_;
+
+  public:
+    const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs() const;
+    vtr::vector_map<ClusterBlockId, t_block_loc>& mutable_block_locs();
+
+    const GridBlock& grid_blocks() const;
+    GridBlock& mutable_grid_blocks();
+
+    const vtr::vector_map<ClusterPinId, int>& physical_pins() const;
+    vtr::vector_map<ClusterPinId, int>& mutable_physical_pins();
+
+    ///@brief Returns the physical pin of the tile, related to the given ClusterPinId
+    int tile_pin_index(const ClusterPinId pin) const;
+
+    ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
+    int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
+};
+
+#endif //VTR_BLK_LOC_REGISTRY_H

vpr/src/base/vpr_context.h

@@ -33,6 +33,7 @@
 #include "noc_traffic_flows.h"
 #include "noc_routing.h"
 #include "tatum/report/TimingPath.hpp"
+#include "blk_loc_registry.h"
 
 #ifndef NO_SERVER
 

vpr/src/base/vpr_types.cpp

@@ -558,12 +558,3 @@ void t_cluster_placement_stats::free_primitives() {
         }
     }
 }
-
-int BlkLocRegistry::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const {
-    auto& cluster_ctx = g_vpr_ctx.clustering();
-
-    // Get the logical pin index of pin within its logical block type
-    ClusterPinId pin_id = cluster_ctx.clb_nlist.net_pin(net_id, net_pin_index);
-
-    return this->tile_pin_index(pin_id);
-}

vpr/src/base/vpr_types.h

@@ -907,41 +907,6 @@ class GridBlock {
     vtr::NdMatrix<t_grid_blocks, 3> grid_blocks_;
 };
 
-class BlkLocRegistry {
-  public:
-    BlkLocRegistry() = default;
-    ~BlkLocRegistry() = default;
-    BlkLocRegistry(const BlkLocRegistry&) = delete;
-    BlkLocRegistry& operator=(const BlkLocRegistry&) = default;
-    BlkLocRegistry(BlkLocRegistry&&) = delete;
-    BlkLocRegistry& operator=(BlkLocRegistry&&) = delete;
-
-  private:
-    ///@brief Clustered block placement locations
-    vtr::vector_map<ClusterBlockId, t_block_loc> block_locs_;
-
-    ///@brief Clustered block associated with each grid location (i.e. inverse of block_locs)
-    GridBlock grid_blocks_;
-
-    ///@brief Clustered pin placement mapping with physical pin
-    vtr::vector_map<ClusterPinId, int> physical_pins_;
-
-  public:
-    inline const vtr::vector_map<ClusterBlockId, t_block_loc>& block_locs() const { return block_locs_; }
-    inline vtr::vector_map<ClusterBlockId, t_block_loc>& mutable_block_locs() { return block_locs_; }
-
-    inline const GridBlock& grid_blocks() const { return grid_blocks_; }
-    inline GridBlock& mutable_grid_blocks() { return grid_blocks_; }
-
-    inline const vtr::vector_map<ClusterPinId, int>& physical_pins() const { return physical_pins_; }
-    inline vtr::vector_map<ClusterPinId, int>& mutable_physical_pins() { return physical_pins_; }
-
-    ///@brief Returns the physical pin of the tile, related to the given ClusterPinId
-    inline int tile_pin_index(const ClusterPinId pin) const { return physical_pins_[pin]; }
-
-     ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
-    int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
-};
 
 ///@brief Names of various files
 struct t_file_name_opts {

vpr/src/place/initial_noc_placement.cpp

@@ -1,5 +1,7 @@
 
 #include "initial_noc_placment.h"
+
+#include "vpr_types.h"
 #include "initial_placement.h"
 #include "noc_place_utils.h"
 #include "noc_place_checkpoint.h"

vpr/src/place/initial_noc_placment.h

@@ -1,8 +1,10 @@
 
-#ifndef VTR_INITIAL_NOC_PLACMENT_H
-#define VTR_INITIAL_NOC_PLACMENT_H
+#ifndef VTR_INITIAL_NOC_PLACEMENT_H
+#define VTR_INITIAL_NOC_PLACEMENT_H
 
-#include "vpr_types.h"
+struct t_noc_opts;
+struct t_placer_opts;
+class BlkLocRegistry;
 
 /**
  * @brief Randomly places NoC routers, then runs a quick simulated annealing
@@ -17,4 +19,4 @@ void initial_noc_placement(const t_noc_opts& noc_opts,
                            const t_placer_opts& placer_opts,
                            BlkLocRegistry& blk_loc_registry);
 
-#endif //VTR_INITIAL_NOC_PLACMENT_H
+#endif //VTR_INITIAL_NOC_PLACEMENT_H

vpr/src/place/move_transactions.h

@@ -1,8 +1,11 @@
 #ifndef VPR_MOVE_TRANSACTIONS_H
 #define VPR_MOVE_TRANSACTIONS_H
+
 #include "vpr_types.h"
 #include "clustered_netlist_utils.h"
 
+class BlkLocRegistry;
+
 enum class e_block_move_result {
     VALID,       //Move successful
     ABORT,       //Unable to perform move
@@ -30,7 +33,7 @@ struct t_pl_moved_block {
  * placement.                                                   *
  * Store the information on the blocks to be moved in a swap during     *
  * placement, in the form of array of structs instead of struct with    *
- * arrays for cache effifiency                                          *
+ * arrays for cache efficiency                                          *
  *
  * moved blocks: a list of moved blocks data structure with     *
  *               information on the move.                       *

vpr/src/place/move_utils.h

@@ -1,10 +1,12 @@
 #ifndef VPR_MOVE_UTILS_H
 #define VPR_MOVE_UTILS_H
+
 #include "vpr_types.h"
 #include "move_transactions.h"
 #include "compressed_grid.h"
 
 class PlacerState;
+class BlkLocRegistry;
 
 /* Cut off for incremental bounding box updates.                          *
  * 4 is fastest -- I checked.                                             */