Squashed 'libs/EXTERNAL/libtatum/' changes from 751112a2c..d68a6b3ec

d68a6b3ec Fix typo causing compilation error
cd5497e43 Improve comments in TimingAnalyzer
286b4cb0c Clean-up and improve commenting of incremental analyzers
aeb7a90d0 Ensure only SINK nodes are placed in the logical outputs
8142eb60a Avoid sorting by pre-emptively skipping duplicates during incremental update
84d945ba6 Move node tag invalidation from enqueue to node traversal
41c60027d Produce separate callgrind profiles for each incremental update
377507b08 Wrap edge slack calculation in TATUM_CALCULATE_EDGE_SLACKS define
ba0837132 Fix callgrind profiling configuration
72602d145 Add support for querying nodes modified by analzyer updates
f54d05349 Disable debug prints
3339f82d0 Ensure stale node slacks are invalidated during incremental update
e2ac16a42 Only dump dot for valid analyzers
1bd9e0447 Add support for checking only setup/hold/setuphold analysis from command line
cbb0ffbf7 Add missing slack verification checks
9925563de Fix TimingGraph::logical_outputs()
a4ce72ad5 Include missing header
1868b9470 Add missing incremental setup/hold analyzers
45cd38140 Add support for skipping clock edge invalidation during profiling (disabled)
54df64b18 Cleanup
1af66cd74 Fix processed level count
f95f26ee2 Reduce invalidation pessimism for clock network delay changes
6a21936a6 Further clean-up to profiling and measurement code for incremental analysis
1ee01d939 Add --edge_change_prob option to tatum_test
a9084fd3b Clean-up randomized profiling test
44907b473 Disable some debug code
cecbedf7e Ensure that SOURCE node's driven by clocks correctly have their tags invalidated
d8d44b6ff Fix handling of incremental updates to sinks
5bd072aaf Ignore generated files
4e785724f Include tag type in verification error messages
c31fc923d Add support for running with sanitizers (disabled)
bca158971 Fix uninitialized level range
9ddbc0d80 Fix verification of inf values
1a66299e5 Clean up compilation warnings
2c0622130 Add improved dominant edge-based incremental node invalidation
54b8ad8d8 Move incremental tag invalidation into separate enqueue functions
7d2f9c717 Remove commented code
ea7732497 Fix incremental analysis when dominant timing edge changes
8d4f374c7 Add support for modifying edge delays and verifying correctness of incremental analysis
133e98c40 Add missing file
119279170 Add missing comparison operator
d2d73e4bd Improve assertion handling of unused args
2dcedda50 Add support for profiling with randomly modified delays
7b371ab55 Initial implementation of level-based incremental update
03876efa6 Add reverse node-to-level lookup to TimingGraph
533771bc7 Add edge invalidation interface to TimingAnalyzer's and feed invalidations to GraphWalkers
08f21e3c2 Do not duplicate clocks tags during incremental analysis
e6dc3f204 Add support for TimingTags::set_tag() which adds or updates a tag unconditionally
38c5deae3 Fix incremental required time update
605ab74b3 Various fixes to main tester
6a5836171 Do not repeatedly add data tags during incremental update
11533d523 Move sinks to last level of levelization (easier for incremental required time update)
6ee5a8833 Avoid creating duplicate required times on sink nodes during incremental updates
a8bd7abd8 Initial incremental timing update support
0c320a75d Add initial SerialIncrWalker implementation and infrastructure
0657b5fdd Fix typo
78e9e9e2e Add failure message at end of executable
e3a946df8 Update node traversal functions to return whether they caused modifications
a997b7b90 Turn on test verification by default
bb3bd3142 Remove unused code

git-subtree-dir: libs/EXTERNAL/libtatum
git-subtree-split: d68a6b3ec5a66fae97136e6e3135d7b34520660e

Author: kmurray

.gitignore

@@ -47,3 +47,8 @@ callgrind*
 # Python temp files
 #
 *.pyc
+
+#Generated Tatum files
+*.rpt
+*.dot
+*.echo

CMakeLists.txt

@@ -20,9 +20,14 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
     #Only set compiler flags if not a sub-project
     set(WARN_FLAGS -Wall -Wextra -Wpedantic -Wcast-qual -Wcast-align -Wshadow -Wformat=2 -Wlogical-op -Wmissing-declarations -Wmissing-include-dirs -Wredundant-decls -Wswitch-default -Wundef -Wunused-variable -Wdisabled-optimization -Wnoexcept -Woverloaded-virtual -Wctor-dtor-privacy -Wnon-virtual-dtor)
 
