Add comments and rename GridDefType

Author: AmirhosseinPoolad

libs/libarchfpga/src/echo_arch.cpp

@@ -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/grid_types.h

@@ -13,26 +13,21 @@
 struct t_metadata_dict;
 
 /**
- * @brief Grid location specification
+ * @brief Grid location specification, used to capture user's intended architecture specification.
+ * will be later turned into a flattened device grid according to the device's size.
  * 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 start_expr; ///<Starting position (inclusive)
+    std::string end_expr;   ///<Ending position (inclusive)
 
-    std::string repeat_expr; //Distance between repeated
-                             // region instances
+    std::string repeat_expr; ///<Distance between repeated region instances
 
-    std::string incr_expr; //Distance between block instantiations
-                           // with the region
+    std::string incr_expr; ///<Distance between block instantiations with the region
 };
 
-/* Definition of how to place physical logic block in the grid.
-
- */
-
 /**
  * @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
@@ -69,7 +64,7 @@ struct t_grid_loc_spec {
  *                            <-------------->
  *                                 repeatx
  *
- * startx/endx and endx/endy define a rectangular region instances dimensions.
+ * 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
@@ -103,29 +98,38 @@ 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
+        , 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
+    std::string block_type; ///< The block type name
 
-    int priority = 0; //Priority of the specification.
-                      // In case of conflicting specifications
-                      // the largest priority wins.
+    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
+    t_grid_loc_spec x; ///< Horizontal location specification
+    t_grid_loc_spec y; ///< Vertical location specification
 
-    // 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.
+    /**
+     * @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;
-    t_metadata_dict* meta = nullptr; // Metadata for this location definition. This
-                                     // metadata may be shared with multiple grid_locs
-                                     // that come from a common definition.
+
+    /**
+     * @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;
 };
 
-enum class GridDefType {
+/**
+ * @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
 };

libs/libarchfpga/src/physical_types.h

@@ -257,7 +257,7 @@ struct t_layer_def {
 };
 
 struct t_grid_def {
-    GridDefType grid_type = GridDefType::AUTO; //The type of this grid specification
+    e_grid_def_type grid_type = e_grid_def_type::AUTO; //The type of this grid specification
 
     std::string name = ""; //The name of this device
 

libs/libarchfpga/src/read_fpga_interchange_arch.cpp

@@ -2244,7 +2244,7 @@ struct ArchReader {
             grid_def.width += 2;
             grid_def.height += 2;
 
-            grid_def.grid_type = GridDefType::FIXED;
+            grid_def.grid_type = e_grid_def_type::FIXED;
 
             if (name == "auto") {
                 // At the moment, the interchange specifies fixed-layout only architectures,

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -2585,15 +2585,15 @@ static t_grid_def process_grid_layout(vtr::string_internment& strings,
     if (layout_type_tag.name() == std::string("auto_layout")) {
         expect_only_attributes(layout_type_tag, {"aspect_ratio"}, loc_data);
 
-        grid_def.grid_type = GridDefType::AUTO;
+        grid_def.grid_type = e_grid_def_type::AUTO;
 
         grid_def.aspect_ratio = get_attribute(layout_type_tag, "aspect_ratio", loc_data, ReqOpt::OPTIONAL).as_float(1.);
         grid_def.name = "auto";
 
     } else if (layout_type_tag.name() == std::string("fixed_layout")) {
         expect_only_attributes(layout_type_tag, {"width", "height", "name"}, loc_data);
 
-        grid_def.grid_type = GridDefType::FIXED;
+        grid_def.grid_type = e_grid_def_type::FIXED;
         grid_def.width = get_attribute(layout_type_tag, "width", loc_data).as_int();
         grid_def.height = get_attribute(layout_type_tag, "height", loc_data).as_int();
         std::string name = get_attribute(layout_type_tag, "name", loc_data).value();
@@ -2654,7 +2654,7 @@ static void process_block_type_locs(t_grid_def& grid_def,
         // tags do not have. For this reason we check if loc_spec_tag is an interposer tag
         // and switch code paths if it is.
         if (loc_type == std::string("interposer_cut")) {
-            if (grid_def.grid_type == GridDefType::AUTO) {
+            if (grid_def.grid_type == e_grid_def_type::AUTO) {
                 archfpga_throw(loc_data.filename_c_str(), loc_data.line(loc_spec_tag), "Interposers are not currently supported for auto sized devices.");
             }
 

vpr/src/base/setup_grid.cpp

@@ -84,7 +84,7 @@ DeviceGrid create_device_grid(const std::string& layout_name, const std::vector<
     if (layout_name == "auto") {
         VTR_ASSERT(!grid_layouts.empty());
         //Auto-size
-        if (grid_layouts[0].grid_type == GridDefType::AUTO) {
+        if (grid_layouts[0].grid_type == e_grid_def_type::AUTO) {
             //Auto layout of the specified dimensions
             return build_device_grid(grid_layouts[0], width, height);
         } else {
@@ -152,7 +152,7 @@ static DeviceGrid auto_size_device_grid(const std::vector<t_grid_def>& grid_layo
     DeviceGrid grid;
 
     auto is_auto_grid_def = [](const t_grid_def& grid_def) {
-        return grid_def.grid_type == GridDefType::AUTO;
+        return grid_def.grid_type == e_grid_def_type::AUTO;
     };
 
     auto auto_layout_itr = std::find_if(grid_layouts.begin(), grid_layouts.end(), is_auto_grid_def);
@@ -230,8 +230,8 @@ static DeviceGrid auto_size_device_grid(const std::vector<t_grid_def>& grid_layo
             grid_layouts_view.push_back(&layout);
         }
         auto area_cmp = [](const t_grid_def* lhs, const t_grid_def* rhs) {
-            VTR_ASSERT(lhs->grid_type == GridDefType::FIXED);
-            VTR_ASSERT(rhs->grid_type == GridDefType::FIXED);
+            VTR_ASSERT(lhs->grid_type == e_grid_def_type::FIXED);
+            VTR_ASSERT(rhs->grid_type == e_grid_def_type::FIXED);
 
             int lhs_area = lhs->width * lhs->height;
             int rhs_area = rhs->width * rhs->height;
@@ -339,7 +339,7 @@ static bool grid_satisfies_instance_counts(const DeviceGrid& grid, const std::ma
 
 ///@brief Build the specified device grid
 static DeviceGrid build_device_grid(const t_grid_def& grid_def, size_t grid_width, size_t grid_height, bool warn_out_of_range, const std::vector<t_logical_block_type_ptr>& limiting_resources) {
-    if (grid_def.grid_type == GridDefType::FIXED) {
+    if (grid_def.grid_type == e_grid_def_type::FIXED) {
         if (grid_def.width != int(grid_width) || grid_def.height != int(grid_height)) {
             VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                             "Requested grid size (%zu%zu) does not match fixed device size (%dx%d)",

vpr/test/test_interchange_device.cpp

@@ -51,7 +51,7 @@ TEST_CASE("read_interchange_layout", "[vpr]") {
     FPGAInterchangeReadArch(kArchFile, /*timing_enabled=*/true, &arch, physical_tile_types, logical_block_types);
 
     auto& gd = arch.grid_layouts[0];
-    REQUIRE(gd.grid_type == GridDefType::FIXED);
+    REQUIRE(gd.grid_type == e_grid_def_type::FIXED);
     REQUIRE(gd.height == 12);
     REQUIRE(gd.width == 12);