Merge branch 'master' into ingest_per_edge_delay

Author: soheilshahrouz

.github/workflows/stale.yml

@@ -0,0 +1,31 @@
+name: 'Close Stale Issues'
+on:
+  schedule:
+    # Run everyday at 1 PM UTC
+    - cron: '0 13 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v9
+        with:
+          # The message to be shown for stale issues
+          stale-issue-message: 'This issue has been inactive for a year and has been marked as stale. It will be closed in 15 days if it continues to be stale. If you believe this is still an issue, please add a comment.'
+          close-issue-message: 'This issue has been marked stale for 15 days and has been automatically closed.'
+          # If you want to exempt an issue from being marked stale/deleted, label it as 'no-stale'
+          exempt-issue-labels: 'no-stale'
+          days-before-issue-stale: 365
+          days-before-issue-close: 15
+          # Start from the oldest issues
+          ascending: true
+          
+          # The configuration below can be used to allow the same behaviour with PRs.
+          # Since we currently don't want to close old PRs, it is commented out but 
+          # left here in case we change our mind.
+
+          # stale-pr-message: 'This PR has been inactive for a year and has been marked as stale. It will be closed in 15 days if it continues to be stale. If you are still working on this PR, please add a comment.'
+          # close-pr-message: 'This PR has been marked stale for 15 days and has been automatically closed.'
+          # exempt-pr-labels: 'no-stale'
+          # days-before-pr-stale: 365
+          # days-before-pr-close: 15

CONTRIBUTING.md

@@ -77,7 +77,7 @@ This information helps us to quickly reproduce (and hopefully fix) the issue:
 
     Tell us what version of VTR you are using (e.g. the output of `vpr --version`), which Operating System and compiler you are using, or any other relevant information about where or how you are building/running VTR.
 
