Merge branch 'master' into reconstruction_from_flat_placement_dicrepancy_debugging

Author: AlexandreSinger

.github/workflows/nightly_test.yml

@@ -22,8 +22,6 @@ on:
   #     - '**.md'
   #     - '**.rst'
   workflow_dispatch:
-  schedule:
-  - cron: '0 0 * * *' # daily
 
 # We want to cancel previous runs for a given PR or branch / ref if another CI
 # run is requested.

.github/workflows/nightly_test_manual.yml

@@ -4,6 +4,11 @@ name: NightlyTestManual
 on:
   workflow_dispatch:
 
+  # Automatically runs every Sunday 5 AM UTC.
+  # Results should be ready ~15 hours later (Sunday 8 PM UTC), on time for Monday mornings.
+  schedule:
+    - cron:  '0 5 * * 0'
+
 # We want to cancel previous runs for a given PR or branch / ref if another CI
 # run is requested.
 # See: https://docs.github.com/en/actions/using-jobs/using-concurrency
@@ -57,15 +62,38 @@ jobs:
     # Run all of the nightly tests.
     # TODO: We could expose more parallelism if we had one task list which ran
     #       all of these.
-    - name: 'Run Nightly Tests'
+    - name: 'Run Nightly Test 1'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test1
+
+    - name: 'Run Nightly Test 2'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test2
+
+    - name: 'Run Nightly Test 3'
       run: |
         source .venv/bin/activate
-        ./run_reg_test.py -j12 \
-            vtr_reg_nightly_test1 \
-            vtr_reg_nightly_test2 \
-            vtr_reg_nightly_test3 \
-            vtr_reg_nightly_test4 \
-            vtr_reg_nightly_test5 \
-            vtr_reg_nightly_test6 \
-            vtr_reg_nightly_test7
+        ./run_reg_test.py -j12 vtr_reg_nightly_test3
+
 
+    - name: 'Run Nightly Test 4'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test4
+
+    - name: 'Run Nightly Test 5'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test5
+
+    - name: 'Run Nightly Test 6'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test6
+
+    - name: 'Run Nightly Test 7'
+      run: |
+        source .venv/bin/activate
+        ./run_reg_test.py -j12 vtr_reg_nightly_test7

vpr/src/analytical_place/full_legalizer.cpp

