Preloading clean

docs/source/manual/file_formats/unique_blocks.rst

@@ -0,0 +1,62 @@
+.. _file_formats_unique_blocks:
+
+Unique Blocks (.xml)
+~~~~~~~~~~~~~~~~~
+
+A unique blocks file is formatted in XML. The unique blocks can be of type ``cbx``, ``cby`` or ``sb``. As illustrated by the XML code below, the file includes the type and coordinates of these unique blocks, as well as the coordinates of their corresponding instances.
+
+Configurable Block
+^^^^^^^^^^^^^^^^^^^
+
+Unique blocks can be applied to various blocks, each of which can be of type ``cbx``, ``cby`` or ``sb``, and may have different coordinates.
+
+.. option:: <block type="<string>" x="<string>" y="<string>"/>   
+
+  For each block, a set of keys can be defined. For unique blocks, both keys and instances can be specified. However, if a unique block does not have an instance, only keys are permitted.
+
+  - ``type`` specifies the type of the unique block in the FPGA fabric. Valid values for ``type`` are ``cbx``, ``cby`` or ``sb``.
+
+  - ``x`` represents the x-coordinate of the unique block.
+
+  - ``y`` represents the y-coordinate of the unique block. 
+
+Configurable Instance
+^^^^^^^^^^^^^^^^^^^
+
+A specific unique block can have multiple instances, where each instance is a mirrored version of the unique block. Each instance shares the same type as its parent block and includes information about its coordinates.
+
+.. option:: <instance x="<string>" y="<string>"/>
+
+  - ``x`` specifies the x-coordinate of the instance. 
+
+  - ``y`` specifies the y-coordinate of the instance. 
+
+
+The following content provides an example of a unique block file:
+
+.. code-block:: xml
+
+  <unique_blocks>
+  	<block type="sb" x="0" y="0">
+  	</block>
+  	<block type="sb" x="0" y="1">
+  	</block>
+  	<block type="sb" x="1" y="0">
+  	</block>
+  	<block type="sb" x="1" y="1">
+  	</block>
+  	<block type="cbx" x="1" y="0">
+  		<instance x="0" y="0"/>
+  		<instance x="0" y="1"/>
+  	</block>
+  	<block type="cbx" x="1" y="1">
+  	</block>
+  	<block type="cby" x="0" y="1">
+  		<instance x="0" y="0"/>
+  		<instance x="1" y="0"/>
+  	</block>
+  	<block type="cby" x="1" y="1">
+  	</block>
+  </unique_blocks>
+
+

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 */