-Once you've gathered all the information [open an Issue](https://github.com/verilog-to-routing/vtr-verilog-to-routing/issues/new?template=bug_report.md) on our issue tracker.
+Once you've gathered all the information [open an Issue](https://github.com/verilog-to-routing/vtr-verilog-to-routing/issues/new?template=bug_report.md) on our issue tracker. Issues that do not have any activity for a year will be automatically marked as stale and will be closed after 15 days of being marked as stale.
 
 If you know how to fix the issue, or already have it coded-up, please also consider [submitting the fix](#submitting-code-to-vtr).
 This is likely the fastest way to get bugs fixed!

libs/libarchfpga/src/cad_types.h

@@ -126,7 +126,7 @@ struct t_cluster_placement_primitive {
     t_pb_graph_node* pb_graph_node;
     bool valid;
     float base_cost;        /* cost independent of current status of packing */
-    float incremental_cost; /* cost dependant on current status of packing */
+    float incremental_cost; /* cost dependent on current status of packing */
 };
 
 #endif

libs/libarchfpga/src/device_grid.h

@@ -80,6 +80,10 @@ class DeviceGrid {
     inline int get_height_offset(const t_physical_tile_loc& tile_loc) const {
         return grid_[tile_loc.layer_num][tile_loc.x][tile_loc.y].height_offset;
     }
+    ///@brief Returns true if the given location is the root location (bottom left corner) of a tile.
+    inline bool is_root_location(const t_physical_tile_loc& tile_loc) const {
+        return get_width_offset(tile_loc) == 0 && get_height_offset(tile_loc) == 0;
+    }
 
     ///@brief Returns a rectangle which represents the bounding box of the tile at the given location.
     inline vtr::Rect<int> get_tile_bb(const t_physical_tile_loc& tile_loc) const {

libs/libarchfpga/src/physical_types.h

@@ -540,10 +540,13 @@ struct t_port_power {
     bool reverse_scaled; /* Scale by (1-prob) */
 };
 
-//The type of Fc specification
+/**
+ * @enum e_fc_type
+ * @brief The type of Fc specification
+ */
 enum class e_fc_type {
-    IN, //The fc specification for an input pin
-    OUT //The fc specification for an output pin
+    IN, /**< Fc specification for an input pin. */
+    OUT /**< Fc specification for an output pin. */
 };
 
 //The value type of the Fc specification
@@ -1562,6 +1565,7 @@ enum e_directionality {
     UNI_DIRECTIONAL,
     BI_DIRECTIONAL
 };
+
 /* X_AXIS: Data that describes an x-directed wire segment (CHANX)                     *
  * Y_AXIS: Data that describes an y-directed wire segment (CHANY)                     *     
  * BOTH_AXIS: Data that can be applied to both x-directed and y-directed wire segment */

libs/librrgraph/src/base/check_rr_graph.cpp

@@ -53,10 +53,10 @@ void check_rr_graph(const RRGraphView& rr_graph,
                     const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data,
                     const DeviceGrid& grid,
                     const t_chan_width& chan_width,
-                    const t_graph_type graph_type,
+                    const e_graph_type graph_type,
                     bool is_flat) {
     e_route_type route_type = DETAILED;
-    if (graph_type == GRAPH_GLOBAL) {
+    if (graph_type == e_graph_type::GLOBAL) {
         route_type = GLOBAL;
     }
 

libs/librrgraph/src/base/check_rr_graph.h

@@ -10,7 +10,7 @@ void check_rr_graph(const RRGraphView& rr_graph,
                     const vtr::vector<RRIndexedDataId, t_rr_indexed_data>& rr_indexed_data,
                     const DeviceGrid& grid,
                     const t_chan_width& chan_width,
-                    const t_graph_type graph_type,
+                    const e_graph_type graph_type,
                     bool is_flat);
 
 void check_rr_node(const RRGraphView& rr_graph,

libs/librrgraph/src/base/get_parallel_segs.cpp

@@ -1,7 +1,5 @@
 #include "get_parallel_segs.h"
 
-/*Gets t_segment_inf for parallel segments as defined by the user. 
- *Segments that have BOTH_AXIS attribute value are always included in the returned vector.*/
 std::vector<t_segment_inf> get_parallel_segs(const std::vector<t_segment_inf>& segment_inf,
                                              t_unified_to_parallel_seg_index& seg_index_map,
                                              enum e_parallel_axis parallel_axis) {

libs/librrgraph/src/base/get_parallel_segs.h

@@ -4,6 +4,18 @@
 #include "rr_graph_type.h"
 #include "physical_types.h"
 
+/**
+ * @brief Returns segments aligned with a given axis, including BOTH_AXIS segments.
+ *
+ * Filters the unified segment list (`segment_inf`) to include only segments matching
+ * the specified `parallel_axis` or marked as `BOTH_AXIS`. Also populates `seg_index_map`
+ * to map unified indices to axis-specific ones.
+ *
+ * @param segment_inf    Unified list of all segments.
+ * @param seg_index_map  Map from unified to axis-specific segment indices.
+ * @param parallel_axis  Axis to filter segments by.
+ * @return Filtered list of segments for the given axis.
+ */
 std::vector<t_segment_inf> get_parallel_segs(const std::vector<t_segment_inf>& segment_inf,
                                              t_unified_to_parallel_seg_index& seg_index_map,
                                              enum e_parallel_axis parallel_axis);

libs/librrgraph/src/base/rr_graph_type.h

@@ -19,18 +19,32 @@ enum e_route_type {
     DETAILED
 };
 
-enum e_graph_type {
-    GRAPH_GLOBAL, /* One node per channel with wire capacity > 1 and full connectivity */
-    GRAPH_BIDIR,  /* Detailed bidirectional graph */
-    GRAPH_UNIDIR, /* Detailed unidir graph, untilable */
-    /* RESEARCH TODO: Get this option debugged */
-    GRAPH_UNIDIR_TILEABLE /* Detail unidir graph with wire groups multiples of 2*L */
+/**
+ * @enum e_graph_type
+ * @brief Represents the type of routing resource graph
+ */
+enum class e_graph_type {
+    GLOBAL,           ///< One node per channel with wire capacity > 1 and full connectivity
+    BIDIR,            ///< Detailed bidirectional routing graph
+    UNIDIR,           ///< Detailed unidirectional routing graph (non-tileable)
+    UNIDIR_TILEABLE   ///< Tileable unidirectional graph with wire groups in multiples of 2 * L (experimental)
 };
-typedef enum e_graph_type t_graph_type;
 
-/* This map is used to get indices w.r.t segment_inf_x or segment_inf_y based on parallel_axis of a segment, 
- * from indices w.r.t the **unified** segment vector, segment_inf in devices context which stores all segments 
- * regardless of their axis. (see get_parallel_segs for more details)*/
+/**
+ * @typedef t_unified_to_parallel_seg_index
+ * @brief Maps indices from the unified segment list to axis-specific segment lists.
+ *
+ * This map is used to translate indices from the unified segment vector
+ * (`segment_inf` in the device context, which contains all segments regardless of axis)
+ * to axis-specific segment vectors (`segment_inf_x` or `segment_inf_y`), based on the
+ * segment's parallel axis.
+ *
+ * Each entry maps a unified segment index to a pair containing:
+ *   - The index in the corresponding axis-specific segment vector
+ *   - The axis of the segment (X or Y)
+ *
+ * @see get_parallel_segs for more details.
+ */
 typedef std::unordered_multimap<size_t, std::pair<size_t, e_parallel_axis>> t_unified_to_parallel_seg_index;
 
 #endif

libs/librrgraph/src/base/rr_node_types.h

@@ -66,7 +66,7 @@ typedef uint16_t t_edge_size;
 /**
  * @brief An iterator that dereferences to an edge index
  *
- * Used inconjunction with vtr::Range to return ranges of edge indices
+ * Used in conjunction with vtr::Range to return ranges of edge indices
  */
 class edge_idx_iterator {
   public:
@@ -101,7 +101,7 @@ typedef vtr::Range<edge_idx_iterator> edge_idx_range;
 typedef std::vector<std::map<int, int>> t_arch_switch_fanin;
 
 /*
- * Reistance/Capacitance data for an RR Nodes
+ * Resistance/Capacitance data for an RR Nodes
  *
  * In practice many RR nodes have the same values, so they are fly-weighted
  * to keep t_rr_node small. Each RR node holds an rc_index which allows

libs/librrgraph/src/io/rr_graph_reader.cpp

@@ -63,7 +63,7 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
                   std::vector<t_rr_rc_data>* rr_rc_data,
                   const DeviceGrid& grid,
                   const std::vector<t_arch_switch_inf>& arch_switch_inf,
-                  const t_graph_type graph_type,
+                  e_graph_type graph_type,
                   const t_arch* arch,
                   t_chan_width* chan_width,
                   const enum e_base_cost_type base_cost_type,

libs/librrgraph/src/io/rr_graph_reader.h

@@ -21,7 +21,7 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder,
                   std::vector<t_rr_rc_data>* rr_rc_data,
                   const DeviceGrid& grid,
                   const std::vector<t_arch_switch_inf>& arch_switch_inf,
-                  const t_graph_type graph_type,
+                  e_graph_type graph_type,
                   const t_arch* arch,
                   t_chan_width* chan_width,
                   const enum e_base_cost_type base_cost_type,

libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h

@@ -270,7 +270,7 @@ struct RrGraphContextTypes : public uxsd::DefaultRrGraphContextTypes {
 class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
   public:
     RrGraphSerializer(
-        const t_graph_type graph_type,
+        const e_graph_type graph_type,
         const enum e_base_cost_type base_cost_type,
         int* wire_to_rr_ipin_switch,
         int* wire_to_rr_ipin_switch_between_dice,
@@ -823,7 +823,7 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
         auto node = (*rr_nodes_)[inode];
         RRNodeId node_id = node.id();
 
-        if (GRAPH_GLOBAL == graph_type_) {
+        if (e_graph_type::GLOBAL == graph_type_) {
             rr_graph_builder_->set_node_cost_index(node_id, RRIndexedDataId(0));
         } else if (rr_graph.node_type(node.id()) == CHANX) {
             int seg_ind_x = find_segment_index_along_axis(segment_id, X_AXIS);
@@ -2166,7 +2166,7 @@ class RrGraphSerializer final : public uxsd::RrGraphBase<RrGraphContextTypes> {
     std::vector<t_rr_rc_data>* rr_rc_data_;
 
     // Constant data for loads and writes.
-    const t_graph_type graph_type_;
+    const e_graph_type graph_type_;
     const enum e_base_cost_type base_cost_type_;
     const bool do_check_rr_graph_;
     const char* read_rr_graph_name_;

libs/librrgraph/src/io/rr_graph_writer.cpp

@@ -42,7 +42,7 @@ void write_rr_graph(RRGraphBuilder* rr_graph_builder,
                     bool is_flat) {
 
     RrGraphSerializer reader(
-        /*graph_type=*/t_graph_type(),
+        /*graph_type=*/e_graph_type(),
         /*base_cost_type=*/e_base_cost_type(),
         /*wire_to_rr_ipin_switch=*/nullptr,
         /*wire_to_rr_ipin_switch_between_dice=*/nullptr,

vpr/src/base/place_and_route.cpp

@@ -28,7 +28,7 @@
 
 /******************* Subroutines local to this module ************************/
 
-static int compute_chan_width(int cfactor, t_chan chan_dist, float distance, float separation, t_graph_type graph_directionality);
+static int compute_chan_width(int cfactor, t_chan chan_dist, float distance, float separation, e_graph_type graph_directionality);
 static float comp_width(t_chan* chan, float x, float separation);
 
 /************************* Subroutine Definitions ****************************/
@@ -68,8 +68,8 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
     int udsd_multiplier;
     int warnings;
 
-    t_graph_type graph_type;
-    t_graph_type graph_directionality;
+    e_graph_type graph_type;
+    e_graph_type graph_directionality;
 
     /* We have chosen to pass placer_opts_ref by reference because of its large size. *
      * However, since the value is mutated later in the function, we declare a        *
@@ -80,11 +80,11 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list,
     /* Allocate the major routing structures. */
 
     if (router_opts.route_type == GLOBAL) {
-        graph_type = GRAPH_GLOBAL;
-        graph_directionality = GRAPH_BIDIR;
+        graph_type = e_graph_type::GLOBAL;
+        graph_directionality = e_graph_type::BIDIR;
     } else {
-        graph_type = (det_routing_arch->directionality == BI_DIRECTIONAL ? GRAPH_BIDIR : GRAPH_UNIDIR);
-        graph_directionality = (det_routing_arch->directionality == BI_DIRECTIONAL ? GRAPH_BIDIR : GRAPH_UNIDIR);
+        graph_type = (det_routing_arch->directionality == BI_DIRECTIONAL ? e_graph_type::BIDIR : e_graph_type::UNIDIR);
+        graph_directionality = (det_routing_arch->directionality == BI_DIRECTIONAL ? e_graph_type::BIDIR : e_graph_type::UNIDIR);
     }
 
     VTR_ASSERT(!net_delay.empty());
@@ -408,7 +408,7 @@ t_chan_width setup_chan_width(const t_router_opts& router_opts,
     /*we give plenty of tracks, this increases routability for the */
     /*lookup table generation */
 
-    t_graph_type graph_directionality;
+    e_graph_type graph_directionality;
     int width_fac;
 
     if (router_opts.fixed_channel_width == NO_FIXED_CHANNEL_WIDTH) {
@@ -425,9 +425,9 @@ t_chan_width setup_chan_width(const t_router_opts& router_opts,
     }
 
     if (router_opts.route_type == GLOBAL) {
-        graph_directionality = GRAPH_BIDIR;
+        graph_directionality = e_graph_type::BIDIR;
     } else {
-        graph_directionality = GRAPH_UNIDIR;
+        graph_directionality = e_graph_type::UNIDIR;
     }
 
     return init_chan(width_fac, chan_width_dist, graph_directionality);
@@ -441,7 +441,9 @@ t_chan_width setup_chan_width(const t_router_opts& router_opts,
  * is used to determine if the channel width should be rounded to an
  * even number.
  */
-t_chan_width init_chan(int cfactor, const t_chan_width_dist& chan_width_dist, t_graph_type graph_directionality) {
+t_chan_width init_chan(int cfactor,
+                       const t_chan_width_dist& chan_width_dist,
+                       e_graph_type graph_directionality) {
     auto& device_ctx = g_vpr_ctx.mutable_device();
     auto& grid = device_ctx.grid;
 
@@ -513,10 +515,10 @@ t_chan_width init_chan(int cfactor, const t_chan_width_dist& chan_width_dist, t_
  *   @param separation              The distance between two channels in the 0 to 1 coordinate system.
  *   @param graph_directionality    The directionality of the graph (unidirectional or bidirectional).
  */
-static int compute_chan_width(int cfactor, t_chan chan_dist, float distance, float separation, t_graph_type graph_directionality) {
+static int compute_chan_width(int cfactor, t_chan chan_dist, float distance, float separation, e_graph_type graph_directionality) {
     int computed_width;
     computed_width = (int)floor(cfactor * comp_width(&chan_dist, distance, separation) + 0.5);
-    if ((GRAPH_BIDIR == graph_directionality) || computed_width % 2 == 0) {
+    if ((e_graph_type::BIDIR == graph_directionality) || computed_width % 2 == 0) {
         return computed_width;
     } else {
         return computed_width - 1;

vpr/src/base/place_and_route.h

@@ -41,7 +41,7 @@ t_chan_width setup_chan_width(const t_router_opts& router_opts,
 
 t_chan_width init_chan(int cfactor,
                        const t_chan_width_dist& chan_width_dist,
-                       t_graph_type graph_directionality);
+                       e_graph_type graph_directionality);
 
 void post_place_sync();