Merge branch 'master' of https://github.com/verilog-to-routing/vtr-verilog-to-routing into update_wire_cost_map

Author: amin1377

.github/workflows/test.yml

@@ -141,6 +141,11 @@ jobs:
             params: '-DCMAKE_COMPILE_WARNING_AS_ERROR=on -DVTR_ASSERT_LEVEL=3 -DWITH_BLIFEXPLORER=on',
             suite: 'vtr_reg_basic'
           },
+          {
+            name: 'Basic with highest assertion level',
+            params: '-DCMAKE_COMPILE_WARNING_AS_ERROR=on -DVTR_ASSERT_LEVEL=4 -DWITH_BLIFEXPLORER=on',
+            suite: 'vtr_reg_basic'
+          },
           {
             name: 'Basic_odin',
             params: '-DCMAKE_COMPILE_WARNING_AS_ERROR=on -DVTR_ASSERT_LEVEL=3 -DWITH_BLIFEXPLORER=on -DWITH_PARMYS=OFF -DWITH_ODIN=on',

.gitignore

@@ -144,6 +144,7 @@ tags
 #
 .vscode
 .history
+.cache
 #eclipse project
 .project
 
@@ -153,4 +154,4 @@ tags
 .idea
 cmake-build-debug
 cmake-build-release
-/.metadata/
+/.metadata/

doc/src/vpr/command_line_usage.rst

@@ -979,15 +979,16 @@ The following options are only valid when the placement engine is in timing-driv
 
     **Default:** ``8.0``
 
-.. option:: --place_delay_model {delta, delta_override}
+.. option:: --place_delay_model {simple, delta, delta_override}
 
     Controls how the timing-driven placer estimates delays.
 
-     * ``delta`` The router is used to profile delay from various locations in the grid for various differences in position
+     * ``simple`` The placement delay estimator is built from the router lookahead. This takes less CPU time to build and it and still as accurate as the ``delta` model.
+     * ``delta`` The router is used to profile delay from various locations in the grid for various differences in position.
      * ``delta_override`` Like ``delta`` but also includes special overrides to ensure effects of direct connects between blocks are accounted for.
        This is potentially more accurate but is more complex and depending on the architecture (e.g. number of direct connects) may increase place run-time.
 
-    **Default:** ``delta``
+    **Default:** ``simple``
 
 .. option:: --place_delay_model_reducer {min, max, median, arithmean, geomean}
 
@@ -1292,6 +1293,13 @@ VPR uses a negotiated congestion algorithm (based on Pathfinder) to perform rout
     * `swns` - setup Worst Negative Slack (sWNS) [ns]
     * `stns` - Setup Total Negative Slack (sTNS) [ns]
 
+.. option:: --route_verbosity <int>
+
+    Controls the verbosity of routing output.
+    High values produce more detailed output, which can be useful for debugging or understanding the routing process.
+
+    **Default**: ``1``
+
 .. _timing_driven_router_options:
 
 Timing-Driven Router Options

libs/libarchfpga/src/parse_switchblocks.cpp

@@ -65,6 +65,9 @@ static void parse_comma_separated_wire_points(const char* ch, std::vector<t_wire
 /* Parses the number of connections type */
 static void parse_num_conns(std::string num_conns, t_wireconn_inf& wireconn);
 
+/* Set connection from_side and to_side for custom switch block pattern*/
+static void set_switch_func_type(SB_Side_Connection& conn, const char* func_type);
+
 /* parse switch_override in wireconn */
 static void parse_switch_override(const char* switch_override, t_wireconn_inf& wireconn, const t_arch_switch_inf* switches, int num_switches);
 
@@ -269,6 +272,70 @@ static void parse_num_conns(std::string num_conns, t_wireconn_inf& wireconn) {
     wireconn.num_conns_formula = num_conns;
 }
 
+//set sides for a specific conn for custom switch block pattern
+static void set_switch_func_type(SB_Side_Connection& conn, const char* func_type) {
+    if (0 == strcmp(func_type, "lt")) {
+        conn.set_sides(LEFT, TOP);
+    } else if (0 == strcmp(func_type, "lr")) {
+        conn.set_sides(LEFT, RIGHT);
+    } else if (0 == strcmp(func_type, "lb")) {
+        conn.set_sides(LEFT, BOTTOM);
+    } else if (0 == strcmp(func_type, "la")) {
+        conn.set_sides(LEFT, ABOVE);
+    } else if (0 == strcmp(func_type, "lu")) {
+        conn.set_sides(LEFT, UNDER);
+    } else if (0 == strcmp(func_type, "tl")) {
+        conn.set_sides(TOP, LEFT);
+    } else if (0 == strcmp(func_type, "tb")) {
+        conn.set_sides(TOP, BOTTOM);
+    } else if (0 == strcmp(func_type, "tr")) {
+        conn.set_sides(TOP, RIGHT);
+    } else if (0 == strcmp(func_type, "ta")) {
+        conn.set_sides(TOP, ABOVE);
+    } else if (0 == strcmp(func_type, "tu")) {
+        conn.set_sides(TOP, UNDER);
+    } else if (0 == strcmp(func_type, "rt")) {
+        conn.set_sides(RIGHT, TOP);
+    } else if (0 == strcmp(func_type, "rl")) {
+        conn.set_sides(RIGHT, LEFT);
+    } else if (0 == strcmp(func_type, "rb")) {
+        conn.set_sides(RIGHT, BOTTOM);
+    } else if (0 == strcmp(func_type, "ra")) {
+        conn.set_sides(RIGHT, ABOVE);
+    } else if (0 == strcmp(func_type, "ru")) {
+        conn.set_sides(RIGHT, UNDER);
+    } else if (0 == strcmp(func_type, "bl")) {
+        conn.set_sides(BOTTOM, LEFT);
+    } else if (0 == strcmp(func_type, "bt")) {
+        conn.set_sides(BOTTOM, TOP);
+    } else if (0 == strcmp(func_type, "br")) {
+        conn.set_sides(BOTTOM, RIGHT);
+    } else if (0 == strcmp(func_type, "ba")) {
+        conn.set_sides(BOTTOM, ABOVE);
+    } else if (0 == strcmp(func_type, "bu")) {
+        conn.set_sides(BOTTOM, UNDER);
+    } else if (0 == strcmp(func_type, "al")) {
+        conn.set_sides(ABOVE, LEFT);
+    } else if (0 == strcmp(func_type, "at")) {
+        conn.set_sides(ABOVE, TOP);
+    } else if (0 == strcmp(func_type, "ar")) {
+        conn.set_sides(ABOVE, RIGHT);
+    } else if (0 == strcmp(func_type, "ab")) {
+        conn.set_sides(ABOVE, BOTTOM);
+    } else if (0 == strcmp(func_type, "ul")) {
+        conn.set_sides(UNDER, LEFT);
+    } else if (0 == strcmp(func_type, "ut")) {
+        conn.set_sides(UNDER, TOP);
+    } else if (0 == strcmp(func_type, "ur")) {
+        conn.set_sides(UNDER, RIGHT);
+    } else if (0 == strcmp(func_type, "ub")) {
+        conn.set_sides(UNDER, BOTTOM);
+    } else {
+        /* unknown permutation function */
+        archfpga_throw(__FILE__, __LINE__, "Unknown permutation function specified: %s\n", func_type);
+    }
+}
+
 /* Loads permutation funcs specified under Node into t_switchblock_inf. Node should be
  * <switchfuncs> */
 void read_sb_switchfuncs(pugi::xml_node Node, t_switchblock_inf* sb, const pugiutil::loc_data& loc_data) {
@@ -300,34 +367,8 @@ void read_sb_switchfuncs(pugi::xml_node Node, t_switchblock_inf* sb, const pugiu
         func_formula = get_attribute(SubElem, "formula", loc_data).as_string(nullptr);
 
         /* go through all the possible cases of func_type */
-        if (0 == strcmp(func_type, "lt")) {
-            conn.set_sides(LEFT, TOP);
-        } else if (0 == strcmp(func_type, "lr")) {
-            conn.set_sides(LEFT, RIGHT);
-        } else if (0 == strcmp(func_type, "lb")) {
-            conn.set_sides(LEFT, BOTTOM);
-        } else if (0 == strcmp(func_type, "tl")) {
-            conn.set_sides(TOP, LEFT);
-        } else if (0 == strcmp(func_type, "tb")) {
-            conn.set_sides(TOP, BOTTOM);
-        } else if (0 == strcmp(func_type, "tr")) {
-            conn.set_sides(TOP, RIGHT);
-        } else if (0 == strcmp(func_type, "rt")) {
-            conn.set_sides(RIGHT, TOP);
-        } else if (0 == strcmp(func_type, "rl")) {
-            conn.set_sides(RIGHT, LEFT);
-        } else if (0 == strcmp(func_type, "rb")) {
-            conn.set_sides(RIGHT, BOTTOM);
-        } else if (0 == strcmp(func_type, "bl")) {
-            conn.set_sides(BOTTOM, LEFT);
-        } else if (0 == strcmp(func_type, "bt")) {
-            conn.set_sides(BOTTOM, TOP);
-        } else if (0 == strcmp(func_type, "br")) {
-            conn.set_sides(BOTTOM, RIGHT);
-        } else {
-            /* unknown permutation function */
-            archfpga_throw(__FILE__, __LINE__, "Unknown permutation function specified: %s\n", func_type);
-        }
+        set_switch_func_type(conn, func_type);
+
         func_ptr = &(sb->permutation_map[conn]);
 
         /* Here we load the specified switch function(s) */
@@ -404,8 +445,8 @@ static void check_bidir_switchblock(const t_permutation_map* permutation_map) {
     SB_Side_Connection conn;
 
     /* iterate over all combinations of from_side -> to side */
-    for (e_side from_side : {TOP, RIGHT, BOTTOM, LEFT}) {
-        for (e_side to_side : {TOP, RIGHT, BOTTOM, LEFT}) {
+    for (e_side from_side : TOTAL_2D_SIDES) {
+        for (e_side to_side : TOTAL_2D_SIDES) {
             /* can't connect a switchblock side to itself */
             if (from_side == to_side) {
                 continue;

libs/libarchfpga/src/physical_types.h

@@ -176,10 +176,17 @@ enum e_side : unsigned char {
     RIGHT = 1,
     BOTTOM = 2,
     LEFT = 3,
-    NUM_SIDES
+    NUM_2D_SIDES = 4,
+    ABOVE = 5,
+    UNDER = 7,
+    NUM_3D_SIDES = 6,
 };
-constexpr std::array<e_side, NUM_SIDES> SIDES = {{TOP, RIGHT, BOTTOM, LEFT}};                    //Set of all side orientations
-constexpr std::array<const char*, NUM_SIDES> SIDE_STRING = {{"TOP", "RIGHT", "BOTTOM", "LEFT"}}; //String versions of side orientations
+
+constexpr std::array<e_side, NUM_2D_SIDES> TOTAL_2D_SIDES = {{TOP, RIGHT, BOTTOM, LEFT}};                     //Set of all side orientations
+constexpr std::array<const char*, NUM_2D_SIDES> TOTAL_2D_SIDE_STRINGS = {{"TOP", "RIGHT", "BOTTOM", "LEFT"}}; //String versions of side orientations
+
+constexpr std::array<e_side, NUM_3D_SIDES> TOTAL_3D_SIDES = {{TOP, RIGHT, BOTTOM, LEFT, ABOVE, UNDER}};                         //Set of all side orientations including different layers
+constexpr std::array<const char*, NUM_3D_SIDES> TOTAL_3D_SIDE_STRINGS = {{"TOP", "RIGHT", "BOTTOM", "LEFT", "ABOVE", "UNDER"}}; //String versions of side orientations including different layers
 
 /* pin location distributions */
 enum class e_pin_location_distr {
@@ -822,10 +829,11 @@ struct t_physical_pin {
 
 /**
  * @brief Describes The location of a physical tile
- * @param layer_num The die number of the physical tile. If the FPGA only has one die, or the physical tile is located
- *                  on the base die, layer_num is equal to zero. If it is one the die above base die, it is one, etc.
  * @param x The x location of the physical tile on the given die
  * @param y The y location of the physical tile on the given die
+ * @param layer_num The die number of the physical tile. If the FPGA only has one die, or the physical tile is located
+ *                  on the base die, layer_num is equal to zero. If the physical tile is location on the die immediately
+ *                  above the base die, the layer_num is 1 and so on.
  */
 struct t_physical_tile_loc {
     int x = OPEN;
@@ -1285,7 +1293,6 @@ class t_pb_graph_node {
     int total_pb_pins; /* only valid for top-level */
 
     void* temp_scratch_pad;                                     /* temporary data, useful for keeping track of things when traversing data structure */
-    t_cluster_placement_primitive* cluster_placement_primitive; /* pointer to indexing structure useful during packing stage */
 
     int* input_pin_class_size;  /* Stores the number of pins that belong to a particular input pin class */
     int num_input_pin_class;    /* number of input pin classes that this pb_graph_node has */
@@ -1975,10 +1982,12 @@ struct t_router {
 
     /** A value representing the approximate horizontal position on the FPGA device where the router
      * tile is located*/
-    double device_x_position = -1;
+    float device_x_position = -1;
     /** A value representing the approximate vertical position on the FPGA device where the router
      * tile is located*/
-    double device_y_position = -1;
+    float device_y_position = -1;
+    /** A value representing the exact layer in the FPGA device where the router tile is located.*/
+    int device_layer_position = -1;
 
     /** A list of router ids that are connected to the current router*/
     std::vector<int> connection_list;

libs/libarchfpga/src/read_fpga_interchange_arch.cpp

@@ -480,7 +480,7 @@ struct ArchReader {
         type.pin_height_offset.resize(type.num_pins, 0);
 
         type.pinloc.resize({1, 1, 4}, std::vector<bool>(type.num_pins, false));
-        for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
+        for (e_side side : TOTAL_2D_SIDES) {
             for (int pin = 0; pin < type.num_pins; pin++) {
                 type.pinloc[0][0][side][pin] = true;
                 type.pin_width_offset[pin] = 0;

libs/libarchfpga/src/read_xml_arch_file.cpp

@@ -579,7 +579,7 @@ static void LoadPinLoc(pugi::xml_node Locations,
         int num_sides = 4 * (type->width * type->height);
         int side_index = 0;
         int count = 0;
-        for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
+        for (e_side side : TOTAL_2D_SIDES) {
             for (int width = 0; width < type->width; ++width) {
                 for (int height = 0; height < type->height; ++height) {
                     for (int pin_offset = 0; pin_offset < (type->num_pins / num_sides) + 1; ++pin_offset) {
@@ -604,7 +604,7 @@ static void LoadPinLoc(pugi::xml_node Locations,
         while (ipin < type->num_pins) {
             for (int width = 0; width < type->width; ++width) {
                 for (int height = 0; height < type->height; ++height) {
-                    for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
+                    for (e_side side : TOTAL_2D_SIDES) {
                         if (((width == 0 && side == LEFT)
                              || (height == type->height - 1 && side == TOP)
                              || (width == type->width - 1 && side == RIGHT)
@@ -645,7 +645,7 @@ static void LoadPinLoc(pugi::xml_node Locations,
         while (ipin < input_pins.size()) {
             for (int width = 0; width < type->width; ++width) {
                 for (int height = 0; height < type->height; ++height) {
-                    for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
+                    for (e_side side : TOTAL_2D_SIDES) {
                         if (ipin < input_pins.size()) {
                             //Pins still to allocate
 
@@ -668,7 +668,7 @@ static void LoadPinLoc(pugi::xml_node Locations,
         while (ipin < output_pins.size()) {
             for (int width = 0; width < type->width; ++width) {
                 for (int height = 0; height < type->height; ++height) {
-                    for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
+                    for (e_side side : TOTAL_2D_SIDES) {
                         if (((width == 0 && side == LEFT)
                              || (height == type->height - 1 && side == TOP)
                              || (width == type->width - 1 && side == RIGHT)
@@ -699,8 +699,8 @@ static void LoadPinLoc(pugi::xml_node Locations,
             for (int layer = 0; layer < num_of_avail_layer; ++layer) {
                 for (int width = 0; width < type->width; ++width) {
                     for (int height = 0; height < type->height; ++height) {
-                        for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
-                            for (const auto& token : pin_locs->assignments[sub_tile_index][width][height][layer][side]) {
+                        for (e_side side : TOTAL_2D_SIDES) {
+                            for (auto token : pin_locs->assignments[sub_tile_index][width][height][layer][side]) {
                                 auto pin_range = ProcessPinString<t_sub_tile*>(Locations,
                                                                                &sub_tile,
                                                                                token.c_str(),
@@ -3393,9 +3393,9 @@ static void ProcessPinLocations(pugi::xml_node Locations,
         for (int l = 0; l < num_of_avail_layer; ++l) {
             for (int w = 0; w < PhysicalTileType->width; ++w) {
                 for (int h = 0; h < PhysicalTileType->height; ++h) {
-                    for (e_side side : {TOP, RIGHT, BOTTOM, LEFT}) {
-                        for (const auto& token : pin_locs->assignments[sub_tile_index][w][h][l][side]) {
-                            InstPort inst_port(token);
+                    for (e_side side : TOTAL_2D_SIDES) {
+                        for (auto token : pin_locs->assignments[sub_tile_index][w][h][l][side]) {
+                            InstPort inst_port(token.c_str());
 
                             //A pin specification should contain only the block name, and not any instance count information
                             if (inst_port.instance_low_index() != InstPort::UNSPECIFIED || inst_port.instance_high_index() != InstPort::UNSPECIFIED) {
@@ -4766,9 +4766,9 @@ static int find_switch_by_name(const t_arch& arch, const std::string& switch_nam
 }
 
 static e_side string_to_side(const std::string& side_str) {
-    e_side side = NUM_SIDES;
+    e_side side = NUM_2D_SIDES;
     if (side_str.empty()) {
-        side = NUM_SIDES;
+        side = NUM_2D_SIDES;
     } else if (side_str == "left") {
         side = LEFT;
     } else if (side_str == "right") {