fix compile errors

Author: amin1377

vpr/src/base/CheckSetup.cpp

@@ -7,6 +7,7 @@
 #include "globals.h"
 #include "read_xml_arch_file.h"
 
+
 static constexpr int DYMANIC_PORT_RANGE_MIN = 49152;
 static constexpr int DYNAMIC_PORT_RANGE_MAX = 65535;
 
@@ -56,14 +57,16 @@ void CheckSetup(const t_packer_opts& packer_opts,
                         "A block location file requires that placement is enabled.\n");
     }
 
-    if (placer_opts.place_algorithm.is_timing_driven() && placer_opts.place_static_move_prob.size() > NUM_PL_MOVE_TYPES) {
+    if (placer_opts.place_algorithm.is_timing_driven() &&
+        placer_opts.place_static_move_prob.size() > NUM_PL_MOVE_TYPES) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                         "The number of provided placer move probabilities (%d) should equal or less than the total number of supported moves (%d).\n",
                         placer_opts.place_static_move_prob.size(),
                         NUM_PL_MOVE_TYPES);
     }
 
-    if (!placer_opts.place_algorithm.is_timing_driven() && placer_opts.place_static_move_prob.size() > NUM_PL_NONTIMING_MOVE_TYPES) {
+    if (!placer_opts.place_algorithm.is_timing_driven() &&
+        placer_opts.place_static_move_prob.size() > NUM_PL_NONTIMING_MOVE_TYPES) {
         VPR_FATAL_ERROR(VPR_ERROR_OTHER,
                         "The number of placer non timing move probabilities (%d) should equal to or less than the total number of supported moves (%d).\n",
                         placer_opts.place_static_move_prob.size(),

vpr/src/base/SetupGrid.h

@@ -27,16 +27,6 @@ DeviceGrid create_device_grid(const std::string& layout_name,
                               size_t min_width,
                               size_t min_height);
 
-DeviceGrid create_device_grid(const std::string& layout_name, const std::vector<t_grid_def>& grid_layouts, size_t min_width, size_t min_height);
-
-/**
- * @brief Calculate the device utilization
- *
- * Calculate the device utilization (i.e. fraction of used grid tiles)
- * foor the specified grid and resource requirements
- */
-float calculate_device_utilization(const DeviceGrid& grid, const std::map<t_logical_block_type_ptr, size_t>& instance_counts);
-
 /**
  * @brief Returns the effective size of the device
  *        (size of the bounding box of non-empty grid tiles)

vpr/src/base/gen/vpr_constraints_uxsdcxx.h

@@ -132,7 +132,6 @@ static_assert(alignof(triehash_uu64) == 1, "Unaligned 64-bit access not found.")
 enum class atok_t_add_atom {NAME_PATTERN};
 constexpr const char *atok_lookup_t_add_atom[] = {"name_pattern"};
 
-
 enum class atok_t_add_region { LAYER_HIGH,
                                LAYER_LOW,
                                SUBTILE,
@@ -575,6 +574,12 @@ inline atok_t_vpr_constraints lex_attr_t_vpr_constraints(const char* in, const s
  */
 [[noreturn]] inline void dfa_error(const char* wrong, const int* states, const char* const* lookup, int len, const std::function<void(const char*)>* report_error);
 
+/**
+ * Internal error function for xs:all validators.
+ */
+template<std::size_t N>
+[[noreturn]] inline void all_error(std::bitset<N> gstate, const char* const* lookup, const std::function<void(const char*)>* report_error);
+
 /**
  * Internal error function for attribute validators.
  */
@@ -1052,13 +1057,13 @@ inline void load_vpr_constraints(const pugi::xml_node &root, T &out, Context &co
     for (pugi::xml_node node = root.first_child(); node; node = node.next_sibling()) {
         *offset_debug = node.offset_debug();
         gtok_t_vpr_constraints in = lex_node_t_vpr_constraints(node.name(), report_error);
-        next = gstate_t_vpr_constraints[state][(int)in];
-        if (next == -1)
-            dfa_error(gtok_lookup_t_vpr_constraints[(int)in], gstate_t_vpr_constraints[state], gtok_lookup_t_vpr_constraints, 2, report_error);
-        state = next;
+        if (gstate[(int)in] == 0)
+            gstate[(int)in] = 1;
+        else
+            noreturn_report(report_error, ("Duplicate element " + std::string(node.name()) + " in <vpr_constraints>.").c_str());
         switch (in) {
             case gtok_t_vpr_constraints::PARTITION_LIST: {
-                auto child_context = out.add_vpr_constraints_partition_list(context);
+                auto child_context = out.init_vpr_constraints_partition_list(context);
                 load_partition_list(node, out, child_context, report_error, offset_debug);
                 out.finish_vpr_constraints_partition_list(child_context);
             } break;
@@ -1164,12 +1169,6 @@ inline void write_vpr_constraints(T& in, std::ostream& os, Context& context) {
             os << "</global_route_constraints>\n";
         }
     }
-    {
-        auto child_context = in.get_vpr_constraints_global_route_constraints(context);
-        os << "<global_route_constraints>\n";
-        write_global_route_constraints(in, os, child_context);
-        os << "</global_route_constraints>\n";
-    }
 }
 
 inline void dfa_error(const char* wrong, const int* states, const char* const* lookup, int len, const std::function<void(const char*)>* report_error) {
@@ -1185,6 +1184,20 @@ inline void dfa_error(const char* wrong, const int* states, const char* const* l
     noreturn_report(report_error, ("Expected " + expected_or + ", found " + std::string(wrong)).c_str());
 }
 
+template<std::size_t N>
+inline void all_error(std::bitset<N> gstate, const char* const* lookup, const std::function<void(const char*)>* report_error) {
+    std::vector<std::string> missing;
+    for (unsigned int i = 0; i < N; i++) {
+        if (gstate[i] == 0) missing.push_back(lookup[i]);
+    }
+
+    std::string missing_and = missing[0];
+    for (unsigned int i = 1; i < missing.size(); i++)
+        missing_and += std::string(", ") + missing[i];
+
+    noreturn_report(report_error, ("Didn't find required elements " + missing_and + ".").c_str());
+}
+
 template<std::size_t N>
 inline void attr_error(std::bitset<N> astate, const char* const* lookup, const std::function<void(const char*)>* report_error) {
     std::vector<std::string> missing;

vpr/src/base/gen/vpr_constraints_uxsdcxx_interface.h

@@ -141,6 +141,10 @@ class VprConstraintsBase {
     virtual inline typename ContextTypes::SetGlobalSignalWriteContext add_global_route_constraints_set_global_signal(typename ContextTypes::GlobalRouteConstraintsWriteContext& ctx, enum_route_model_type route_model) = 0;
     virtual inline void finish_global_route_constraints_set_global_signal(typename ContextTypes::SetGlobalSignalWriteContext& ctx) = 0;
     virtual inline size_t num_global_route_constraints_set_global_signal(typename ContextTypes::GlobalRouteConstraintsReadContext& ctx) = 0;
+    virtual inline typename ContextTypes::SetGlobalSignalReadContext get_global_route_constraints_set_global_signal(int n, typename ContextTypes::GlobalRouteConstraintsReadContext& ctx) = 0;
+
+    /** Generated for complex type "vpr_constraints":
+     * <xs:complexType xmlns:xs="http://www.w3.org/2001/XMLSchema">
      *     <xs:all minOccurs="0">
      *       <xs:element name="partition_list" type="partition_list" />
      *       <xs:element name="global_route_constraints" type="global_route_constraints" />
@@ -150,8 +154,7 @@ class VprConstraintsBase {
      */
     virtual inline const char* get_vpr_constraints_tool_name(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
     virtual inline void set_vpr_constraints_tool_name(const char* tool_name, typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
-    virtual inline void preallocate_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx, size_t size) = 0;
-    virtual inline typename ContextTypes::PartitionListWriteContext add_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
+    virtual inline typename ContextTypes::PartitionListWriteContext init_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsWriteContext& ctx) = 0;
     virtual inline void finish_vpr_constraints_partition_list(typename ContextTypes::PartitionListWriteContext& ctx) = 0;
     virtual inline typename ContextTypes::PartitionListReadContext get_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;
     virtual inline bool has_vpr_constraints_partition_list(typename ContextTypes::VprConstraintsReadContext& ctx) = 0;

vpr/src/base/vpr_api.cpp

@@ -350,7 +350,7 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a
     //Initialize vpr floorplanning and routing constraints
     auto& filename_opts = vpr_setup->FileNameOpts;
     if (!filename_opts.read_vpr_constraints_file.empty()) {
-        load_vpr_constraints_files(filename_opts.read_vpr_constraints_file.c_str());
+        load_vpr_constraints_file(filename_opts.read_vpr_constraints_file.c_str());
 
         // Check if there are route constraints specified, and if the clock modeling setting is explicitly specified
         // If both conditions are met, issue a warning that the route constraints will override the clock modeling setting.

vpr/src/base/vpr_constraints.h

@@ -1,16 +1,8 @@
 #ifndef VPR_CONSTRAINTS_H
 #define VPR_CONSTRAINTS_H
 
-<<<<<<< HEAD
 #include "user_place_constraints.h"
 #include "user_route_constraints.h"
-=======
-#include "vtr_vector.h"
-#include "vpr_utils.h"
-#include "partition.h"
-#include "partition_region.h"
-#include "route_constraint.h"
->>>>>>> Route constraint for local clock and reset.
 
 /**
  * @brief This file defines the VprConstraints class, which encapsulates user-specified placement and routing constraints

vpr/src/base/vpr_constraints.xsd

@@ -97,7 +97,8 @@
       <xs:all minOccurs="0">
         <xs:element name="partition_list" type="partition_list"/>
         <xs:element name="global_route_constraints" type="global_route_constraints"/>
-      </xs:choice>
+      </xs:all>
+
       <xs:attribute name="tool_name" type="xs:string"/>
     </xs:complexType>
   </xs:element>

vpr/src/base/vpr_constraints_reader.cpp

@@ -38,11 +38,7 @@ void load_vpr_constraints_file(const char* read_vpr_constraints_name) {
     auto& routing_ctx = g_vpr_ctx.mutable_routing();
     routing_ctx.constraints = reader.constraints_.route_constraints();
 
-    // update vpr constraints for routing
-    auto& routing_ctx = g_vpr_ctx.mutable_routing();
-    routing_ctx.constraints = reader.constraints_;
-
-    VprConstraints ctx_constraints = floorplanning_ctx.constraints;
+    const auto& ctx_constraints = floorplanning_ctx.constraints;
 
     if (getEchoEnabled() && isEchoFileEnabled(E_ECHO_VPR_CONSTRAINTS)) {
         echo_constraints(getEchoFileName(E_ECHO_VPR_CONSTRAINTS), ctx_constraints);

vpr/src/base/vpr_constraints_writer.cpp

@@ -26,50 +26,6 @@
  */
 static Partition create_partition(const std::string& part_name, const Region& region);
 
-void write_vpr_constraints(t_vpr_setup& vpr_setup) {
-    auto& filename_opts = vpr_setup.FileNameOpts;
-    if (!filename_opts.write_vpr_constraints_file.empty()) {
-        std::string file_name = filename_opts.write_vpr_constraints_file;
-        if (vtr::check_file_name_extension(file_name.c_str(), ".xml")) {
-            VprConstraints constraints;
-
-            // update constraints with place info
-            // this is to align to original place/partion constraint behavior
-            const auto& placer_opts = vpr_setup.PlacerOpts;
-            int horizontal_partitions = placer_opts.floorplan_num_horizontal_partitions, vertical_partitions = placer_opts.floorplan_num_vertical_partitions;
-            if (horizontal_partitions != 0 && vertical_partitions != 0) {
-                setup_vpr_floorplan_constraints_cutpoints(constraints, horizontal_partitions, vertical_partitions);
-            } else {
-                setup_vpr_floorplan_constraints_one_loc(constraints, placer_opts.place_constraint_expand, placer_opts.place_constraint_subtile);
-            }
-
-            // update route constraints
-            for (int i = 0; i < g_vpr_ctx.routing().constraints.get_route_constraint_num(); i++) {
-                RouteConstraint rc = g_vpr_ctx.routing().constraints.get_route_constraint_by_idx(i);
-                // note: route constraints with regexpr in input constraint file
-                // is now replaced with the real net name and will not be written
-                // into output file
-                if (rc.is_valid()) {
-                    constraints.add_route_constraint(rc);
-                }
-            }
-
-            // VprConstraintsSerializer writer(g_vpr_ctx.routing().constraints);
-            VprConstraintsSerializer writer(constraints);
-            std::fstream fp;
-            fp.open(file_name.c_str(), std::fstream::out | std::fstream::trunc);
-            fp.precision(std::numeric_limits<float>::max_digits10);
-            void* context;
-            uxsd::write_vpr_constraints_xml(writer, context, fp);
-        } else {
-            VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
-                            "Unknown extension on output %s",
-                            file_name.c_str());
-        }
-    }
-    return;
-}
-
 void write_vpr_floorplan_constraints(const char* file_name, int expand, bool subtile, int horizontal_partitions, int vertical_partitions) {
     VprConstraints constraints;
     if (horizontal_partitions != 0 && vertical_partitions != 0) {
@@ -225,7 +181,7 @@ void setup_vpr_floorplan_constraints_cutpoints(VprConstraints& constraints,
             }
         }
 
-        Region current_reg(xminimum, yminimum, xmaximum, ymaximum, 0, n_layers - 1);
+        Region current_reg(xminimum, yminimum, xmaximum, ymaximum, 0, n_layers-1);
         // This function has not been tested for multi-layer grids. An assertion is used earlier to make sure that the grid has only one layer
 
         auto got = region_atoms.find(current_reg);

vpr/src/base/vpr_constraints_writer.h

@@ -35,14 +35,6 @@ class VprConstraints;
  */
 void write_vpr_constraints(t_vpr_setup& vpr_setup);
 
-/**
- * @brief Write out vpr constratins to an XML file based on current placement and 
- * route constraint settings
- * 
- *   @param vpr_setup   VPR setup information
- */
-void write_vpr_constraints(t_vpr_setup& vpr_setup);
-
 /**
  * @brief Write out floorplan constraints to an XML file based on current placement
  *

vpr/src/base/vpr_context.h

@@ -238,6 +238,13 @@ struct DeviceContext : public Context {
      */
     RRGraphView rr_graph{rr_graph_builder.rr_nodes(), rr_graph_builder.node_lookup(), rr_graph_builder.rr_node_metadata(), rr_graph_builder.rr_edge_metadata(), rr_indexed_data, rr_rc_data, rr_graph_builder.rr_segments(), rr_graph_builder.rr_switch(), rr_graph_builder.node_in_edge_storage(), rr_graph_builder.node_ptc_storage()};
 
+    /* Track ids for each rr_node in the rr_graph.
+     * This is used by drawer for tileable routing resource graph
+     */
+    std::map<RRNodeId, std::vector<size_t>> rr_node_track_ids;
+
+    std::vector<t_arch_switch_inf> arch_switch_inf; // [0..(num_arch_switches-1)]
+
     std::map<int, t_arch_switch_inf> all_sw_inf;
 
     int delayless_switch_idx = OPEN;

vpr/src/route/connection_router.cpp

@@ -573,7 +573,8 @@ void ConnectionRouter<Heap>::timing_driven_add_to_heap(const t_conn_cost_params&
     // When RCV is enabled, prune based on the RCV-specific total path cost (see
     // in `compute_node_cost_using_rcv` in `evaluate_timing_driven_node_costs`)
     // to allow detours to get better QoR.
-    if ((!rcv_path_manager.is_enabled() && best_back_cost > new_back_cost) || (rcv_path_manager.is_enabled() && best_total_cost > new_total_cost)) {
+    if ((!rcv_path_manager.is_enabled() && best_back_cost > new_back_cost) ||
+        (rcv_path_manager.is_enabled() && best_total_cost > new_total_cost)) {
         VTR_LOGV_DEBUG(router_debug_, "      Expanding to node %d (%s)\n", to_node,
                        describe_rr_node(device_ctx.rr_graph,
                                         device_ctx.grid,
@@ -789,12 +790,12 @@ void ConnectionRouter<Heap>::evaluate_timing_driven_node_costs(RTExploredNode* t
         //Update total cost
         float expected_cost = router_lookahead_.get_expected_cost(to->index, target_node, cost_params, to->R_upstream);
         VTR_LOGV_DEBUG(router_debug_ && !std::isfinite(expected_cost),
-                       "        Lookahead from %s (%s) to %s (%s) is non-finite, expected_cost = %f, to->R_upstream = %f\n",
-                       rr_node_arch_name(to->index, is_flat_).c_str(),
-                       describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, to->index, is_flat_).c_str(),
-                       rr_node_arch_name(target_node, is_flat_).c_str(),
-                       describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, target_node, is_flat_).c_str(),
-                       expected_cost, to->R_upstream);
+                        "        Lookahead from %s (%s) to %s (%s) is non-finite, expected_cost = %f, to->R_upstream = %f\n",
+                        rr_node_arch_name(to->index, is_flat_).c_str(),
+                        describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, to->index, is_flat_).c_str(),
+                        rr_node_arch_name(target_node, is_flat_).c_str(),
+                        describe_rr_node(device_ctx.rr_graph, device_ctx.grid, device_ctx.rr_indexed_data, target_node, is_flat_).c_str(),
+                        expected_cost, to->R_upstream);
         total_cost += to->backward_path_cost + cost_params.astar_fac * std::max(0.f, expected_cost - cost_params.astar_offset);
     }
     to->total_cost = total_cost;
@@ -1064,13 +1065,6 @@ static inline void update_router_stats(RouterStats* router_stats,
     VTR_ASSERT(node_type != NUM_RR_TYPES);
 
     /* TODO: Eliminate the use of global var here!!! */
-    const VibInf* vib;
-    if (!g_vpr_ctx.device().arch->vib_infs.empty()) {
-        vib = g_vpr_ctx.device().vib_grid.get_vib(rr_graph->node_layer(rr_node_id), rr_graph->node_xlow(rr_node_id), rr_graph->node_ylow(rr_node_id));
-    }
-    else {
-        vib = nullptr;
-    }
     if constexpr (VTR_ENABLE_DEBUG_LOGGING_CONST_EXPR) {
         if (is_inter_cluster_node(*rr_graph, rr_node_id)) {
             if (is_push) {

vpr/src/route/overuse_report.cpp

@@ -235,17 +235,8 @@ static void report_overused_ipin_opin(std::ostream& os,
         grid_x == rr_graph.node_xhigh(node_id) && grid_y == rr_graph.node_yhigh(node_id),
         "Non-track RR node should not span across multiple grid blocks.");
 
-    t_physical_tile_type_ptr physical_tile = device_ctx.grid.get_physical_type({grid_x, grid_y, grid_layer});
-    const VibInf* vib;
-    if (!device_ctx.arch->vib_infs.empty()) {
-        vib = device_ctx.vib_grid.get_vib(grid_layer, grid_x, grid_y);
-    }
-    else {
-        vib = nullptr;
-    }
-    //const t_vib_inf* vib = device_ctx.vib_grid[grid_layer][grid_x][grid_y];
     os << "Pin physical number = " << rr_graph.node_pin_num(node_id) << '\n';
-    if (is_inter_cluster_node(physical_tile, vib, rr_graph.node_type(node_id), rr_graph.node_ptc_num(node_id))) {
+    if (is_inter_cluster_node(rr_graph, node_id)) {
         os << "On Tile Pin"
            << "\n";
     } else {

vpr/src/route/router_lookahead_map.cpp

@@ -200,14 +200,6 @@ float MapLookahead::get_expected_cost_flat_router(RRNodeId current_node, RRNodeI
     t_physical_tile_type_ptr from_physical_type = device_ctx.grid.get_physical_type({rr_graph.node_xlow(current_node),
                                                                                      rr_graph.node_ylow(current_node),
                                                                                      rr_graph.node_layer(current_node)});
-    const VibInf* vib;
-    if (!device_ctx.arch->vib_infs.empty()) {
-        vib = device_ctx.vib_grid.get_vib(rr_graph.node_layer(current_node), rr_graph.node_xlow(current_node), rr_graph.node_ylow(current_node));
-    }
-    else {
-        vib = nullptr;
-    }
-    //const t_vib_inf* vib = device_ctx.vib_grid[rr_graph.node_layer(current_node)][rr_graph.node_xlow(current_node)][rr_graph.node_ylow(current_node)];
     int from_node_ptc_num = rr_graph.node_ptc_num(current_node);
     t_physical_tile_type_ptr to_physical_type = device_ctx.grid.get_physical_type({rr_graph.node_xlow(target_node),
                                                                                    rr_graph.node_ylow(target_node),