Preloading clean

openfpga/src/annotation/device_rr_gsb.cpp

@@ -66,6 +66,9 @@ size_t DeviceRRGSB::get_num_cb_unique_module(const t_rr_type& cb_type) const {
   }
 }
 
+void DeviceRRGSB::init_is_dirty_flag() { is_dirty_ = false; }
+void DeviceRRGSB::set_is_dirty_flag(const bool flag) { is_dirty_ = flag; }
+bool DeviceRRGSB::get_is_dirty_flag() const { return is_dirty_; }
 /* Identify if a GSB actually exists at a location */
 bool DeviceRRGSB::is_gsb_exist(const RRGraphView& rr_graph,
                                const vtr::Point<size_t> coord) const {
@@ -171,6 +174,18 @@ void DeviceRRGSB::reserve(const vtr::Point<size_t>& coordinate) {
     cby_unique_module_id_[x].resize(coordinate.y());
   }
 }
+void DeviceRRGSB::reserve_unique_modules(const vtr::Point<size_t>& coordinate) {
+  sb_unique_module_id_.resize(coordinate.x());
+  cbx_unique_module_id_.resize(coordinate.x());
+  cby_unique_module_id_.resize(coordinate.x());
+
+  for (size_t x = 0; x < coordinate.x(); ++x) {
+    sb_unique_module_id_[x].resize(coordinate.y());
+
+    cbx_unique_module_id_[x].resize(coordinate.y());
+    cby_unique_module_id_[x].resize(coordinate.y());
+  }
+}
 
 /* Resize rr_switch_block array is needed*/
 void DeviceRRGSB::resize_upon_need(const vtr::Point<size_t>& coordinate) {
@@ -348,6 +363,7 @@ void DeviceRRGSB::build_unique_module(const RRGraphView& rr_graph) {
   build_cb_unique_module(rr_graph, CHANY);
 
   build_gsb_unique_module();
+  set_is_dirty_flag(true);
 }
 
 void DeviceRRGSB::add_gsb_unique_module(const vtr::Point<size_t>& coordinate) {
@@ -408,6 +424,20 @@ void DeviceRRGSB::clear() {
 
   clear_sb_unique_module();
   clear_sb_unique_module_id();
+  init_is_dirty_flag();
+}
+
+void DeviceRRGSB::clear_unique_modules() {
+  /* clean unique module lists */
+  clear_cb_unique_module(CHANX);
+  clear_cb_unique_module_id(CHANX);
+
+  clear_cb_unique_module(CHANY);
+  clear_cb_unique_module_id(CHANY);
+
+  clear_sb_unique_module();
+  clear_sb_unique_module_id();
+  init_is_dirty_flag();
 }
 
 void DeviceRRGSB::clear_gsb() {
@@ -551,4 +581,148 @@ size_t DeviceRRGSB::get_cb_unique_module_index(
   return cb_unique_module_id;
 }
 
+void DeviceRRGSB::preload_unique_cbx_module(
+  const vtr::Point<size_t>& block_coordinate,
+  const std::vector<vtr::Point<size_t>>& instance_coords) {
+  /*check whether the preloaded value exceeds the limit */
+  size_t limit_x = cbx_unique_module_id_.size();
+  size_t limit_y = cbx_unique_module_id_[0].size();
+  VTR_ASSERT(block_coordinate.x() < limit_x);
+  VTR_ASSERT(block_coordinate.y() < limit_y);
+  add_cb_unique_module(CHANX, block_coordinate);
+  /* preload the unique block */
+  set_cb_unique_module_id(CHANX, block_coordinate,
+                          get_num_cb_unique_module(CHANX) - 1);
+
+  /* preload the instances of the unique block. Instance will have the same id
+   * as the unique block */
+  for (auto instance_location : instance_coords) {
+    VTR_ASSERT(instance_location.x() < limit_x);
+    VTR_ASSERT(instance_location.y() < limit_y);
+    set_cb_unique_module_id(
+      CHANX, instance_location,
+      cbx_unique_module_id_[block_coordinate.x()][block_coordinate.y()]);
+  }
+}
+
+void DeviceRRGSB::preload_unique_cby_module(
+  const vtr::Point<size_t>& block_coordinate,
+  const std::vector<vtr::Point<size_t>>& instance_coords) {
+  /*check whether the preloaded value exceeds the limit */
+  size_t limit_x = cby_unique_module_id_.size();
+  size_t limit_y = cby_unique_module_id_[0].size();
+
+  VTR_ASSERT(block_coordinate.x() < limit_x);
+  VTR_ASSERT(block_coordinate.y() < limit_y);
+  add_cb_unique_module(CHANY, block_coordinate);
+  /* preload the unique block */
+  set_cb_unique_module_id(CHANY, block_coordinate,
+                          get_num_cb_unique_module(CHANY) - 1);
+
+  /* preload the instances of the unique block. Instance will have the same id
+   * as the unique block */
+  for (auto instance_location : instance_coords) {
+    VTR_ASSERT(instance_location.x() < limit_x);
+    VTR_ASSERT(instance_location.y() < limit_y);
+    set_cb_unique_module_id(
+      CHANY, instance_location,
+      cby_unique_module_id_[block_coordinate.x()][block_coordinate.y()]);
+  }
+}
+
+void DeviceRRGSB::preload_unique_sb_module(
+  const vtr::Point<size_t>& block_coordinate,
+  const std::vector<vtr::Point<size_t>>& instance_coords) {
+  /*check whether the preloaded value exceeds the limit */
+  VTR_ASSERT(block_coordinate.x() < sb_unique_module_id_.size());
+  VTR_ASSERT(block_coordinate.y() < sb_unique_module_id_[0].size());
+  sb_unique_module_.push_back(block_coordinate);
+  /* Record the id of unique module */
+  sb_unique_module_id_[block_coordinate.x()][block_coordinate.y()] =
+    sb_unique_module_.size() - 1;
+
+  /* each mirror instance of the unique module will have the same module id as
+   * the unique module */
+  for (auto instance_location : instance_coords) {
+    VTR_ASSERT(instance_location.x() < sb_unique_module_id_.size());
+    VTR_ASSERT(instance_location.y() < sb_unique_module_id_[0].size());
+    sb_unique_module_id_[instance_location.x()][instance_location.y()] =
+      sb_unique_module_id_[block_coordinate.x()][block_coordinate.y()];
+  }
+}
+
+/*The following four functions will allow us to get
+The map between (id,mirror instance coord), (id, unique block coord)
+As the unique block and its mirror instances share the same id, we can get the
+map between (unique block coord, mirror instance coord)
+*/
+void DeviceRRGSB::get_id_unique_sb_block_map(
+  std::map<int, vtr::Point<size_t>>& id_unique_block_map) const {
+  for (size_t id = 0; id < get_num_sb_unique_module(); ++id) {
+    const auto& unique_block_coord = sb_unique_module_[id];
+    auto unique_module_id =
+      sb_unique_module_id_[unique_block_coord.x()][unique_block_coord.y()];
+    id_unique_block_map[unique_module_id] = unique_block_coord;
+  }
+}
+
+void DeviceRRGSB::get_id_sb_instance_map(
+  std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const {
+  for (size_t location_x = 0; location_x < sb_unique_module_id_.size();
+       ++location_x) {
+    for (size_t location_y = 0; location_y < sb_unique_module_id_[0].size();
+         ++location_y) {
+      auto unique_module_id = sb_unique_module_id_[location_x][location_y];
+      vtr::Point<size_t> instance_coord(location_x, location_y);
+      id_instance_map[unique_module_id].push_back(instance_coord);
+    }
+  }
+}
+
+void DeviceRRGSB::get_id_unique_cbx_block_map(
+  std::map<int, vtr::Point<size_t>>& id_unique_block_map) const {
+  for (size_t id = 0; id < get_num_cb_unique_module(CHANX); ++id) {
+    const auto& unique_block_coord = cbx_unique_module_[id];
+    auto unique_module_id =
+      cbx_unique_module_id_[unique_block_coord.x()][unique_block_coord.y()];
+    id_unique_block_map[unique_module_id] = unique_block_coord;
+  }
+}
+
+void DeviceRRGSB::get_id_cbx_instance_map(
+  std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const {
+  for (size_t location_x = 0; location_x < cbx_unique_module_id_.size();
+       ++location_x) {
+    for (size_t location_y = 0; location_y < cbx_unique_module_id_[0].size();
+         ++location_y) {
+      auto unique_module_id = cbx_unique_module_id_[location_x][location_y];
+      vtr::Point<size_t> instance_coord(location_x, location_y);
+      id_instance_map[unique_module_id].push_back(instance_coord);
+    }
+  }
+}
+
+void DeviceRRGSB::get_id_unique_cby_block_map(
+  std::map<int, vtr::Point<size_t>>& id_unique_block_map) const {
+  for (size_t id = 0; id < get_num_cb_unique_module(CHANY); ++id) {
+    const auto& unique_block_coord = cby_unique_module_[id];
+    auto unique_module_id =
+      cby_unique_module_id_[unique_block_coord.x()][unique_block_coord.y()];
+    id_unique_block_map[unique_module_id] = unique_block_coord;
+  }
+}
+
+void DeviceRRGSB::get_id_cby_instance_map(
+  std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const {
+  for (size_t location_x = 0; location_x < cby_unique_module_id_.size();
+       ++location_x) {
+    for (size_t location_y = 0; location_y < cby_unique_module_id_[0].size();
+         ++location_y) {
+      auto unique_module_id = cby_unique_module_id_[location_x][location_y];
+      vtr::Point<size_t> instance_coord(location_x, location_y);
+      id_instance_map[unique_module_id].push_back(instance_coord);
+    }
+  }
+}
+
 } /* End namespace openfpga*/

openfpga/src/annotation/device_rr_gsb.h

@@ -69,10 +69,15 @@ class DeviceRRGSB {
                                     const vtr::Point<size_t>& coordinate) const;
 
  public: /* Mutators */
+  void set_is_dirty_flag(const bool flag);
+  bool get_is_dirty_flag() const;
+  void build_gsb_unique_module(); /* Add a switch block to the array, which will
+                                     automatically identify and update the lists
+                                     of unique mirrors and rotatable mirrors */
   void reserve(
     const vtr::Point<size_t>& coordinate); /* Pre-allocate the rr_switch_block
                                               array that the device requires */
-  void reserve_sb_unique_submodule_id(
+  void reserve_unique_modules(
     const vtr::Point<size_t>&
       coordinate); /* Pre-allocate the rr_sb_unique_module_id matrix that the
                       device requires */
@@ -95,9 +100,33 @@ class DeviceRRGSB {
                                      automatically identify and update the lists
                                      of unique mirrors and rotatable mirrors */
   void clear();                   /* clean the content */
- private:                         /* Internal cleaners */
-  void clear_gsb();               /* clean the content */
+  void preload_unique_cbx_module(
+    const vtr::Point<size_t>& block_coordinate,
+    const std::vector<vtr::Point<size_t>>& instance_coords);
+  void preload_unique_cby_module(
+    const vtr::Point<size_t>& block_coordinate,
+    const std::vector<vtr::Point<size_t>>& instance_coords);
+  void preload_unique_sb_module(
+    const vtr::Point<size_t>& block_coordinate,
+    const std::vector<vtr::Point<size_t>>& instance_coords);
+  void clear_unique_modules();
+  void get_id_sb_instance_map(
+    std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const;
+  void get_id_unique_sb_block_map(
+    std::map<int, vtr::Point<size_t>>& id_unique_block_map) const;
+  void get_id_cbx_instance_map(
+    std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const;
+  void get_id_unique_cbx_block_map(
+    std::map<int, vtr::Point<size_t>>& id_unique_block_map) const;
+  void get_id_cby_instance_map(
+    std::map<int, std::vector<vtr::Point<size_t>>>& id_instance_map) const;
+  void get_id_unique_cby_block_map(
+    std::map<int, vtr::Point<size_t>>& id_unique_block_map) const;
+
+ private:                                                /* Internal cleaners */
+  void clear_gsb();                                      /* clean the content */
   void clear_cb_unique_module(const t_rr_type& cb_type); /* clean the content */
+  void init_is_dirty_flag();
   void clear_cb_unique_module_id(
     const t_rr_type& cb_type);       /* clean the content */
   void clear_sb_unique_module();     /* clean the content */
@@ -133,11 +162,10 @@ class DeviceRRGSB {
     const t_rr_type&
       cb_type); /* Add a switch block to the array, which will automatically
                    identify and update the lists of unique side module */
-  void build_gsb_unique_module(); /* Add a switch block to the array, which will
-                                     automatically identify and update the lists
-                                     of unique mirrors and rotatable mirrors */
- private:                         /* Internal Data */
+
+ private: /* Internal Data */
   std::vector<std::vector<RRGSB>> rr_gsb_;
+  bool is_dirty_ = false;  // is_valid
 
   std::vector<std::vector<size_t>>
     gsb_unique_module_id_; /* A map from rr_gsb to its unique mirror */