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

Author: amin1377

.github/workflows/nightly_test.yml

@@ -1,6 +1,24 @@
 name: NightlyTest
 
 on:
+  # We want to run the CI when anything is pushed to master.
+  # Since master is a protected branch this only happens when a PR is merged.
+  # This is a double check in case the PR was stale and had some issues.
+  push:
+    branches:
+      - master
+    paths-ignore: # Prevents from running if only docs are updated
+      - 'doc/**'
+      - '**/*README*'
+      - '**.md'
+      - '**.rst'
+  pull_request:
+    paths-ignore: # Prevents from running if only docs are updated
+      - 'doc/**'
+      - '**/*README*'
+      - '**.md'
+      - '**.rst'
+  workflow_dispatch:
   schedule:
   - cron: '0 0 * * *' # daily
 

doc/src/vpr/command_line_usage.rst

@@ -1306,6 +1306,15 @@ The following options are only valid when the router is in timing-driven mode (t
 
     **Default:** ``1.2``
 
+.. option:: --astar_offset <float>
+
+    Sets how aggressive the directed search used by the timing-driven router is.
+    It is a subtractive adjustment to the lookahead heuristic.
+
+    Values between 0 and 1e-9 are resonable; higher values may increase quality at the expense of run-time.
+
+    **Default:** ``0.0``
+
 .. option:: --router_profiler_astar_fac <float>
 
     Controls the directedness of the timing-driven router's exploration when doing router delay profiling of an architecture.

vpr/src/base/SetupVPR.cpp

@@ -423,6 +423,7 @@ static void SetupRoutingArch(const t_arch& Arch,
 static void SetupRouterOpts(const t_options& Options, t_router_opts* RouterOpts) {
     RouterOpts->do_check_rr_graph = Options.check_rr_graph;
     RouterOpts->astar_fac = Options.astar_fac;
+    RouterOpts->astar_offset = Options.astar_offset;
     RouterOpts->router_profiler_astar_fac = Options.router_profiler_astar_fac;
     RouterOpts->bb_factor = Options.bb_factor;
     RouterOpts->criticality_exp = Options.criticality_exp;

vpr/src/base/ShowSetup.cpp

@@ -382,6 +382,7 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
 
     if (TIMING_DRIVEN == RouterOpts.router_algorithm) {
         VTR_LOG("RouterOpts.astar_fac: %f\n", RouterOpts.astar_fac);
+        VTR_LOG("RouterOpts.astar_offset: %f\n", RouterOpts.astar_offset);
         VTR_LOG("RouterOpts.router_profiler_astar_fac: %f\n", RouterOpts.router_profiler_astar_fac);
         VTR_LOG("RouterOpts.criticality_exp: %f\n", RouterOpts.criticality_exp);
         VTR_LOG("RouterOpts.max_criticality: %f\n", RouterOpts.max_criticality);
@@ -735,4 +736,4 @@ static void ShowNocOpts(const t_noc_opts& NocOpts) {
     VTR_LOG("NocOpts.noc_sat_routing_num_workers: %d\n", NocOpts.noc_sat_routing_num_workers);
     VTR_LOG("NocOpts.noc_routing_algorithm: %s\n", NocOpts.noc_placement_file_name.c_str());
     VTR_LOG("\n");
-}
+}

vpr/src/base/read_options.cpp

@@ -2504,6 +2504,14 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .default_value("1.2")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    route_timing_grp.add_argument(args.astar_offset, "--astar_offset")
+        .help(
+            "Controls the directedness of the timing-driven router's exploration."
+            " It is a subtractive adjustment to the lookahead heuristic."
+            " Values between 0 and 1e-9 are resonable; higher values may increase quality at the expense of run-time.")
+        .default_value("0.0")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     route_timing_grp.add_argument(args.router_profiler_astar_fac, "--router_profiler_astar_fac")
         .help(
             "Controls the directedness of the timing-driven router's exploration"

vpr/src/base/read_options.h

@@ -221,6 +221,7 @@ struct t_options {
 
     /* Timing-driven router options only */
     argparse::ArgValue<float> astar_fac;
+    argparse::ArgValue<float> astar_offset;
     argparse::ArgValue<float> router_profiler_astar_fac;
     argparse::ArgValue<float> max_criticality;
     argparse::ArgValue<float> criticality_exp;

vpr/src/base/vpr_types.h

@@ -1344,6 +1344,8 @@ struct t_placer_opts {
  *             an essentially breadth-first search, astar_fac = 1 is near   *
  *             the usual astar algorithm and astar_fac > 1 are more         *
  *             aggressive.                                                  *
+ * astar_offset: Offset that is subtracted from the lookahead (expected     *
+ *               future costs) in the timing-driven router.                 *
  * max_criticality: The maximum criticality factor (from 0 to 1) any sink   *
  *                  will ever have (i.e. clip criticality to this number).  *
  * criticality_exp: Set criticality to (path_length(sink) / longest_path) ^ *
@@ -1432,6 +1434,7 @@ struct t_router_opts {
     enum e_router_algorithm router_algorithm;
     enum e_base_cost_type base_cost_type;
     float astar_fac;
+    float astar_offset;
     float router_profiler_astar_fac;
     float max_criticality;
     float criticality_exp;

vpr/src/pack/cluster_placement.cpp

@@ -140,9 +140,15 @@ bool get_next_primitive_list(t_cluster_placement_stats* cluster_placement_stats,
                         continue;
                     }
 
-
                     /* check for force site match, if applicable */
                     if (force_site > -1) {
+                        /* check that the forced site index is within the available range */
+                        int max_site = it->second->pb_graph_node->total_primitive_count - 1;
+                        if (force_site > max_site) {
+                            VTR_LOG("The specified primitive site (%d) is out of range (max %d)\n",
+                                    force_site, max_site);
+                            break;
+                        }
                         if (force_site == it->second->pb_graph_node->flat_site_index) {
                             cost = try_place_molecule(molecule, it->second->pb_graph_node, primitives_list);
                             if (cost < HUGE_POSITIVE_FLOAT) {

vpr/src/place/initial_noc_placement.cpp

@@ -220,7 +220,7 @@ static void noc_routers_anneal(const t_noc_opts& noc_opts) {
     // Generate and evaluate router moves
     for (int i_move = 0; i_move < N_MOVES; i_move++) {
         e_create_move create_move_outcome = e_create_move::ABORT;
-        clear_move_blocks(blocks_affected);
+        blocks_affected.clear_move_blocks();
         // Shrink the range limit over time
         float r_lim_decayed = 1.0f + (N_MOVES - i_move) * (max_r_lim / N_MOVES);
         create_move_outcome = propose_router_swap(blocks_affected, r_lim_decayed);

vpr/src/place/move_transactions.cpp

@@ -1,12 +1,24 @@
+#include "move_transactions.h"
 #include "move_utils.h"
 
 #include "globals.h"
 #include "place_util.h"
+#include "vtr_assert.h"
+
+t_pl_blocks_to_be_moved::t_pl_blocks_to_be_moved(size_t max_blocks){
+        moved_blocks.reserve(max_blocks);
+}
+
+size_t t_pl_blocks_to_be_moved::get_size_and_increment() {
+    VTR_ASSERT_SAFE(moved_blocks.size() < moved_blocks.capacity());
+    moved_blocks.resize(moved_blocks.size() + 1);
+    return moved_blocks.size() - 1;
+}
 
 //Records that block 'blk' should be moved to the specified 'to' location
-e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected, ClusterBlockId blk, t_pl_loc to) {
-    auto res = blocks_affected.moved_to.emplace(to);
-    if (!res.second) {
+e_block_move_result t_pl_blocks_to_be_moved::record_block_move(ClusterBlockId blk, t_pl_loc to) {
+    auto [to_it, to_success] = moved_to.emplace(to);
+    if (!to_success) {
         log_move_abort("duplicate block move to location");
         return e_block_move_result::ABORT;
     }
@@ -15,36 +27,57 @@ e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected,
 
     t_pl_loc from = place_ctx.block_locs[blk].loc;
 
-    auto res2 = blocks_affected.moved_from.emplace(from);
-    if (!res2.second) {
+    auto [_, from_success] = moved_from.emplace(from);
+    if (!from_success) {
+        moved_to.erase(to_it);
         log_move_abort("duplicate block move from location");
         return e_block_move_result::ABORT;
     }
 
     VTR_ASSERT_SAFE(to.sub_tile < int(place_ctx.grid_blocks.num_blocks_at_location({to.x, to.y, to.layer})));
 
     // Sets up the blocks moved
-    int imoved_blk = blocks_affected.num_moved_blocks;
-    blocks_affected.moved_blocks[imoved_blk].block_num = blk;
-    blocks_affected.moved_blocks[imoved_blk].old_loc = from;
-    blocks_affected.moved_blocks[imoved_blk].new_loc = to;
-    blocks_affected.num_moved_blocks++;
+    size_t imoved_blk = get_size_and_increment();
+    moved_blocks[imoved_blk].block_num = blk;
+    moved_blocks[imoved_blk].old_loc = from;
+    moved_blocks[imoved_blk].new_loc = to;
 
     return e_block_move_result::VALID;
 }
 
+//Examines the currently proposed move and determine any empty locations
+std::set<t_pl_loc> t_pl_blocks_to_be_moved::t_pl_blocks_to_be_moved::determine_locations_emptied_by_move() {
+    std::set<t_pl_loc> moved_from_set;
+    std::set<t_pl_loc> moved_to_set;
+
+    for (const t_pl_moved_block& moved_block : moved_blocks) {
+        //When a block is moved its old location becomes free
+        moved_from_set.emplace(moved_block.old_loc);
+
+        //But any block later moved to a position fills it
+        moved_to_set.emplace(moved_block.new_loc);
+    }
+
+    std::set<t_pl_loc> empty_locs;
+    std::set_difference(moved_from_set.begin(), moved_from_set.end(),
+                        moved_to_set.begin(), moved_to_set.end(),
+                        std::inserter(empty_locs, empty_locs.begin()));
+
+    return empty_locs;
+}
+
 //Moves the blocks in blocks_affected to their new locations
 void apply_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
     auto& device_ctx = g_vpr_ctx.device();
 
     //Swap the blocks, but don't swap the nets or update place_ctx.grid_blocks
     //yet since we don't know whether the swap will be accepted
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
-        ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
+    for (const t_pl_moved_block& moved_block : blocks_affected.moved_blocks) {
+        ClusterBlockId blk = moved_block.block_num;
 
-        const t_pl_loc& old_loc = blocks_affected.moved_blocks[iblk].old_loc;
-        const t_pl_loc& new_loc = blocks_affected.moved_blocks[iblk].new_loc;
+        const t_pl_loc& old_loc = moved_block.old_loc;
+        const t_pl_loc& new_loc = moved_block.new_loc;
 
         // move the block to its new location
         place_ctx.block_locs[blk].loc = new_loc;
@@ -67,11 +100,11 @@ void commit_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& place_ctx = g_vpr_ctx.mutable_placement();
 
     /* Swap physical location */
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
-        ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
+    for (const t_pl_moved_block& moved_block : blocks_affected.moved_blocks) {
+        ClusterBlockId blk = moved_block.block_num;
 
-        const t_pl_loc& to = blocks_affected.moved_blocks[iblk].new_loc;
-        const t_pl_loc& from = blocks_affected.moved_blocks[iblk].old_loc;
+        const t_pl_loc& to = moved_block.new_loc;
+        const t_pl_loc& from = moved_block.old_loc;
 
         //Remove from old location only if it hasn't already been updated by a previous block update
         if (place_ctx.grid_blocks.block_at_location(from) == blk) {
@@ -97,11 +130,11 @@ void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
     auto& device_ctx = g_vpr_ctx.device();
 
     // Swap the blocks back, nets not yet swapped they don't need to be changed
-    for (int iblk = 0; iblk < blocks_affected.num_moved_blocks; ++iblk) {
-        ClusterBlockId blk = blocks_affected.moved_blocks[iblk].block_num;
+    for (const t_pl_moved_block& moved_block : blocks_affected.moved_blocks) {
+        ClusterBlockId blk = moved_block.block_num;
 
-        const t_pl_loc& old_loc = blocks_affected.moved_blocks[iblk].old_loc;
-        const t_pl_loc& new_loc = blocks_affected.moved_blocks[iblk].new_loc;
+        const t_pl_loc& old_loc = moved_block.old_loc;
+        const t_pl_loc& new_loc = moved_block.new_loc;
 
         // return the block to where it was before the swap
         place_ctx.block_locs[blk].loc = old_loc;
@@ -121,15 +154,15 @@ void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected) {
 }
 
 //Clears the current move so a new move can be proposed
-void clear_move_blocks(t_pl_blocks_to_be_moved& blocks_affected) {
+void t_pl_blocks_to_be_moved::clear_move_blocks() {
     //Reset moved flags
-    blocks_affected.moved_to.clear();
-    blocks_affected.moved_from.clear();
+    moved_to.clear();
+    moved_from.clear();
 
-    //For run-time, we just reset num_moved_blocks to zero, but do not free the blocks_affected
+    //For run-time, we just reset size of blocks_affected.moved_blocks to zero, but do not free the blocks_affected
     //array to avoid memory allocation
 
-    blocks_affected.num_moved_blocks = 0;
+    moved_blocks.resize(0);
 
-    blocks_affected.affected_pins.clear();
+    affected_pins.clear();
 }

vpr/src/place/move_transactions.h

@@ -3,6 +3,13 @@
 #include "vpr_types.h"
 #include "clustered_netlist_utils.h"
 
+enum class e_block_move_result {
+    VALID,       //Move successful
+    ABORT,       //Unable to perform move
+    INVERT,      //Try move again but with from/to inverted
+    INVERT_VALID //Completed inverted move
+};
+
 /* Stores the information of the move for a block that is       *
  * moved during placement                                       *
  * block_num: the index of the moved block                      *
@@ -25,41 +32,45 @@ struct t_pl_moved_block {
  * placement, in the form of array of structs instead of struct with    *
  * arrays for cache effifiency                                          *
  *
- * num_moved_blocks: total number of blocks moved when          *
- *                   swapping two blocks.                       *
  * moved blocks: a list of moved blocks data structure with     *
  *               information on the move.                       *
  *               [0...max_blocks-1]                       *
  * affected_pins: pins affected by this move (used to           *
  *                incrementally invalidate parts of the timing  *
  *                graph.                                        */
 struct t_pl_blocks_to_be_moved {
-    explicit t_pl_blocks_to_be_moved(size_t max_blocks)
-        : moved_blocks(max_blocks) {}
+    explicit t_pl_blocks_to_be_moved(size_t max_blocks);
+    t_pl_blocks_to_be_moved() = delete;
+    t_pl_blocks_to_be_moved(const t_pl_blocks_to_be_moved&) = delete;
+    t_pl_blocks_to_be_moved(t_pl_blocks_to_be_moved&&) = delete;
+
+/**
+ * @brief This function increments the size of the moved_blocks vector and return the index
+ * of the newly added last elements. 
+ */
+    size_t get_size_and_increment();
+
+/**
+ * @brief This function clears all data structures of this struct.
+ */
+    void clear_move_blocks();
+
+    e_block_move_result record_block_move(ClusterBlockId blk, t_pl_loc to);
+    
+    std::set<t_pl_loc> determine_locations_emptied_by_move();
 
-    int num_moved_blocks = 0;
     std::vector<t_pl_moved_block> moved_blocks;
     std::unordered_set<t_pl_loc> moved_from;
     std::unordered_set<t_pl_loc> moved_to;
 
     std::vector<ClusterPinId> affected_pins;
 };
 
-enum class e_block_move_result {
-    VALID,       //Move successful
-    ABORT,       //Unable to perform move
-    INVERT,      //Try move again but with from/to inverted
-    INVERT_VALID //Completed inverted move
-};
-
-e_block_move_result record_block_move(t_pl_blocks_to_be_moved& blocks_affected, ClusterBlockId blk, t_pl_loc to);
 
 void apply_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected);
 
 void commit_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected);
 
 void revert_move_blocks(const t_pl_blocks_to_be_moved& blocks_affected);
 
-void clear_move_blocks(t_pl_blocks_to_be_moved& blocks_affected);
-
 #endif