keep compatibility with old tbb

Author: duck2

vpr/src/base/ShowSetup.cpp

@@ -432,6 +432,9 @@ static void ShowRouterOpts(const t_router_opts& RouterOpts) {
 
         VTR_LOG("RouterOpts.router_algorithm: ");
         switch (RouterOpts.router_algorithm) {
+            case PARALLEL:
+                VTR_LOG("PARALLEL\n");
+                break;
             case TIMING_DRIVEN:
                 VTR_LOG("TIMING_DRIVEN\n");
                 break;

vpr/src/route/partition_tree.cpp

@@ -24,9 +24,10 @@ std::unique_ptr<PartitionTreeNode> PartitionTree::build_x(const Netlist<>& netli
     int score;
     /* TODO: maybe put all of this into a tuple or struct? */
     int best_score = std::numeric_limits<int>::max();
-    int best_pos, best_left, best_right;
+    int best_pos = -1, best_left = -1, best_right = -1;
     enum { X,
-           Y } best_axis;
+           Y } best_axis
+        = X;
 
     for (int x = x1 + 1; x < x2; x++) {
         left = right = mine = 0;

vpr/src/route/route_parallel.cpp

@@ -6,9 +6,9 @@
 #include <iostream>
 #include <tuple>
 
-#include "oneapi/tbb/enumerable_thread_specific.h"
-#include "oneapi/tbb/task_group.h"
-#include "oneapi/tbb/global_control.h"
+#include "tbb/enumerable_thread_specific.h"
+#include "tbb/task_group.h"
+#include "tbb/global_control.h"
 
 #include "binary_heap.h"
 #include "bucket.h"
@@ -33,14 +33,14 @@
 template<typename ConnectionRouter>
 class RouteIterCtx {
   public:
-    oneapi::tbb::enumerable_thread_specific<ConnectionRouter> routers;
+    tbb::enumerable_thread_specific<ConnectionRouter> routers;
     const Netlist<>& net_list;
     int itry;
     float pres_fac;
     const t_router_opts& router_opts;
     CBRR& connections_inf;
-    oneapi::tbb::enumerable_thread_specific<RouterStats> router_stats;
-    oneapi::tbb::enumerable_thread_specific<timing_driven_route_structs> route_structs;
+    tbb::enumerable_thread_specific<RouterStats> router_stats;
+    tbb::enumerable_thread_specific<timing_driven_route_structs> route_structs;
     NetPinsMatrix<float>& net_delay;
     const ClusteredPinAtomPinsLookup& netlist_pin_lookup;
     std::shared_ptr<SetupHoldTimingInfo> timing_info;
@@ -307,13 +307,13 @@ bool try_parallel_route_tmpl(const Netlist<>& net_list,
     float total_prep_time = t.elapsed_sec();
     VTR_LOG("# Built partition tree in %f seconds\n", total_prep_time);
 
-    oneapi::tbb::global_control c(oneapi::tbb::global_control::max_allowed_parallelism, max_workers);
-    oneapi::tbb::task_group tbb_task_group;
+    tbb::global_control c(tbb::global_control::max_allowed_parallelism, max_workers);
+    tbb::task_group tbb_task_group;
 
     /* Set up thread local storage.
      * tbb::enumerable_thread_specific will construct the elements as needed.
      * see https://spec.oneapi.io/versions/1.0-rev-3/elements/oneTBB/source/thread_local_storage/enumerable_thread_specific_cls/construct_destroy_copy.html */
-    auto routers = oneapi::tbb::enumerable_thread_specific<ConnectionRouter>(ConnectionRouter(
+    auto routers = tbb::enumerable_thread_specific<ConnectionRouter>(ConnectionRouter(
         device_ctx.grid,
         *router_lookahead,
         device_ctx.rr_graph.rr_nodes(),
@@ -322,8 +322,8 @@ bool try_parallel_route_tmpl(const Netlist<>& net_list,
         device_ctx.rr_graph.rr_switch(),
         route_ctx.rr_node_route_inf,
         is_flat)); /* Here we provide an "exemplar" to copy for each thread */
-    auto router_stats_thread = oneapi::tbb::enumerable_thread_specific<RouterStats>();
-    auto route_structs = oneapi::tbb::enumerable_thread_specific<timing_driven_route_structs>(net_list);
+    auto router_stats_thread = tbb::enumerable_thread_specific<RouterStats>();
+    auto route_structs = tbb::enumerable_thread_specific<timing_driven_route_structs>(net_list);
 
     RouterStats router_stats;
     float prev_iter_cumm_time = 0;
@@ -857,7 +857,7 @@ NetResultFlags try_parallel_route_net(ConnectionRouter& router,
 }
 
 template<typename ConnectionRouter>
-void route_partition_tree_x(oneapi::tbb::task_group& g,
+void route_partition_tree_x(tbb::task_group& g,
                             PartitionTreeNode& node,
                             RouteIterCtx<ConnectionRouter>& ctx,
                             vtr::linear_map<ParentNetId, int>& nets_to_retry) {
@@ -938,7 +938,7 @@ static void reduce_partition_tree_x(const PartitionTreeNode& node, RouteIterResu
 
 /** Route all nets in parallel using the partitioning information in the PartitionTree. */
 template<typename ConnectionRouter>
-RouteIterResults route_partition_tree(oneapi::tbb::task_group& g,
+RouteIterResults route_partition_tree(tbb::task_group& g,
                                       PartitionTree& tree,
                                       RouteIterCtx<ConnectionRouter>& ctx) {
     auto& device_ctx = g_vpr_ctx.device();

vpr/src/timing/timing_util.cpp

@@ -800,7 +800,7 @@ float calc_relaxed_criticality(const std::map<DomainPair, float>& domains_max_re
         VTR_ASSERT_SAFE_MSG(!std::isnan(crit), "Criticality not be nan");
         VTR_ASSERT_SAFE_MSG(std::isfinite(crit), "Criticality should not be infinite");
         VTR_ASSERT_MSG(crit >= 0. - CRITICALITY_ROUND_OFF_TOLERANCE, "Criticality should never be negative");
-        VTR_ASSERT_MSG(crit <= 1. + CRITICALITY_ROUND_OFF_TOLERANCE, "Criticality should never be greather than one");
+        VTR_ASSERT_MSG(crit <= 1. + CRITICALITY_ROUND_OFF_TOLERANCE, "Criticality should never be greater than one");
 
         //Clamp criticality to [0., 1.] to correct round-off
         crit = std::max(0.f, crit);
@@ -809,7 +809,7 @@ float calc_relaxed_criticality(const std::map<DomainPair, float>& domains_max_re
         max_crit = std::max(max_crit, crit);
     }
     VTR_ASSERT_MSG(max_crit >= 0., "Criticality should never be negative");
-    VTR_ASSERT_MSG(max_crit <= 1., "Criticality should never be greather than one");
+    VTR_ASSERT_MSG(max_crit <= 1., "Criticality should never be greater than one");
 
     return max_crit;
 }