@@ -101,14 +101,13 @@ class APClusterPlacer {
 private:
     // Get the macro for the given cluster block.
     t_pl_macro get_macro(ClusterBlockId clb_blk_id) {
-        const auto& place_macros = g_vpr_ctx.placement().blk_loc_registry().place_macros();
         // Basically stolen from initial_placement.cpp:place_one_block
         // TODO: Make this a cleaner interface and share the code.
-        int imacro = place_macros.get_imacro_from_iblk(clb_blk_id);
+        int imacro = place_macros_.get_imacro_from_iblk(clb_blk_id);
 
         // If this block is part of a macro, return it.
         if (imacro != -1) {
-            return place_macros[imacro];
+            return place_macros_[imacro];
         }
         // If not, create a "fake" macro with a single element.
         t_pl_macro_member macro_member;
@@ -121,20 +120,22 @@ class APClusterPlacer {
         return pl_macro;
     }
 
+    const PlaceMacros& place_macros_;
+
 public:
     /**
      * @brief Constructor for the APClusterPlacer
      *
      * Initializes internal and global state necessary to place clusters on the
      * FPGA device.
      */
-    APClusterPlacer() {
+    APClusterPlacer(const PlaceMacros& place_macros)
+                : place_macros_(place_macros) {
         // FIXME: This was stolen from place/place.cpp
         //        it used a static method, just taking what I think I will need.
         auto& blk_loc_registry = g_vpr_ctx.mutable_placement().mutable_blk_loc_registry();
-        const auto& directs = g_vpr_ctx.device().arch->directs;
 
-        init_placement_context(blk_loc_registry, directs);
+        init_placement_context(blk_loc_registry);
 
         // stolen from place/place.cpp:alloc_and_load_try_swap_structs
         // FIXME: set cube_bb to false by hand, should be passed in.
@@ -149,7 +150,7 @@ class APClusterPlacer {
         blk_loc_registry.clear_all_grid_locs();
 
         // Deal with the placement constraints.
-        propagate_place_constraints(blk_loc_registry.place_macros());
+        propagate_place_constraints(place_macros_);
 
         mark_fixed_blocks(blk_loc_registry);
 
@@ -384,6 +385,7 @@ void NaiveFullLegalizer::create_clusters(const PartialPlacement& p_placement) {
 }
 
 void NaiveFullLegalizer::place_clusters(const ClusteredNetlist& clb_nlist,
+                                        const PlaceMacros& place_macros,
                                         const PartialPlacement& p_placement) {
     // PLACING:
     // Create a lookup from the AtomBlockId to the APBlockId
@@ -405,7 +407,7 @@ void NaiveFullLegalizer::place_clusters(const ClusteredNetlist& clb_nlist,
     // Move the clusters to where they want to be first.
     // TODO: The fixed clusters should probably be moved first for legality
     //       reasons.
-    APClusterPlacer ap_cluster_placer;
+    APClusterPlacer ap_cluster_placer(place_macros);
     std::vector<ClusterBlockId> unplaced_clusters;
     for (ClusterBlockId cluster_blk_id : clb_nlist.blocks()) {
         // Assume that the cluster will always want to be placed wherever the
@@ -466,8 +468,18 @@ void NaiveFullLegalizer::legalize(const PartialPlacement& p_placement) {
     // TODO: Eventually should be returned from the create_clusters method.
     const ClusteredNetlist& clb_nlist = g_vpr_ctx.clustering().clb_nlist;
 
+    // Alloc and load the placement macros.
+    VTR_ASSERT(!g_vpr_ctx.placement().place_macros);
+    g_vpr_ctx.mutable_placement().place_macros = std::make_unique<PlaceMacros>(g_vpr_ctx.device().arch->directs,
+                                                                               g_vpr_ctx.device().physical_tile_types,
+                                                                               g_vpr_ctx.clustering().clb_nlist,
+                                                                               g_vpr_ctx.atom().nlist,
+                                                                               g_vpr_ctx.atom().lookup);
+
+    const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
+
     // Place the clusters based on where the atoms want to be placed.
-    place_clusters(clb_nlist, p_placement);
+    place_clusters(clb_nlist, place_macros, p_placement);
 
     // Verify that the placement created by the full legalizer is valid.
     unsigned num_placement_errors = verify_placement(g_vpr_ctx);

vpr/src/analytical_place/full_legalizer.h

@@ -19,6 +19,7 @@ class AtomNetlist;
 class ClusteredNetlist;
 class DeviceGrid;
 class PartialPlacement;
+class PlaceMacros;
 class Prepacker;
 struct t_arch;
 struct t_logical_block_type;
@@ -125,6 +126,7 @@ class NaiveFullLegalizer : public FullLegalizer {
      *        placement.
      */
     void place_clusters(const ClusteredNetlist& clb_nlist,
+                        const PlaceMacros& place_macros,
                         const PartialPlacement& p_placement);
 
 };

vpr/src/base/blk_loc_registry.cpp

@@ -45,14 +45,6 @@ int BlkLocRegistry::net_pin_to_tile_pin_index(const ClusterNetId net_id, int net
     return this->tile_pin_index(pin_id);
 }
 
-const PlaceMacros& BlkLocRegistry::place_macros() const {
-    return place_macros_;
-}
-
-PlaceMacros& BlkLocRegistry::mutable_place_macros() {
-    return  place_macros_;
-}
-
 void BlkLocRegistry::set_block_location(ClusterBlockId blk_id, const t_pl_loc& location) {
     const auto& device_ctx = g_vpr_ctx.device();
     const auto& cluster_ctx = g_vpr_ctx.clustering();
@@ -289,3 +281,4 @@ t_physical_tile_loc BlkLocRegistry::get_coordinate_of_pin(ClusterPinId pin) cons
 
     return tile_loc;
 }
+

vpr/src/base/blk_loc_registry.h

@@ -5,7 +5,6 @@
 #include "vtr_vector_map.h"
 #include "vpr_types.h"
 #include "grid_block.h"
-#include "place_macro.h"
 
 struct t_block_loc;
 struct t_pl_blocks_to_be_moved;
@@ -37,13 +36,6 @@ class BlkLocRegistry {
     ///@brief Clustered pin placement mapping with physical pin
     vtr::vector_map<ClusterPinId, int> physical_pins_;
 
-    /**
-     * @brief Contains information about placement macros.
-     * A placement macro is a set of clustered blocks that must be placed
-     * in a way that is compliant with relative locations specified by the macro.
-     */
-    PlaceMacros place_macros_;
-
     /// @brief Stores ClusterBlockId of all movable clustered blocks
     /// (blocks that are not locked down to a single location)
     std::vector<ClusterBlockId> movable_blocks_;
@@ -67,12 +59,6 @@ class BlkLocRegistry {
     ///@brief Returns the physical pin of the tile, related to the given ClusterNedId, and the net pin index.
     int net_pin_to_tile_pin_index(const ClusterNetId net_id, int net_pin_index) const;
 
-    ///@brief Returns a constant reference to placement macros.
-    const PlaceMacros& place_macros() const;
-
-    ///@brief Returns a mutable reference to placement macros.
-    PlaceMacros& mutable_place_macros();
-
     /// @brief Returns a constant reference to the vector of ClusterBlockIds of all movable clustered blocks.
     const std::vector<ClusterBlockId>& movable_blocks() const { return movable_blocks_; }
 
@@ -170,3 +156,4 @@ class BlkLocRegistry {
 
     e_expected_transaction expected_transaction_;
 };
+

vpr/src/base/place_and_route.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 
 #include "FlatPlacementInfo.h"
+#include "place_macro.h"
 #include "vtr_assert.h"
 #include "vtr_log.h"
 

vpr/src/base/vpr_api.cpp

@@ -14,9 +14,13 @@
 #include <cstdio>
 #include <cstring>
 #include <cmath>
+#include <memory>
+#include <vector>
 
 #include "FlatPlacementInfo.h"
 #include "cluster_util.h"
+#include "physical_types.h"
+#include "place_macro.h"
 #include "verify_placement.h"
 #include "vpr_context.h"
 #include "vtr_assert.h"
@@ -741,7 +745,9 @@ bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
     return true;
 }
 
-bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch& arch) {
+bool vpr_place_flow(const Netlist<>& net_list,
+                    t_vpr_setup& vpr_setup,
+                    const t_arch& arch) {
     VTR_LOG("\n");
     const auto& placer_opts = vpr_setup.PlacerOpts;
     const auto& filename_opts = vpr_setup.FileNameOpts;
@@ -756,7 +762,7 @@ bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_a
             VTR_ASSERT(placer_opts.doPlacement == STAGE_LOAD);
 
             //Load a previous placement
-            vpr_load_placement(vpr_setup, arch);
+            vpr_load_placement(vpr_setup, arch.directs);
         }
 
         post_place_sync();
@@ -781,7 +787,9 @@ bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_a
     return true;
 }
 
-void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch& arch) {
+void vpr_place(const Netlist<>& net_list,
+               t_vpr_setup& vpr_setup,
+               const t_arch& arch) {
     bool is_flat = false;
     if (vpr_setup.PlacerOpts.place_algorithm.is_timing_driven()) {
         // Prime lookahead cache to avoid adding lookahead computation cost to
@@ -828,7 +836,8 @@ void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch&
                                block_locs);
 }
 
-void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
+void vpr_load_placement(t_vpr_setup& vpr_setup,
+                        const std::vector<t_direct_inf> directs) {
     vtr::ScopedStartFinishTimer timer("Load Placement");
 
     const auto& device_ctx = g_vpr_ctx.device();
@@ -837,7 +846,14 @@ void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch) {
     const auto& filename_opts = vpr_setup.FileNameOpts;
 
     //Initialize placement data structures, which will be filled when loading placement
-    init_placement_context(blk_loc_registry, arch.directs);
+    init_placement_context(blk_loc_registry);
+
+    // Alloc and load the placement macros.
+    place_ctx.place_macros = std::make_unique<PlaceMacros>(directs,
+                                                           device_ctx.physical_tile_types,
+                                                           g_vpr_ctx.clustering().clb_nlist,
+                                                           g_vpr_ctx.atom().nlist,
+                                                           g_vpr_ctx.atom().lookup);
 
     //Load an existing placement from a file
     place_ctx.placement_id = read_place(filename_opts.NetFile.c_str(), filename_opts.PlaceFile.c_str(),

vpr/src/base/vpr_api.h

@@ -71,13 +71,18 @@ bool vpr_load_flat_placement(t_vpr_setup& vpr_setup, const t_arch& arch);
 /* Placement */
 
 ///@brief Perform, load or skip the placement stage
-bool vpr_place_flow(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch& arch);
+bool vpr_place_flow(const Netlist<>& net_list,
+                    t_vpr_setup& vpr_setup,
+                    const t_arch& arch);
 
 ///@brief Perform placement
-void vpr_place(const Netlist<>& net_list, t_vpr_setup& vpr_setup, const t_arch& arch);
+void vpr_place(const Netlist<>& net_list,
+               t_vpr_setup& vpr_setup,
+               const t_arch& arch);
 
 ///@brief Loads a previous placement
-void vpr_load_placement(t_vpr_setup& vpr_setup, const t_arch& arch);
+void vpr_load_placement(t_vpr_setup& vpr_setup,
+                        const std::vector<t_direct_inf> directs);
 
 /* Routing */
 

vpr/src/base/vpr_context.h

@@ -6,6 +6,7 @@
 #include <mutex>
 
 #include "FlatPlacementInfo.h"
+#include "place_macro.h"
 #include "user_place_constraints.h"
 #include "user_route_constraints.h"
 #include "vpr_types.h"
@@ -362,6 +363,16 @@ struct PlacementContext : public Context {
      */
     void unlock_loc_vars() { VTR_ASSERT_SAFE(!loc_vars_are_accessible_); loc_vars_are_accessible_ = true; }
 
+    /**
+     * @brief Collection of all the placement macros in the netlist. A placement
+     *        macro is a set of clustered blocks that must be placed in a way
+     *        that is compliant with relative locations specified by the macro.
+     *        Macros are used during placement and are not modified after they
+     *        are created.
+     * This is created at the start of placement.
+     */
+    std::unique_ptr<PlaceMacros> place_macros;
+
     /**
      * @brief Compressed grid space for each block type
      *

vpr/src/draw/draw.cpp

@@ -569,7 +569,7 @@ void init_draw_coords(float clb_width, const BlkLocRegistry& blk_loc_registry) {
             draw_state->draw_rr_node[inode].node_highlighted = false;
         }
     }
-    draw_coords->tile_width = clb_width;
+    draw_coords->set_tile_width(clb_width);
     draw_coords->pin_size = 0.3;
     for (const auto& type : device_ctx.physical_tile_types) {
         auto num_pins = type.num_pins;

vpr/src/draw/draw_basic.cpp

@@ -776,7 +776,9 @@ void draw_placement_macros(ezgl::renderer* g) {
     t_draw_coords* draw_coords = get_draw_coords_vars();
 
     const auto& block_locs = draw_state->get_graphics_blk_loc_registry_ref().block_locs();
-    const auto& place_macros = draw_state->get_graphics_blk_loc_registry_ref().place_macros();
+
+    VTR_ASSERT(g_vpr_ctx.placement().place_macros);
+    const PlaceMacros& place_macros = *g_vpr_ctx.placement().place_macros;
 
     for (const t_pl_macro& pl_macro : place_macros.macros()) {
 

vpr/src/draw/draw_types.h

@@ -410,6 +410,11 @@ struct t_draw_coords {
     ///@brief constructor
     t_draw_coords();
 
+    ///@brief Sets the tile width
+    inline void set_tile_width(float new_tile_width) {
+        tile_width = new_tile_width;
+    }
+
     ///@brief returns tile width
     float get_tile_width();