+    set(SANITIZE_FLAGS  -fsanitize=address -fsanitize=leak -fsanitize=undefined)
+
     add_compile_options(${WARN_FLAGS})
     add_compile_options(-std=c++14)
 
+    #add_compile_options(${SANITIZE_FLAGS})
+    #link_libraries(${SANITIZE_FLAGS})
+
     set(FLEX_BISON_WARN_SUPPRESS_FLAGS -Wno-switch-default -Wno-unused-parameter -Wno-sign-compare -Wno-missing-declarations)
 endif()
 

libtatum/tatum/HoldAnalysis.hpp

@@ -65,7 +65,9 @@ class HoldAnalysis : public detail::CommonAnalysisVisitor<detail::HoldAnalysisOp
 
         TimingTags::tag_range hold_tags(const NodeId node) const { return ops_.get_tags(node); }
         TimingTags::tag_range hold_tags(const NodeId node, TagType type) const { return ops_.get_tags(node, type); }
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         TimingTags::tag_range hold_edge_slacks(const EdgeId edge) const { return ops_.get_edge_slacks(edge); }
+#endif
         TimingTags::tag_range hold_node_slacks(const NodeId node) const { return ops_.get_node_slacks(node); }
 };
 

libtatum/tatum/SetupAnalysis.hpp

@@ -132,7 +132,9 @@ class SetupAnalysis : public detail::CommonAnalysisVisitor<detail::SetupAnalysis
 
         TimingTags::tag_range setup_tags(const NodeId node) const { return ops_.get_tags(node); }
         TimingTags::tag_range setup_tags(const NodeId node, TagType type) const { return ops_.get_tags(node, type); }
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         TimingTags::tag_range setup_edge_slacks(const EdgeId edge) const { return ops_.get_edge_slacks(edge); }
+#endif
         TimingTags::tag_range setup_node_slacks(const NodeId node) const { return ops_.get_node_slacks(node); }
 };
 

libtatum/tatum/SetupHoldAnalysis.hpp

@@ -28,10 +28,38 @@ class SetupHoldAnalysis : public GraphVisitor {
             setup_visitor_.do_reset_node(node_id); 
             hold_visitor_.do_reset_node(node_id); 
         }
+
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         void do_reset_edge(const EdgeId edge_id) override { 
             setup_visitor_.do_reset_edge(edge_id); 
             hold_visitor_.do_reset_edge(edge_id); 
         }
