Merge pull request #2259 from verilog-to-routing/modeling_multi_die_stack

Modeling multi die stack

Author: vaughnbetz

libs/libarchfpga/src/device_grid.cpp

@@ -1,23 +1,43 @@
 #include "device_grid.h"
 
-DeviceGrid::DeviceGrid(std::string grid_name, vtr::Matrix<t_grid_tile> grid)
+DeviceGrid::DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid)
     : name_(grid_name)
     , grid_(grid) {
     count_instances();
 }
 
-DeviceGrid::DeviceGrid(std::string grid_name, vtr::Matrix<t_grid_tile> grid, std::vector<t_logical_block_type_ptr> limiting_res)
+DeviceGrid::DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid, std::vector<t_logical_block_type_ptr> limiting_res)
     : DeviceGrid(grid_name, grid) {
     limiting_resources_ = limiting_res;
 }
 
-size_t DeviceGrid::num_instances(t_physical_tile_type_ptr type) const {
-    auto iter = instance_counts_.find(type);
-    if (iter != instance_counts_.end()) {
-        //Return count
-        return iter->second;
+size_t DeviceGrid::num_instances(t_physical_tile_type_ptr type, int layer_num) const {
+    size_t count = 0;
+    //instance_counts_ is not initialized
+    if (instance_counts_.empty()) {
+        return 0;
     }
-    return 0; //None found
+
+    int num_layers = (int)grid_.dim_size(0);
+
+    if (layer_num == -1) {
+        //Count all layers
+        for (int curr_layer_num = 0; curr_layer_num < num_layers; ++curr_layer_num) {
+            auto iter = instance_counts_[curr_layer_num].find(type);
+            if (iter != instance_counts_[curr_layer_num].end()) {
+                count += iter->second;
+            }
+        }
+        return count;
+    } else {
+        auto iter = instance_counts_[layer_num].find(type);
+        if (iter != instance_counts_[layer_num].end()) {
+            //Return count
+            count = iter->second;
+        }
+    }
+
+    return count;
 }
 
 void DeviceGrid::clear() {
@@ -26,16 +46,34 @@ void DeviceGrid::clear() {
 }
 
 void DeviceGrid::count_instances() {
+    int num_layers = (int)grid_.dim_size(0);
     instance_counts_.clear();
+    instance_counts_.resize(num_layers);
+
+    //Initialize the instance counts
+    for (int layer_num = 0; layer_num < num_layers; ++layer_num) {
+        for (size_t x = 0; x < width(); ++x) {
+            for (size_t y = 0; y < height(); ++y) {
+                auto type = grid_[layer_num][x][y].type;
+
+                if (grid_[layer_num][x][y].width_offset == 0 && grid_[layer_num][x][y].height_offset == 0) {
+                    //Add capacity only if this is the root location
+                    instance_counts_[layer_num][type] = 0;
+                }
+            }
+        }
+    }
 
     //Count the number of blocks in the grid
-    for (size_t x = 0; x < width(); ++x) {
-        for (size_t y = 0; y < height(); ++y) {
-            auto type = grid_[x][y].type;
+    for (int layer_num = 0; layer_num < num_layers; ++layer_num) {
+        for (size_t x = 0; x < width(); ++x) {
+            for (size_t y = 0; y < height(); ++y) {
+                auto type = grid_[layer_num][x][y].type;
 
-            if (grid_[x][y].width_offset == 0 && grid_[x][y].height_offset == 0) {
-                //Add capacity only if this is the root location
-                instance_counts_[type] += type->capacity;
+                if (grid_[layer_num][x][y].width_offset == 0 && grid_[layer_num][x][y].height_offset == 0) {
+                    //Add capacity only if this is the root location
+                    instance_counts_[layer_num][type] += type->capacity;
+                }
             }
         }
     }

libs/libarchfpga/src/device_grid.h

@@ -3,57 +3,119 @@
 
 #include <string>
 #include <vector>
+#include <cmath>
 #include "vtr_ndmatrix.h"
 #include "physical_types.h"
 
-///@brief s_grid_tile is the minimum tile of the fpga
+/**
+ * @brief s_grid_tile is the minimum tile of the fpga
+ * @note This struct shouldn't be directly accessed by other functions. Use the helper functions in DeviceGrid instead.
+ */
 struct t_grid_tile {
     t_physical_tile_type_ptr type = nullptr; ///<Pointer to type descriptor, NULL for illegal
     int width_offset = 0;                    ///<Number of grid tiles reserved based on width (right) of a block
     int height_offset = 0;                   ///<Number of grid tiles reserved based on height (top) of a block
     const t_metadata_dict* meta = nullptr;
 };
 
+///@brief DeviceGrid represents the FPGA fabric. It is used to get information about different layers and tiles.
+// TODO: All of the function that use helper functions of this class should pass the layer_num to the functions, and the default value of layer_num should be deleted eventually.
 class DeviceGrid {
   public:
     DeviceGrid() = default;
-    DeviceGrid(std::string grid_name, vtr::Matrix<t_grid_tile> grid);
-    DeviceGrid(std::string grid_name, vtr::Matrix<t_grid_tile> grid, std::vector<t_logical_block_type_ptr> limiting_res);
+    DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid);
+    DeviceGrid(std::string grid_name, vtr::NdMatrix<t_grid_tile, 3> grid, std::vector<t_logical_block_type_ptr> limiting_res);
 
     const std::string& name() const { return name_; }
 
-    size_t width() const { return grid_.dim_size(0); }
-    size_t height() const { return grid_.dim_size(1); }
+    ///@brief Return the number of layers(number of dies)
+    inline int get_num_layers() const {
+        return (int)grid_.dim_size(0);
+    }
 
-    //Note: supports 2-d indexing [0..width()-1][0..height()-1] yielding a t_grid_tile
-    auto operator[](size_t index) const { return grid_[index]; }
-    auto operator[](size_t index) { return grid_[index]; }
+    ///@brief Return the width of the grid at the specified layer
+    size_t width() const { return grid_.dim_size(1); }
+    ///@brief Return the height of the grid at the specified layer
+    size_t height() const { return grid_.dim_size(2); }
 
-    const vtr::Matrix<t_grid_tile>& matrix() const {
-        return grid_;
+    ///@brief Return the size of the flattened grid on the given layer
+    inline size_t grid_size() const {
+        return grid_.size();
     }
 
+    ///@brief deallocate members of DeviceGrid
     void clear();
 
-    size_t num_instances(t_physical_tile_type_ptr type) const;
+    /**
+     * @brief Return the number of instances of the specified tile type on the specified layer. If the layer_num is -1, return the total number of instances of the specified tile type on all layers.
+     * @note This function should be used if count_instances() is called in the constructor.
+     */
+    size_t num_instances(t_physical_tile_type_ptr type, int layer_num = 0) const;
 
     /**
      * @brief Returns the block types which limits the device size (may be empty if
      *        resource limits were not considered when selecting the device).
      */
     std::vector<t_logical_block_type_ptr> limiting_resources() const { return limiting_resources_; }
 
+    ///@brief Return the t_physical_tile_type_ptr at the specified location
+    inline t_physical_tile_type_ptr get_physical_type(size_t x, size_t y, int layer_num = 0) const {
+        return grid_[layer_num][x][y].type;
+    }
+
+    ///@brief Return the width offset of the tile at the specified location. The root location of the tile is where width_offset and height_offset are 0.
+    inline int get_width_offset(size_t x, size_t y, int layer_num = 0) const {
+        return grid_[layer_num][x][y].width_offset;
+    }
+
+    ///@brief Return the height offset of the tile at the specified location. The root location of the tile is where width_offset and height_offset are 0
+    inline int get_height_offset(size_t x, size_t y, int layer_num = 0) const {
+        return grid_[layer_num][x][y].height_offset;
+    }
+
+    ///@brief Return the metadata of the tile at the specified location
+    inline const t_metadata_dict* get_metadata(size_t x, size_t y, int layer_num = 0) const {
+        return grid_[layer_num][x][y].meta;
+    }
+
+    ///@brief Given t_grid_tile, return the x coordinate of the tile on the given layer - Used by serializer functions
+    inline int get_grid_loc_x(const t_grid_tile*& grid_loc) const {
+        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
+        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
+
+        return diff / grid_.dim_size(2);
+    }
+
+    ///@brief Given t_grid_tile, return the y coordinate of the tile on the given layer - Used by serializer functions
+    inline int get_grid_loc_y(const t_grid_tile*& grid_loc) const {
+        int layer_num = std::floor(static_cast<int>(grid_loc - &grid_.get(0)) / (width() * height()));
+        auto diff = grid_loc - &grid_.get(layer_num * height() * width());
+
+        return diff % grid_.dim_size(2);
+    }
+
+    ///@brief Return the nth t_grid_tile on the given layer of the flattened grid - Used by serializer functions
+    inline const t_grid_tile* get_grid_locs_grid_loc(int n) const {
+        return &grid_.get(n);
+    }
+
   private:
+    ///@brief count_instances() counts the number of each tile type on each layer and store it in instance_counts_. It is called in the constructor.
     void count_instances();
 
     std::string name_;
 
-    //Note that vtr::Matrix operator[] returns and intermediate type
-    //which can be used or indexing in the second dimension, allowing
-    //traditional 2-d indexing to be used
-    vtr::Matrix<t_grid_tile> grid_;
+    /**
+     * @brief grid_ is a 3D matrix that represents the grid of the FPGA chip.
+     * @note The first dimension is the layer number (grid_[0] corresponds to the bottom layer), the second dimension is the x coordinate, and the third dimension is the y coordinate.
+     * @note Note that vtr::Matrix operator[] returns and intermediate type
+     * @note which can be used for indexing in the second dimension, allowing
+     * @note traditional 2-d indexing to be used
+     */
+    vtr::NdMatrix<t_grid_tile, 3> grid_; //This stores the grid of complex blocks. It is a a 3D matrix: [0..num_layers-1][0..grid.width()-1][0..grid_height()-1]
 
-    std::map<t_physical_tile_type_ptr, size_t> instance_counts_;
+    ///@brief instance_counts_ stores the number of each tile type on each layer. It is initialized in count_instances().
+    std::vector<std::map<t_physical_tile_type_ptr, size_t>> instance_counts_; /* [layer_num][physical_tile_type_ptr] */
 
     std::vector<t_logical_block_type_ptr> limiting_resources_;
 };

libs/libarchfpga/src/physical_types.h

@@ -374,6 +374,10 @@ enum GridDefType {
     FIXED
 };
 
+struct t_layer_def {
+    std::vector<t_grid_loc_def> loc_defs; //The list of block location definitions for this layer specification
+};
+
 struct t_grid_def {
     GridDefType grid_type = GridDefType::AUTO; //The type of this grid specification
 
@@ -384,8 +388,7 @@ struct t_grid_def {
 
     float aspect_ratio = 1.; //Aspect ratio for auto-sized devices (only valid for
                              //grid_type == AUTO)
-
-    std::vector<t_grid_loc_def> loc_defs; //The list of grid location definitions for this grid specification
+    std::vector<t_layer_def> layers;
 };
 
 /************************* POWER ***********************************/

libs/libarchfpga/src/read_fpga_interchange_arch.cpp

@@ -2243,6 +2243,8 @@ struct ArchReader {
 
         for (auto name : packages) {
             t_grid_def grid_def;
+            int num_layers = 1;
+            grid_def.layers.resize(num_layers);
             grid_def.width = grid_def.height = 0;
             for (auto tile : tiles) {
                 grid_def.width = std::max(grid_def.width, tile.getCol() + 1);
@@ -2293,7 +2295,7 @@ struct ArchReader {
 
                 single.owned_meta = std::make_unique<t_metadata_dict>(data);
                 single.meta = single.owned_meta.get();
-                grid_def.loc_defs.emplace_back(std::move(single));
+                grid_def.layers.at(num_layers - 1).loc_defs.emplace_back(std::move(single));
             }
 
             // The constant source tile will be placed at (0, 0)
@@ -2304,7 +2306,7 @@ struct ArchReader {
             constant.x.end_expr = constant.x.start_expr + " + w - 1";
             constant.y.end_expr = constant.y.start_expr + " + h - 1";
 
-            grid_def.loc_defs.emplace_back(std::move(constant));
+            grid_def.layers.at(num_layers - 1).loc_defs.emplace_back(std::move(constant));
 
             arch_->grid_layouts.emplace_back(std::move(grid_def));
         }