Merge pull request #3266 from verilog-to-routing/interposer_parsing

Interposer tag

Author: vaughnbetz

doc/src/api/libarchfpga/grid_types.rst

@@ -0,0 +1,14 @@
+========
+Grid Specification Types
+========
+
+These types are used to capture user's intended grid specification, i.e., which tiles go where in the device. These specifications will be later turned into a flattened device grid according to the device's size.
+
+.. doxygenstruct:: t_grid_loc_spec
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_grid_loc_def
+   :project: vpr
+   :members:
+   

doc/src/api/libarchfpga/index.rst

@@ -0,0 +1,12 @@
+.. _libarchfpga:
+
+LIBARCHFPGA
+=======
+
+.. toctree::
+   :maxdepth: 1
+
+   physical_types
+   grid_types
+   scatter_gather_types
+   interposer_types

doc/src/api/libarchfpga/interposer_types.rst

@@ -0,0 +1,13 @@
+========
+Interposer Types
+========
+
+These types are used to store information about interposer based architectures.
+
+.. doxygenstruct:: t_interposer_cut_inf
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_interdie_wire_inf
+   :project: vpr
+   :members:

doc/src/api/libarchfpga/physical_types.rst

@@ -0,0 +1,33 @@
+========
+Physical Types
+========
+
+These types are used to capture user's intended architecture specification.
+
+.. doxygenstruct:: t_arch
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_arch_switch_inf
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_segment_inf
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_physical_tile_loc
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_sub_tile
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_layer_def
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_grid_def
+   :project: vpr
+   :members:

doc/src/api/libarchfpga/scatter_gather_types.rst

@@ -0,0 +1,17 @@
+========
+Scatter-Gather Types
+========
+
+These types store information about about scatter-gather routing patterns
+
+.. doxygenstruct:: t_scatter_gather_pattern
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_sg_link
+   :project: vpr
+   :members:
+
+.. doxygenstruct:: t_sg_location
+   :project: vpr
+   :members:

doc/src/arch/reference.rst

@@ -581,6 +581,32 @@ Grid Layout Example
 
     Example FPGA grid
 
+
+.. arch:tag:: <interposer_cut dim=x|y loc="int"/>
+
+    :req_param dim: Dimension or axis of the cut. 'X' or 'x' means a horizontal cut while 'Y' or 'y' means a vertical cut.
+    :req_param loc: Location of the cut. Cuts are done above or to the right of the tiles at coordinate 'loc'. For example a cut with dim=x and loc=0 would cut the vertical wires above tiles in the 0th row. Currently only integer values are supported.
+
+    .. note:: Interposers are experimental and are currently not supported by VPR and using the related tags will not actually result in any changes to the flow.
+    Defines an interposer cut for modelling 2.5D interposer-based architectures. An interposer cut will cut all connections at location 'loc' along the axis 'dim' Leaving the two sides completely unconnected.
+    To reconnect the two sides, this tag can have multiple <interdie_wire> tags as children to specify the connection between the two sides.
+
+.. arch:tag:: <interdie_wire sg_name="string" sg_link="string" offset_start="expr" offset_end="expr" offset_increment="expr" num="int"/>
+
+    :req_param sg_name: Name of the scatter-gather pattern to be used for the interdie connection.
+    :req_param sg_link: Name of the scatter-gather link to be used for the interdie connection.
+    :req_param offset_start: Starting point of scatter-gather instantiations.
+    :req_param offset_end: Ending point of scatter-gather instantiations
+    :req_param offset_increment: Increment/distance between scatter-gather instantiations.
+    :req_param num: Number of scatter-gather instantiations per switchblock location.
+
+    Defines the interdie wiring between the two sides of the cut. Connectivity is defined using scatter-gather patterns. Starting at 'offset_start' from location of the cut and moving by 'offset_increment' until we reach the location of 'offset_end' away from the cut, 'num' scatter-gather patterns defined by 'sg_name' and 'sg_link' will be instantiated.
+    Note that these offset points always define the starting point of the scatter-gather pattern's sg_link. offset_start, offset_end and offset_increment can be integer values or expressions involving W and H (device width and height.)
+
+    .. figure:: scatter_gather_images/interposer_diagram.png
+        
+        An example of how specifying interposers in VTR works. Connections between the two sides of a cut are first severed after which the two sides are reconnected using scatter_gather patterns. In this example the length of the sg_link wire used is 3. Note that there are 'num' of each pattern at each switchblock location.
+
 .. _arch_device_info:
 
 FPGA Device Information

doc/src/arch/scatter_gather_images/interposer_diagram.png

@@ -64,6 +64,7 @@ For more specific documentation about VPR see :ref:`vpr`.
    api/vtrutil/index
    api/ezgl/index
    api/vprinternals/index
+   api/libarchfpga/index
 
 Indices and tables
 ==================

doc/src/index.rst

@@ -101,10 +101,10 @@ void PrintArchInfo(FILE* Echo, const t_arch* arch) {
     //Layout
     fprintf(Echo, "*************************************************\n");
     for (const auto& grid_layout : arch->grid_layouts) {
-        if (grid_layout.grid_type == GridDefType::AUTO) {
+        if (grid_layout.grid_type == e_grid_def_type::AUTO) {
             fprintf(Echo, "Layout: '%s' Type: auto Aspect_Ratio: %f\n", grid_layout.name.c_str(), grid_layout.aspect_ratio);
         } else {
-            VTR_ASSERT(grid_layout.grid_type == GridDefType::FIXED);
+            VTR_ASSERT(grid_layout.grid_type == e_grid_def_type::FIXED);
             fprintf(Echo, "Layout: '%s' Type: fixed Width: %d Height %d\n", grid_layout.name.c_str(), grid_layout.width, grid_layout.height);
         }
     }

libs/libarchfpga/src/echo_arch.cpp

@@ -0,0 +1,134 @@
+#pragma once
+
+/**
+ * @file grid_types.h
+ * @brief FPGA grid layout data types 
+ */
+
+#include <string>
+#include <memory>
+
+// Forward declerations
+
+struct t_metadata_dict;
+
+/**
+ * @brief Grid location specification
+ * Each member is a formula evaluated in terms of 'W' (device width),
+ * and 'H' (device height). Formulas can be evaluated using parse_formula()
+ * from expr_eval.h.
+ */
+struct t_grid_loc_spec {
+    std::string start_expr; ///<Starting position (inclusive)
+    std::string end_expr;   ///<Ending position (inclusive)
+
+    std::string repeat_expr; ///<Distance between repeated region instances
+
+    std::string incr_expr; ///<Distance between block instantiations with the region
+};
+
+/**
+ * @brief Definition of how to place physical logic block in the grid.
+ * @details This defines a region of the grid to be set to a specific type
+ * (provided its priority is high enough to override other blocks).
+ *
+ * The diagram below illustrates the layout specification.
+ *
+ *                      +----+                +----+           +----+
+ *                      |    |                |    |           |    |
+ *                      |    |                |    |    ...    |    |
+ *                      |    |                |    |           |    |
+ *                      +----+                +----+           +----+
+ *
+ *                        .                     .                 .
+ *                        .                     .                 .
+ *                        .                     .                 .
+ *
+ *                      +----+                +----+           +----+
+ *                      |    |                |    |           |    |
+ *                      |    |                |    |    ...    |    |
+ *                      |    |                |    |           |    |
+ *                      +----+                +----+           +----+
+ *                   ^
+ *                   |
+ *           repeaty |
+ *                   |
+ *                   v        (endx,endy)
+ *                      +----+                +----+           +----+
+ *                      |    |                |    |           |    |
+ *                      |    |                |    |    ...    |    |
+ *                      |    |                |    |           |    |
+ *                      +----+                +----+           +----+
+ *       (startx,starty)
+ *                            <-------------->
+ *                                 repeatx
+ *
+ * startx/endx and endx/endy define a rectangular region instance's dimensions.
+ * The region instance is then repeated every repeatx/repeaty (if specified).
+ *
+ * Within a particular region instance a block of block_type is laid down every
+ * incrx/incry units (if not specified defaults to block width/height):
+ *
+ *
+ *    * = an instance of block_type within the region
+ *
+ *                    +------------------------------+
+ *                    |*         *         *        *|
+ *                    |                              |
+ *                    |                              |
+ *                    |                              |
+ *                    |                              |
+ *                    |                              |
+ *                    |*         *         *        *|
+ *                ^   |                              |
+ *                |   |                              |
+ *          incry |   |                              |
+ *                |   |                              |
+ *                v   |                              |
+ *                    |*         *         *        *|
+ *                    +------------------------------+
+ *
+ *                      <------->
+ *                        incrx
+ *
+ * In the above diagram incrx = 10, and incry = 6
+ */
+struct t_grid_loc_def {
+    t_grid_loc_def(std::string block_type_val, int priority_val)
+        : block_type(std::move(block_type_val))
+        , priority(priority_val)
+        , x{"0", "W-1", "max(w+1,W)", "w"} // Fill in x direction, no repeat, incr by block width
+        , y{"0", "H-1", "max(h+1,H)", "h"} // Fill in y direction, no repeat, incr by block height
+    {}
+
+    std::string block_type; ///< The block type name
+
+    int priority = 0; ///< Priority of the specification. In case of conflicting specifications the largest priority wins.
+
+    t_grid_loc_spec x; ///< Horizontal location specification
+    t_grid_loc_spec y; ///< Vertical location specification
+
+    /**
+     * @brief When 1 metadata tag is split among multiple t_grid_loc_def, one
+     * t_grid_loc_def is arbitrarily chosen to own the metadata, and the other
+     * t_grid_loc_def point to the owned version.
+     * 
+     */
+    std::unique_ptr<t_metadata_dict> owned_meta;
+
+    /**
+     * @brief Metadata for this location definition. This
+     * metadata may be shared with multiple grid_locs
+     * that come from a common definition.
+     */
+    t_metadata_dict* meta = nullptr;
+};
+
+/**
+ * @brief Enum for specfying if the architecture grid specification is for an auto sized device (variable size)
+ * or a fixed size device.
+ */
+enum class e_grid_def_type {
+    AUTO,
+    FIXED
+};