+#endif
+
+        void do_reset_node_arrival_tags(const NodeId node_id) override { 
+            setup_visitor_.do_reset_node_arrival_tags(node_id); 
+            hold_visitor_.do_reset_node_arrival_tags(node_id); 
+        }
+
+        void do_reset_node_required_tags(const NodeId node_id) override { 
+            setup_visitor_.do_reset_node_required_tags(node_id); 
+            hold_visitor_.do_reset_node_required_tags(node_id); 
+        }
+
+        void do_reset_node_slack_tags(const NodeId node_id) override { 
+            setup_visitor_.do_reset_node_slack_tags(node_id); 
+            hold_visitor_.do_reset_node_slack_tags(node_id); 
+        }
+
+        void do_reset_node_arrival_tags_from_origin(const NodeId node_id, const NodeId origin) override { 
+            setup_visitor_.do_reset_node_arrival_tags_from_origin(node_id, origin); 
+            hold_visitor_.do_reset_node_arrival_tags_from_origin(node_id, origin); 
+        }
+
+        void do_reset_node_required_tags_from_origin(const NodeId node_id, const NodeId origin) override { 
+            setup_visitor_.do_reset_node_required_tags_from_origin(node_id, origin); 
+            hold_visitor_.do_reset_node_required_tags_from_origin(node_id, origin); 
+        }
 
         bool do_arrival_pre_traverse_node(const TimingGraph& tg, const TimingConstraints& tc, const NodeId node_id) override { 
             bool setup_unconstrained = setup_visitor_.do_arrival_pre_traverse_node(tg, tc, node_id); 
@@ -47,29 +75,39 @@ class SetupHoldAnalysis : public GraphVisitor {
             return setup_unconstrained || hold_unconstrained;
         }
 
-        void do_arrival_traverse_node(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, const NodeId node_id) override { 
-            setup_visitor_.do_arrival_traverse_node(tg, tc, dc, node_id); 
-            hold_visitor_.do_arrival_traverse_node(tg, tc, dc, node_id); 
+        bool do_arrival_traverse_node(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, const NodeId node_id) override { 
+            bool setup_modified = setup_visitor_.do_arrival_traverse_node(tg, tc, dc, node_id); 
+            bool hold_modified = hold_visitor_.do_arrival_traverse_node(tg, tc, dc, node_id); 
+
+            return setup_modified || hold_modified;
         }
 
-        void do_required_traverse_node(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, const NodeId node_id) override { 
-            setup_visitor_.do_required_traverse_node(tg, tc, dc, node_id); 
-            hold_visitor_.do_required_traverse_node(tg, tc, dc, node_id); 
+        bool do_required_traverse_node(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, const NodeId node_id) override { 
+            bool setup_modified = setup_visitor_.do_required_traverse_node(tg, tc, dc, node_id); 
+            bool hold_modified = hold_visitor_.do_required_traverse_node(tg, tc, dc, node_id); 
+
+            return setup_modified || hold_modified;
         }
 
-        void do_slack_traverse_node(const TimingGraph& tg, const DelayCalculator& dc, const NodeId node) override {
-            setup_visitor_.do_slack_traverse_node(tg, dc, node); 
-            hold_visitor_.do_slack_traverse_node(tg, dc, node); 
+        bool do_slack_traverse_node(const TimingGraph& tg, const DelayCalculator& dc, const NodeId node) override {
+            bool setup_modified = setup_visitor_.do_slack_traverse_node(tg, dc, node); 
+            bool hold_modified = hold_visitor_.do_slack_traverse_node(tg, dc, node); 
+
+            return setup_modified || hold_modified;
         }
 
         TimingTags::tag_range setup_tags(const NodeId node_id) const { return setup_visitor_.setup_tags(node_id); }
         TimingTags::tag_range setup_tags(const NodeId node_id, TagType type) const { return setup_visitor_.setup_tags(node_id, type); }
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         TimingTags::tag_range setup_edge_slacks(const EdgeId edge_id) const { return setup_visitor_.setup_edge_slacks(edge_id); }
+#endif
         TimingTags::tag_range setup_node_slacks(const NodeId node_id) const { return setup_visitor_.setup_node_slacks(node_id); }
 
         TimingTags::tag_range hold_tags(const NodeId node_id) const { return hold_visitor_.hold_tags(node_id); }
         TimingTags::tag_range hold_tags(const NodeId node_id, TagType type) const { return hold_visitor_.hold_tags(node_id, type); }
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         TimingTags::tag_range hold_edge_slacks(const EdgeId edge_id) const { return hold_visitor_.hold_edge_slacks(edge_id); }
+#endif
         TimingTags::tag_range hold_node_slacks(const NodeId node_id) const { return hold_visitor_.hold_node_slacks(node_id); }
 
         SetupAnalysis& setup_visitor() { return setup_visitor_; }

libtatum/tatum/TimingGraph.cpp

@@ -167,6 +167,13 @@ EdgeId TimingGraph::node_clock_launch_edge(const NodeId node) const {
     return EdgeId::INVALID();
 }
 
+LevelId TimingGraph::node_level(const NodeId node) const {
+    if (!is_levelized_) {
+        return LevelId::INVALID();
+    }
+    return node_levels_[node];
+}
+
 
 NodeId TimingGraph::add_node(const NodeType type) {
     //Invalidate the levelization
@@ -329,6 +336,7 @@ void TimingGraph::force_levelize() {
     //Clear any previous levelization
     level_nodes_.clear();
     level_ids_.clear();
+    node_levels_.clear();
     primary_inputs_.clear();
     logical_outputs_.clear();
 
@@ -356,7 +364,7 @@ void TimingGraph::force_levelize() {
             if (node_type(node_id) == NodeType::SOURCE) {
                 //We require that all primary inputs (i.e. top-level circuit inputs) to
                 //be SOURCEs. Due to disconnected nodes we may have non-SOURCEs which 
-                //appear in the first level.
+                //otherwise appear in the first level.
                 primary_inputs_.push_back(node_id);
             }
         }
@@ -371,6 +379,8 @@ void TimingGraph::force_levelize() {
     int level_idx = 0;
     level_ids_.emplace_back(level_idx);
 
+    std::vector<NodeId> last_level;
+
     bool inserted_node_in_level = true;
     while(inserted_node_in_level) { //If nothing was inserted we are finished
         inserted_node_in_level = false;
@@ -388,26 +398,29 @@ void TimingGraph::force_levelize() {
 
                 //Add to the next level if all fanin has been seen
                 if(node_fanin_remaining[size_t(sink_node)] == 0) {
-                    //Ensure there is space by allocating the next level if required
-                    level_nodes_.resize(level_idx+2);
 
-                    //Add the node
-                    level_nodes_[LevelId(level_idx+1)].push_back(sink_node);
-
-                    inserted_node_in_level = true;
+                    if (node_out_edges(sink_node).size() != 0) {
+                        //Place into next level
+                        
+                        //Ensure there is space by allocating the next level if required
+                        level_nodes_.resize(level_idx+2);
+
+                        //Add the node
+                        level_nodes_[LevelId(level_idx+1)].push_back(sink_node);
+
+                        inserted_node_in_level = true;
+                    } else {
+                        //No fan-out
+                        //
+                        //We choose to put these nodes into the *last* level,
+                        //since it makes it easier to walk back from them in the
+                        //required time traversal
+                        TATUM_ASSERT(node_out_edges(sink_node).size() == 0);
+                        
+                        last_level.push_back(sink_node);
+                    }
                 }
             }
-
-            //Also track the primary outputs (those with fan-in AND no fan-out)
-            //
-            // There may be some node with neither any fan-in or fan-out. 
-            // We will treat them as primary inputs, so they should not be to
-            // the primary outputs
-            if(   node_out_edges(node_id).size() == 0 
-               && node_in_edges(node_id).size() != 0
-               && node_type(node_id) == NodeType::SINK) {
-                logical_outputs_.push_back(node_id);
-            }
         }
 
         if(inserted_node_in_level) {
@@ -416,6 +429,27 @@ void TimingGraph::force_levelize() {
         }
     }
 
+    //Add the last level to the end of the levelization
+    level_nodes_.emplace_back(last_level);
+    level_idx++;
+    level_ids_.emplace_back(level_idx);
+
+    //Add SINK type nodes in the last level to logical outputs
+    //Note that we only do this for sinks, since non-sink nodes may end up
+    //in the last level (e.g. due to breaking combinational loops)
+    auto is_sink = [this](NodeId id) {
+        return this->node_type(id) == NodeType::SINK;
+    };
+    std::copy_if(last_level.begin(), last_level.end(), std::back_inserter(logical_outputs_), is_sink);
+
+    //Build the reverse node-to-level look-up
+    node_levels_.resize(nodes().size());
+    for (LevelId level : level_ids_) {
+        for(NodeId node : level_nodes_[level]) {
+            node_levels_[node] = level;
+        }
+    }
+
     //Mark the levelization as valid
     is_levelized_ = true;
 }
@@ -562,7 +596,8 @@ bool TimingGraph::valid_level_id(const LevelId level_id) const {
 bool TimingGraph::validate_sizes() const {
     if (   node_ids_.size() != node_types_.size()
         || node_ids_.size() != node_in_edges_.size()
-        || node_ids_.size() != node_out_edges_.size()) {
+        || node_ids_.size() != node_out_edges_.size()
+        || node_ids_.size() != node_levels_.size()) {
         throw tatum::Error("Inconsistent node attribute sizes");
     }
 
@@ -794,6 +829,15 @@ bool TimingGraph::validate_structure() const {
         }
     }
 
+    //Check levelization look-up is consistent with levelization
+    for (LevelId level : levels()) {
+        for(NodeId node : level_nodes(level)) {
+            if (node_level(node) != level) {
+                throw tatum::Error("Node level look-up does not match levelization", node);
+            }
+        }
+    }
+
     auto sccs = identify_combinational_loops(*this);
     if(!sccs.empty()) {
         throw Error("Timing graph contains active combinational loops. "

libtatum/tatum/TimingGraph.hpp

@@ -104,6 +104,10 @@ class TimingGraph {
         ///\returns The edge id corresponding to the incoming clock launch edge, or EdgeId::INVALID() if none
         EdgeId node_clock_launch_edge(const NodeId id) const;
 
+        ///\param id The node id
+        ///\returns The level id corresponding to specified node
+        LevelId node_level(const NodeId id) const;
+
         /*
          * Edge accessors
          */
@@ -280,6 +284,7 @@ class TimingGraph {
         tatum::util::linear_map<NodeId,NodeType> node_types_; //Type of node
         tatum::util::linear_map<NodeId,std::vector<EdgeId>> node_in_edges_; //Incomiing edge IDs for node
         tatum::util::linear_map<NodeId,std::vector<EdgeId>> node_out_edges_; //Out going edge IDs for node
+        tatum::util::linear_map<NodeId,LevelId> node_levels_; //Out going edge IDs for node
 
         //Edge data
         tatum::util::linear_map<EdgeId,EdgeId> edge_ids_; //The edge IDs in the graph

libtatum/tatum/analyzer_factory.hpp

@@ -10,6 +10,7 @@
 #include "tatum/graph_walkers.hpp"
 #include "tatum/timing_analyzers.hpp"
 #include "tatum/analyzers/full_timing_analyzers.hpp"
+#include "tatum/analyzers/incr_timing_analyzers.hpp"
 
 namespace tatum {
 
@@ -129,6 +130,52 @@ struct AnalyzerFactory<SetupHoldAnalysis,GraphWalker> {
     }
 };
 
+
+//Specialize for incremental setup
+template<>
+struct AnalyzerFactory<SetupAnalysis,SerialIncrWalker> {
+
+    static std::unique_ptr<SetupTimingAnalyzer> make(const TimingGraph& timing_graph,
+                                                         const TimingConstraints& timing_constraints,
+                                                         const DelayCalculator& delay_calc) {
+        return std::unique_ptr<SetupTimingAnalyzer>(
+                new detail::IncrSetupTimingAnalyzer<SerialIncrWalker>(timing_graph, 
+                                                                      timing_constraints, 
+                                                                      delay_calc)
+                );
+    }
+};
+
+//Specialize for incremental hold
+template<>
+struct AnalyzerFactory<HoldAnalysis,SerialIncrWalker> {
+
+    static std::unique_ptr<HoldTimingAnalyzer> make(const TimingGraph& timing_graph,
+                                                         const TimingConstraints& timing_constraints,
+                                                         const DelayCalculator& delay_calc) {
+        return std::unique_ptr<HoldTimingAnalyzer>(
+                new detail::IncrHoldTimingAnalyzer<SerialIncrWalker>(timing_graph, 
+                                                                     timing_constraints, 
+                                                                     delay_calc)
+                );
+    }
+};
+
+//Specialize for combined incremental setup and hold
+template<>
+struct AnalyzerFactory<SetupHoldAnalysis,SerialIncrWalker> {
+
+    static std::unique_ptr<SetupHoldTimingAnalyzer> make(const TimingGraph& timing_graph,
+                                                         const TimingConstraints& timing_constraints,
+                                                         const DelayCalculator& delay_calc) {
+        return std::unique_ptr<SetupHoldTimingAnalyzer>(
+                new detail::IncrSetupHoldTimingAnalyzer<SerialIncrWalker>(timing_graph, 
+                                                                          timing_constraints, 
+                                                                          delay_calc)
+                );
+    }
+};
+
 } //namepsace
 
 #endif

libtatum/tatum/analyzers/FullHoldTimingAnalyzer.hpp

@@ -57,13 +57,23 @@ class FullHoldTimingAnalyzer : public HoldTimingAnalyzer {
             graph_walker_.set_profiling_data("num_full_updates", graph_walker_.get_profiling_data("num_full_updates") + 1);
         }
 
+        virtual void invalidate_edge_impl(const EdgeId edge) override {
+            graph_walker_.invalidate_edge(edge);
+        }
+
+        virtual node_range modified_nodes_impl() const override {
+            return graph_walker_.modified_nodes();
+        }
+
         double get_profiling_data_impl(std::string key) const override { return graph_walker_.get_profiling_data(key); }
         size_t num_unconstrained_startpoints_impl() const override { return graph_walker_.num_unconstrained_startpoints(); }
         size_t num_unconstrained_endpoints_impl() const override { return graph_walker_.num_unconstrained_endpoints(); }
 
         TimingTags::tag_range hold_tags_impl(NodeId node_id) const override { return hold_visitor_.hold_tags(node_id); }
         TimingTags::tag_range hold_tags_impl(NodeId node_id, TagType type) const override { return hold_visitor_.hold_tags(node_id, type); }
+#ifdef TATUM_CALCULATE_EDGE_SLACKS
         TimingTags::tag_range hold_edge_slacks_impl(EdgeId edge_id) const override { return hold_visitor_.hold_edge_slacks(edge_id); }
+#endif
         TimingTags::tag_range hold_node_slacks_impl(NodeId node_id) const override { return hold_visitor_.hold_node_slacks(node_id); }
 
     private: