Syncing libtatum with VTR

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.9)
+cmake_minimum_required(VERSION 3.16)
 
 project("tatum")
 

libtatum/CMakeLists.txt

@@ -76,7 +76,7 @@ if (TATUM_USE_EXECUTION_ENGINE STREQUAL "tbb")
 
     target_compile_definitions(libtatum PUBLIC TATUM_USE_TBB)
     target_link_libraries(libtatum tbb)
-    target_link_libraries(libtatum tbbmalloc_proxy) #Use the scalable memory allocator
+    target_link_libraries(libtatum ${TBB_tbbmalloc_proxy_LIBRARY}) #Use the scalable memory allocator
 
 elseif (TATUM_USE_EXECUTION_ENGINE STREQUAL "serial")
     #Nothing to do

libtatum/tatum/TimingReporter.cpp

@@ -99,6 +99,15 @@ void TimingReporter::report_timing_setup(std::ostream& os,
     report_timing(os, paths);
 }
 
+void TimingReporter::report_timing_setup(std::vector<tatum::TimingPath>& paths,
+                                         std::ostream& os,
+                                         const SetupTimingAnalyzer& setup_analyzer,
+                                         size_t npaths) const {
+    paths = path_collector_.collect_worst_setup_timing_paths(timing_graph_, setup_analyzer, npaths);
+
+    report_timing(os, paths);
+}
+
 void TimingReporter::report_timing_hold(std::string filename, 
                                          const HoldTimingAnalyzer& hold_analyzer,
                                          size_t npaths) const {
@@ -114,6 +123,15 @@ void TimingReporter::report_timing_hold(std::ostream& os,
     report_timing(os, paths);
 }
 
+void TimingReporter::report_timing_hold(std::vector<tatum::TimingPath>& paths,
+                                         std::ostream& os,
+                                         const HoldTimingAnalyzer& hold_analyzer,
+                                         size_t npaths) const {
+    paths = path_collector_.collect_worst_hold_timing_paths(timing_graph_, hold_analyzer, npaths);
+
+    report_timing(os, paths);
+}
+
 void TimingReporter::report_skew_setup(std::string filename, 
                                          const SetupTimingAnalyzer& setup_analyzer,
                                          size_t nworst) const {

libtatum/tatum/TimingReporter.hpp

@@ -64,9 +64,11 @@ class TimingReporter {
     public:
         void report_timing_setup(std::string filename, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_timing_setup(std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
+        void report_timing_setup(std::vector<tatum::TimingPath>& paths, std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
 
         void report_timing_hold(std::string filename, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_timing_hold(std::ostream& os, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
+        void report_timing_hold(std::vector<tatum::TimingPath>& paths, std::ostream& os, const tatum::HoldTimingAnalyzer& hold_analyzer, size_t npaths=REPORT_TIMING_DEFAULT_NPATHS) const;
 
         void report_skew_setup(std::string filename, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t nworst=REPORT_TIMING_DEFAULT_NPATHS) const;
         void report_skew_setup(std::ostream& os, const tatum::SetupTimingAnalyzer& setup_analyzer, size_t nworst=REPORT_TIMING_DEFAULT_NPATHS) const;

libtatum/tatum/graph_walkers/SerialIncrWalker.hpp

@@ -1,5 +1,10 @@
 #pragma once
 #include <algorithm>
+
+#ifdef TATUM_USE_TBB
+#include <tbb/concurrent_vector.h>
+#endif
+
 #include "tatum/graph_walkers/TimingGraphWalker.hpp"
 #include "tatum/TimingGraph.hpp"
 #include "tatum/delay_calc/DelayCalculator.hpp"
@@ -431,9 +436,16 @@ class SerialIncrWalker : public TimingGraphWalker {
         t_incr_traversal_update incr_arr_update_;
         t_incr_traversal_update incr_req_update_;
 
-        //Set of invalidated edges, and bitset for membership
+        /** Set of invalidated edges, and bitset for membership.
+         * Use thread safe alternatives when TBB is on, since invalidate_edge_impl
+         * may be called concurrently */
+#ifdef TATUM_USE_TBB
+        tbb::concurrent_vector<EdgeId> invalidated_edges_;
+        tatum::util::linear_map<EdgeId, size_t> edge_invalidated_;
+#else
         std::vector<EdgeId> invalidated_edges_;
-        tatum::util::linear_map<EdgeId,bool> edge_invalidated_;
+        tatum::util::linear_map<EdgeId, bool> edge_invalidated_;
+#endif
 
         //Nodes which have been modified during timing update, and bitset for membership
         std::vector<NodeId> nodes_modified_;