Squashed 'libs/EXTERNAL/libtatum/' changes from ef121c8..f15f474

kmurray · kmurray · commit d14e705347a0 · 2018-08-31T13:33:43.000-04:00
f15f474 Include Node and Edge IDs when throwing exceptions
3ef0e61 Report time spent re-ordering timing graph
4d4246c Add option to disable reporting
1fff3be Disable dumping .dot file by default
71d8f91 Add VTR multi-clock test case with non-default constraints

git-subtree-dir: libs/EXTERNAL/libtatum
git-subtree-split: f15f47439ba0f726dfd1a9e89361ff4ddc5302f3
diff --git a/libtatum/tatum/TimingGraph.cpp b/libtatum/tatum/TimingGraph.cpp
@@ -575,39 +575,42 @@ bool TimingGraph::validate_values() const {
 
     for(NodeId node_id : nodes()) {
         if(!valid_node_id(node_id)) {
-            throw tatum::Error("Invalid node id");
+            throw tatum::Error("Invalid node id", node_id);
         }
 
         for(EdgeId edge_id : node_in_edges_[node_id]) {
             if(!valid_edge_id(edge_id)) {
-                throw tatum::Error("Invalid node-in-edge reference");
+                throw tatum::Error("Invalid node-in-edge reference", node_id, edge_id);
             }
 
             //Check that the references are consistent
             if(edge_sink_nodes_[edge_id] != node_id) {
-                throw tatum::Error("Mismatched edge-sink/node-in-edge reference");
+                throw tatum::Error("Mismatched edge-sink/node-in-edge reference", node_id, edge_id);
             }
         }
         for(EdgeId edge_id : node_out_edges_[node_id]) {
             if(!valid_edge_id(edge_id)) {
-                throw tatum::Error("Invalid node-out-edge reference");
+                throw tatum::Error("Invalid node-out-edge reference", node_id, edge_id);
             }
 
             //Check that the references are consistent
             if(edge_src_nodes_[edge_id] != node_id) {
-                throw tatum::Error("Mismatched edge-src/node-out-edge reference");
+                throw tatum::Error("Mismatched edge-src/node-out-edge reference", node_id, edge_id);
             }
         }
     }
     for(EdgeId edge_id : edges()) {
         if(!valid_edge_id(edge_id)) {
-            throw tatum::Error("Invalid edge id");
+            throw tatum::Error("Invalid edge id", edge_id);
         }
-        if(!valid_node_id(edge_src_nodes_[edge_id])) {
-            throw tatum::Error("Invalid edge source node");
+        NodeId src_node = edge_src_nodes_[edge_id];
+        if(!valid_node_id(src_node)) {
+            throw tatum::Error("Invalid edge source node", src_node, edge_id);
         }
-        if(!valid_node_id(edge_sink_nodes_[edge_id])) {
-            throw tatum::Error("Invalid edge sink node");
+
+        NodeId sink_node = edge_sink_nodes_[edge_id];
+        if(!valid_node_id(sink_node)) {
+            throw tatum::Error("Invalid edge sink node", sink_node, edge_id);
         }
     }
 
@@ -633,29 +636,29 @@ bool TimingGraph::validate_structure() const {
         //Check expected number of fan-in/fan-out edges
         if(src_type == NodeType::SOURCE) {
             if(in_edges.size() > 1) {
-                throw tatum::Error("SOURCE node has more than one active incoming edge (expected 0 if primary input, or 1 if clocked)");
+                throw tatum::Error("SOURCE node has more than one active incoming edge (expected 0 if primary input, or 1 if clocked)", src_node);
             }
         } else if (src_type == NodeType::SINK) {
             if(out_edges.size() > 0) {
-                throw tatum::Error("SINK node has out-going edges");
+                throw tatum::Error("SINK node has out-going edges", src_node);
             }
         } else if (src_type == NodeType::IPIN) {
             if(in_edges.size() == 0 && !allow_dangling_combinational_nodes_) {
-                throw tatum::Error("IPIN has no in-coming edges");
+                throw tatum::Error("IPIN has no in-coming edges", src_node);
             }
             if(out_edges.size() == 0 && !allow_dangling_combinational_nodes_) {
-                throw tatum::Error("IPIN has no out-going edges");
+                throw tatum::Error("IPIN has no out-going edges", src_node);
             }
         } else if (src_type == NodeType::OPIN) {
             //May have no incoming edges if a constant generator, so don't check that case
 
             if(out_edges.size() == 0 && !allow_dangling_combinational_nodes_) {
-                throw tatum::Error("OPIN has no out-going edges");
+                throw tatum::Error("OPIN has no out-going edges", src_node);
             }
         } else {
             TATUM_ASSERT(src_type == NodeType::CPIN);
             if(in_edges.size() == 0) {
-                throw tatum::Error("CPIN has no in-coming edges");
+                throw tatum::Error("CPIN has no in-coming edges", src_node);
             }
             //We do not check for out-going cpin edges, since there is no reason that
             //a clock pin must be used
@@ -675,61 +678,61 @@ bool TimingGraph::validate_structure() const {
                    && sink_type != NodeType::OPIN
                    && sink_type != NodeType::CPIN
                    && sink_type != NodeType::SINK) {
-                    throw tatum::Error("SOURCE nodes should only drive IPIN, OPIN, CPIN or SINK nodes");
+                    throw tatum::Error("SOURCE nodes should only drive IPIN, OPIN, CPIN or SINK nodes", src_node, out_edge);
                 }
 
                 if(sink_type == NodeType::SINK) {
                     if(   out_edge_type != EdgeType::INTERCONNECT
                        && out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {
-                        throw tatum::Error("SOURCE to SINK edges should always be either INTERCONNECT or PRIMTIIVE_COMBINATIONAL type edges");
+                        throw tatum::Error("SOURCE to SINK edges should always be either INTERCONNECT or PRIMTIIVE_COMBINATIONAL type edges", src_node, out_edge);
                     }
                     
                 } else if (sink_type == NodeType::OPIN) {
                     if(out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {
-                        throw tatum::Error("SOURCE to OPIN edges should always be PRIMITIVE_COMBINATIONAL type edges");
+                        throw tatum::Error("SOURCE to OPIN edges should always be PRIMITIVE_COMBINATIONAL type edges", src_node, out_edge);
                     }
                 } else {
                     TATUM_ASSERT(sink_type == NodeType::IPIN || sink_type == NodeType::CPIN);
                     if(out_edge_type != EdgeType::INTERCONNECT) {
-                        throw tatum::Error("SOURCE to IPIN/CPIN edges should always be INTERCONNECT type edges");
+                        throw tatum::Error("SOURCE to IPIN/CPIN edges should always be INTERCONNECT type edges", src_node, out_edge);
                     }
                 }
 
             } else if (src_type == NodeType::SINK) {
-                throw tatum::Error("SINK nodes should not have out-going edges");
+                throw tatum::Error("SINK nodes should not have out-going edges", sink_node);
             } else if (src_type == NodeType::IPIN) {
                 if(sink_type != NodeType::OPIN && sink_type != NodeType::SINK) {
-                    throw tatum::Error("IPIN nodes should only drive OPIN or SINK nodes");
+                    throw tatum::Error("IPIN nodes should only drive OPIN or SINK nodes", src_node, out_edge);
                 }
 
                 if(out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {
-                    throw tatum::Error("IPIN to OPIN/SINK edges should always be PRIMITIVE_COMBINATIONAL type edges");
+                    throw tatum::Error("IPIN to OPIN/SINK edges should always be PRIMITIVE_COMBINATIONAL type edges", src_node, out_edge);
                 }
 
             } else if (src_type == NodeType::OPIN) {
                 if(   sink_type != NodeType::IPIN
                    && sink_type != NodeType::CPIN
                    && sink_type != NodeType::SINK) {
-                    throw tatum::Error("OPIN nodes should only drive IPIN, CPIN or SINK nodes");
+                    throw tatum::Error("OPIN nodes should only drive IPIN, CPIN or SINK nodes", src_node, out_edge);
                 }
 
                 if(out_edge_type != EdgeType::INTERCONNECT) {
-                    throw tatum::Error("OPIN out edges should always be INTERCONNECT type edges");
+                    throw tatum::Error("OPIN out edges should always be INTERCONNECT type edges", src_node, out_edge);
                 }
 
             } else if (src_type == NodeType::CPIN) {
                 if(   sink_type != NodeType::SOURCE
                    && sink_type != NodeType::SINK) {
-                    throw tatum::Error("CPIN nodes should only drive SOURCE or SINK nodes");
+                    throw tatum::Error("CPIN nodes should only drive SOURCE or SINK nodes", src_node, out_edge);
                 }
 
                 if(sink_type == NodeType::SOURCE && out_edge_type != EdgeType::PRIMITIVE_CLOCK_LAUNCH) {
-                    throw tatum::Error("CPIN to SOURCE edges should always be PRIMITIVE_CLOCK_LAUNCH type edges");
+                    throw tatum::Error("CPIN to SOURCE edges should always be PRIMITIVE_CLOCK_LAUNCH type edges", src_node, out_edge);
                 } else if (sink_type == NodeType::SINK && out_edge_type != EdgeType::PRIMITIVE_CLOCK_CAPTURE) {
-                    throw tatum::Error("CPIN to SINK edges should always be PRIMITIVE_CLOCK_CAPTURE type edges");
+                    throw tatum::Error("CPIN to SINK edges should always be PRIMITIVE_CLOCK_CAPTURE type edges", src_node, out_edge);
                 }
             } else {
-                throw tatum::Error("Unrecognized node type");
+                throw tatum::Error("Unrecognized node type", src_node, out_edge);
             }
         }
     }
@@ -757,27 +760,27 @@ bool TimingGraph::validate_structure() const {
             for(EdgeId edge : edge_ids) {
                 ss << edge << " ";
             }
-            throw tatum::Error(ss.str());
+            throw tatum::Error(ss.str(), src_node);
         }
     }
 
     for(NodeId node : primary_inputs()) {
         if(!node_in_edges(node).empty()) {
-            throw tatum::Error("Primary input nodes should have no incoming edges");
+            throw tatum::Error("Primary input nodes should have no incoming edges", node);
         }
 
         if(node_type(node) != NodeType::SOURCE) {
-            throw tatum::Error("Primary inputs should be only SOURCE nodes");
+            throw tatum::Error("Primary inputs should be only SOURCE nodes", node);
         }
     }
 
     for(NodeId node : logical_outputs()) {
         if(!node_out_edges(node).empty()) {
-            throw tatum::Error("Logical output node should have no outgoing edges");
+            throw tatum::Error("Logical output node should have no outgoing edges", node);
         }
 
         if(node_type(node) != NodeType::SINK) {
-            throw tatum::Error("Logical outputs should be only SINK nodes");
+            throw tatum::Error("Logical outputs should be only SINK nodes", node);
         }
     }
 
@@ -912,10 +915,10 @@ EdgeType infer_edge_type(const TimingGraph& tg, EdgeId edge) {
         } else if(sink_node_type == NodeType::SINK) {
             return EdgeType::PRIMITIVE_CLOCK_CAPTURE;
         } else {
-            throw tatum::Error("Invalid edge sink node (CPIN source node must connect to SOURCE or SINK sink node)");
+            throw tatum::Error("Invalid edge sink node (CPIN source node must connect to SOURCE or SINK sink node)", sink_node, edge);
         }
     } else {
-        throw tatum::Error("Invalid edge sink/source nodes");
+        throw tatum::Error("Invalid edge sink/source nodes", edge);
     }
 }
 
diff --git a/libtatum/tatum/base/validate_timing_graph_constraints.cpp b/libtatum/tatum/base/validate_timing_graph_constraints.cpp
@@ -19,7 +19,7 @@ bool validate_timing_graph_constraints(const TimingGraph& timing_graph, const Ti
                 msg = "Clock Domain " + std::to_string(size_t(domain)) + " (" + timing_constraints.clock_domain_name(domain) + ")"
                       " source node " + std::to_string(size_t(source_node)) + " is not a node of type SOURCE.";
 
-                throw tatum::Error(msg);
+                throw tatum::Error(msg, source_node);
             }
         }
     }
@@ -32,7 +32,7 @@ bool validate_timing_graph_constraints(const TimingGraph& timing_graph, const Ti
 
                 msg = "Timing Graph node " + std::to_string(size_t(node)) + " is an OPIN with no incoming edges, but is not marked as a constant generator";
 
-                throw tatum::Error(msg);
+                throw tatum::Error(msg, node);
             }
         }
     }
diff --git a/libtatum/tatum/error.hpp b/libtatum/tatum/error.hpp
@@ -2,14 +2,34 @@
 #define TATUM_ERROR_HPP
 #include <stdexcept>
 
+#include "tatum/TimingGraphFwd.hpp"
+
 namespace tatum {
 class Error : public std::runtime_error {
 
     public:
-        template<typename ...Args>
-        explicit Error(Args&&... args)
-            : std::runtime_error(std::forward<Args>(args)...) {}
+        //String only
+        explicit Error(const std::string& what_str)
+            : std::runtime_error(what_str) {}
+
+        //String and node
+        explicit Error(const std::string& what_str, const NodeId n)
+            : std::runtime_error(what_str)
+            , node(n) {}
+
+        //String and edge
+        explicit Error(const std::string& what_str, const EdgeId e)
+            : std::runtime_error(what_str)
+            , edge(e) {}
+
+        //String, node and edge
+        explicit Error(const std::string& what_str, const NodeId n, const EdgeId e)
+            : std::runtime_error(what_str)
+            , node(n)
+            , edge(e) {}
 
+        NodeId node; //The related node, may be invalid if unspecified
+        EdgeId edge; //The related edge, may be invalid if unspecified
 };
 
 }
diff --git a/tatum_test/main.cpp b/tatum_test/main.cpp
@@ -80,6 +80,9 @@ struct Args {
     //Verify results match reference
     size_t verify = 0;
 
+    //Print reports
+    size_t report = 1;
+
     //Timing graph node whose transitive fanout is included in the 
     //dumped .dot file (useful for debugging). Values < 0 dump the
     //entire graph.
@@ -113,23 +116,27 @@ void usage(std::string prog) {
     cout << "                                      0 uses delay model from input.\n";
     cout << "                                      (default " << default_args.unit_delay << ")\n";
     cout << "    --write_echo WRITE_ECHO:          Write an echo file of restuls.\n";
-    cout << "                                      0 implies no, non-zero implies yes.\n";
+    cout << "                                      empty implies no, non-empty implies write to specified file.\n";
     cout << "                                      (default " << default_args.write_echo << ")\n";
     cout << "    --opt_graph_layout OPT_LAYOUT:    Optimize graph layout.\n";
     cout << "                                      0 implies no, non-zero implies yes.\n";
     cout << "                                      (default " << default_args.opt_graph_layout << ")\n";
     cout << "    --print_sizes PRINT_SIZES:        Print various data structure sizes.\n";
     cout << "                                      0 implies no, non-zero implies yes.\n";
     cout << "                                      (default " << default_args.print_sizes << ")\n";
+    cout << "    --report REPORT:                  Generate various reports.\n";
+    cout << "                                      0 implies no, non-zero implies yes.\n";
+    cout << "                                      (default " << default_args.report << ")\n";
     cout << "    --verify VERIFY:                  Verify calculated results match reference.\n";
     cout << "                                      0 implies no, non-zero implies yes.\n";
     cout << "                                      (default " << default_args.verify << ")\n";
     cout << "    --debug_dot_node NODEID:          Specifies the timing graph node node whose transitive\n";
     cout << "                                      connections are dumped to the .dot file (useful for debugging).\n";
-    cout << "                                      Values < 0 dump the entire graph,\n";
+    cout << "                                      Values < -1 dump the entire graph,\n";
+    cout << "                                      Values == -1 do not dump dot file,\n";
     cout << "                                      Values >= 0 dump the transitive connections of\n";
     cout << "                                      the matching node.\n";
-    cout << "                                      (default " << default_args.verify << ")\n";
+    cout << "                                      (default " << default_args.debug_dot_node << ")\n";
 }
 
 void cmd_error(std::string prog, std::string msg) {
@@ -181,6 +188,8 @@ Args parse_args(int argc, char** argv) {
                     args.opt_graph_layout = arg_val;
                 } else if (argv[i] == std::string("--verify")) { 
                     args.verify = arg_val;
+                } else if (argv[i] == std::string("--report")) { 
+                    args.report = arg_val;
                 } else if (argv[i] == std::string("--debug_dot_node")) { 
                     args.debug_dot_node = arg_val;
                 } else {
@@ -216,8 +225,8 @@ int main(int argc, char** argv) {
 
     int exit_code = 0;
 
-    struct timespec prog_start, load_start, verify_start;
-    struct timespec prog_end, load_end, verify_end;
+    struct timespec prog_start, load_start, opt_start, verify_start;
+    struct timespec prog_end, load_end, opt_end, verify_end;
 
     clock_gettime(CLOCK_MONOTONIC, &prog_start);
 
@@ -316,7 +325,10 @@ int main(int argc, char** argv) {
 
     if (args.opt_graph_layout) {
         
+        clock_gettime(CLOCK_MONOTONIC, &opt_start);
         auto id_maps = timing_graph->optimize_layout();
+        clock_gettime(CLOCK_MONOTONIC, &opt_end);
+        cout << "Optimizing graph took: " << tatum::time_sec(opt_start, opt_end) << " sec" << endl;
 
         remap_delay_calculator(*timing_graph, *delay_calculator, id_maps.edge_id_map);
         timing_constraints->remap_nodes(id_maps.node_id_map);
@@ -391,13 +403,18 @@ int main(int argc, char** argv) {
         auto dot_writer = make_graphviz_dot_writer(*timing_graph, *delay_calculator);
 
         std::vector<NodeId> nodes;
-        if (args.debug_dot_node >= 0) {
+        if (args.debug_dot_node == -1) {
+            //Pass
+        } else if (args.debug_dot_node < -1) {
+            auto tg_nodes = timing_graph->nodes();
+            nodes = std::vector<NodeId>(tg_nodes.begin(), tg_nodes.end());
+        } else if (args.debug_dot_node >= 0) {
             nodes = find_transitively_connected_nodes(*timing_graph, {NodeId(args.debug_dot_node)});
-            dot_writer.set_nodes_to_dump(nodes);
         }
+        dot_writer.set_nodes_to_dump(nodes);
 
         std::shared_ptr<tatum::SetupTimingAnalyzer> echo_setup_analyzer = std::dynamic_pointer_cast<tatum::SetupTimingAnalyzer>(serial_analyzer);
-        if(echo_setup_analyzer) {
+        if(args.report && echo_setup_analyzer) {
             //write_dot_file_setup("tg_setup_annotated.dot", *timing_graph, *delay_calculator, *echo_setup_analyzer, nodes);
             dot_writer.write_dot_file("tg_setup_annotated.dot", *echo_setup_analyzer);
             timing_reporter.report_timing_setup("report_timing.setup.rpt", *echo_setup_analyzer);
@@ -409,7 +426,7 @@ int main(int argc, char** argv) {
             detailed_timing_reporter.report_unconstrained_setup("report_unconstrained_timing_detailed.setup.rpt", *echo_setup_analyzer);
         }
         std::shared_ptr<tatum::HoldTimingAnalyzer> echo_hold_analyzer = std::dynamic_pointer_cast<tatum::HoldTimingAnalyzer>(serial_analyzer);
-        if(echo_hold_analyzer) {
+        if(args.report && echo_hold_analyzer) {
             //write_dot_file_hold("tg_hold_annotated.dot", *timing_graph, *delay_calculator, *echo_hold_analyzer, nodes);
             dot_writer.write_dot_file("tg_hold_annotated.dot", *echo_hold_analyzer);
             timing_reporter.report_timing_hold("report_timing.hold.rpt", *echo_hold_analyzer);
diff --git a/test/basic/vtr_multiclock.tatum b/test/basic/vtr_multiclock.tatum

Original file line number	Diff line number	Diff line change
`@@ -575,39 +575,42 @@ bool TimingGraph::validate_values() const {`
`575`	`575`
`576`	`576`	`for(NodeId node_id : nodes()) {`
`577`	`577`	`if(!valid_node_id(node_id)) {`
`578`		`- throw tatum::Error("Invalid node id");`
	`578`	`+ throw tatum::Error("Invalid node id", node_id);`
`579`	`579`	`}`
`580`	`580`
`581`	`581`	`for(EdgeId edge_id : node_in_edges_[node_id]) {`
`582`	`582`	`if(!valid_edge_id(edge_id)) {`
`583`		`- throw tatum::Error("Invalid node-in-edge reference");`
	`583`	`+ throw tatum::Error("Invalid node-in-edge reference", node_id, edge_id);`
`584`	`584`	`}`
`585`	`585`
`586`	`586`	`//Check that the references are consistent`
`587`	`587`	`if(edge_sink_nodes_[edge_id] != node_id) {`
`588`		`- throw tatum::Error("Mismatched edge-sink/node-in-edge reference");`
	`588`	`+ throw tatum::Error("Mismatched edge-sink/node-in-edge reference", node_id, edge_id);`
`589`	`589`	`}`
`590`	`590`	`}`
`591`	`591`	`for(EdgeId edge_id : node_out_edges_[node_id]) {`
`592`	`592`	`if(!valid_edge_id(edge_id)) {`
`593`		`- throw tatum::Error("Invalid node-out-edge reference");`
	`593`	`+ throw tatum::Error("Invalid node-out-edge reference", node_id, edge_id);`
`594`	`594`	`}`
`595`	`595`
`596`	`596`	`//Check that the references are consistent`
`597`	`597`	`if(edge_src_nodes_[edge_id] != node_id) {`
`598`		`- throw tatum::Error("Mismatched edge-src/node-out-edge reference");`
	`598`	`+ throw tatum::Error("Mismatched edge-src/node-out-edge reference", node_id, edge_id);`
`599`	`599`	`}`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`	`for(EdgeId edge_id : edges()) {`
`603`	`603`	`if(!valid_edge_id(edge_id)) {`
`604`		`- throw tatum::Error("Invalid edge id");`
	`604`	`+ throw tatum::Error("Invalid edge id", edge_id);`
`605`	`605`	`}`
`606`		`- if(!valid_node_id(edge_src_nodes_[edge_id])) {`
`607`		`- throw tatum::Error("Invalid edge source node");`
	`606`	`+ NodeId src_node = edge_src_nodes_[edge_id];`
	`607`	`+ if(!valid_node_id(src_node)) {`
	`608`	`+ throw tatum::Error("Invalid edge source node", src_node, edge_id);`
`608`	`609`	`}`
`609`		`- if(!valid_node_id(edge_sink_nodes_[edge_id])) {`
`610`		`- throw tatum::Error("Invalid edge sink node");`
	`610`	`+`
	`611`	`+ NodeId sink_node = edge_sink_nodes_[edge_id];`
	`612`	`+ if(!valid_node_id(sink_node)) {`
	`613`	`+ throw tatum::Error("Invalid edge sink node", sink_node, edge_id);`
`611`	`614`	`}`
`612`	`615`	`}`
`613`	`616`
`@@ -633,29 +636,29 @@ bool TimingGraph::validate_structure() const {`
`633`	`636`	`//Check expected number of fan-in/fan-out edges`
`634`	`637`	`if(src_type == NodeType::SOURCE) {`
`635`	`638`	`if(in_edges.size() > 1) {`
`636`		`- throw tatum::Error("SOURCE node has more than one active incoming edge (expected 0 if primary input, or 1 if clocked)");`
	`639`	`+ throw tatum::Error("SOURCE node has more than one active incoming edge (expected 0 if primary input, or 1 if clocked)", src_node);`
`637`	`640`	`}`
`638`	`641`	`} else if (src_type == NodeType::SINK) {`
`639`	`642`	`if(out_edges.size() > 0) {`
`640`		`- throw tatum::Error("SINK node has out-going edges");`
	`643`	`+ throw tatum::Error("SINK node has out-going edges", src_node);`
`641`	`644`	`}`
`642`	`645`	`} else if (src_type == NodeType::IPIN) {`
`643`	`646`	`if(in_edges.size() == 0 && !allow_dangling_combinational_nodes_) {`
`644`		`- throw tatum::Error("IPIN has no in-coming edges");`
	`647`	`+ throw tatum::Error("IPIN has no in-coming edges", src_node);`
`645`	`648`	`}`
`646`	`649`	`if(out_edges.size() == 0 && !allow_dangling_combinational_nodes_) {`
`647`		`- throw tatum::Error("IPIN has no out-going edges");`
	`650`	`+ throw tatum::Error("IPIN has no out-going edges", src_node);`
`648`	`651`	`}`
`649`	`652`	`} else if (src_type == NodeType::OPIN) {`
`650`	`653`	`//May have no incoming edges if a constant generator, so don't check that case`
`651`	`654`
`652`	`655`	`if(out_edges.size() == 0 && !allow_dangling_combinational_nodes_) {`
`653`		`- throw tatum::Error("OPIN has no out-going edges");`
	`656`	`+ throw tatum::Error("OPIN has no out-going edges", src_node);`
`654`	`657`	`}`
`655`	`658`	`} else {`
`656`	`659`	`TATUM_ASSERT(src_type == NodeType::CPIN);`
`657`	`660`	`if(in_edges.size() == 0) {`
`658`		`- throw tatum::Error("CPIN has no in-coming edges");`
	`661`	`+ throw tatum::Error("CPIN has no in-coming edges", src_node);`
`659`	`662`	`}`
`660`	`663`	`//We do not check for out-going cpin edges, since there is no reason that`
`661`	`664`	`//a clock pin must be used`
`@@ -675,61 +678,61 @@ bool TimingGraph::validate_structure() const {`
`675`	`678`	`&& sink_type != NodeType::OPIN`
`676`	`679`	`&& sink_type != NodeType::CPIN`
`677`	`680`	`&& sink_type != NodeType::SINK) {`
`678`		`- throw tatum::Error("SOURCE nodes should only drive IPIN, OPIN, CPIN or SINK nodes");`
	`681`	`+ throw tatum::Error("SOURCE nodes should only drive IPIN, OPIN, CPIN or SINK nodes", src_node, out_edge);`
`679`	`682`	`}`
`680`	`683`
`681`	`684`	`if(sink_type == NodeType::SINK) {`
`682`	`685`	`if( out_edge_type != EdgeType::INTERCONNECT`
`683`	`686`	`&& out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {`
`684`		`- throw tatum::Error("SOURCE to SINK edges should always be either INTERCONNECT or PRIMTIIVE_COMBINATIONAL type edges");`
	`687`	`+ throw tatum::Error("SOURCE to SINK edges should always be either INTERCONNECT or PRIMTIIVE_COMBINATIONAL type edges", src_node, out_edge);`
`685`	`688`	`}`
`686`	`689`
`687`	`690`	`} else if (sink_type == NodeType::OPIN) {`
`688`	`691`	`if(out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {`
`689`		`- throw tatum::Error("SOURCE to OPIN edges should always be PRIMITIVE_COMBINATIONAL type edges");`
	`692`	`+ throw tatum::Error("SOURCE to OPIN edges should always be PRIMITIVE_COMBINATIONAL type edges", src_node, out_edge);`
`690`	`693`	`}`
`691`	`694`	`} else {`
`692`	`695`	`TATUM_ASSERT(sink_type == NodeType::IPIN \|\| sink_type == NodeType::CPIN);`
`693`	`696`	`if(out_edge_type != EdgeType::INTERCONNECT) {`
`694`		`- throw tatum::Error("SOURCE to IPIN/CPIN edges should always be INTERCONNECT type edges");`
	`697`	`+ throw tatum::Error("SOURCE to IPIN/CPIN edges should always be INTERCONNECT type edges", src_node, out_edge);`
`695`	`698`	`}`
`696`	`699`	`}`
`697`	`700`
`698`	`701`	`} else if (src_type == NodeType::SINK) {`
`699`		`- throw tatum::Error("SINK nodes should not have out-going edges");`
	`702`	`+ throw tatum::Error("SINK nodes should not have out-going edges", sink_node);`
`700`	`703`	`} else if (src_type == NodeType::IPIN) {`
`701`	`704`	`if(sink_type != NodeType::OPIN && sink_type != NodeType::SINK) {`
`702`		`- throw tatum::Error("IPIN nodes should only drive OPIN or SINK nodes");`
	`705`	`+ throw tatum::Error("IPIN nodes should only drive OPIN or SINK nodes", src_node, out_edge);`
`703`	`706`	`}`
`704`	`707`
`705`	`708`	`if(out_edge_type != EdgeType::PRIMITIVE_COMBINATIONAL) {`
`706`		`- throw tatum::Error("IPIN to OPIN/SINK edges should always be PRIMITIVE_COMBINATIONAL type edges");`
	`709`	`+ throw tatum::Error("IPIN to OPIN/SINK edges should always be PRIMITIVE_COMBINATIONAL type edges", src_node, out_edge);`
`707`	`710`	`}`
`708`	`711`
`709`	`712`	`} else if (src_type == NodeType::OPIN) {`
`710`	`713`	`if( sink_type != NodeType::IPIN`
`711`	`714`	`&& sink_type != NodeType::CPIN`
`712`	`715`	`&& sink_type != NodeType::SINK) {`
`713`		`- throw tatum::Error("OPIN nodes should only drive IPIN, CPIN or SINK nodes");`
	`716`	`+ throw tatum::Error("OPIN nodes should only drive IPIN, CPIN or SINK nodes", src_node, out_edge);`
`714`	`717`	`}`
`715`	`718`
`716`	`719`	`if(out_edge_type != EdgeType::INTERCONNECT) {`
`717`		`- throw tatum::Error("OPIN out edges should always be INTERCONNECT type edges");`
	`720`	`+ throw tatum::Error("OPIN out edges should always be INTERCONNECT type edges", src_node, out_edge);`
`718`	`721`	`}`
`719`	`722`
`720`	`723`	`} else if (src_type == NodeType::CPIN) {`
`721`	`724`	`if( sink_type != NodeType::SOURCE`
`722`	`725`	`&& sink_type != NodeType::SINK) {`
`723`		`- throw tatum::Error("CPIN nodes should only drive SOURCE or SINK nodes");`
	`726`	`+ throw tatum::Error("CPIN nodes should only drive SOURCE or SINK nodes", src_node, out_edge);`
`724`	`727`	`}`
`725`	`728`
`726`	`729`	`if(sink_type == NodeType::SOURCE && out_edge_type != EdgeType::PRIMITIVE_CLOCK_LAUNCH) {`
`727`		`- throw tatum::Error("CPIN to SOURCE edges should always be PRIMITIVE_CLOCK_LAUNCH type edges");`
	`730`	`+ throw tatum::Error("CPIN to SOURCE edges should always be PRIMITIVE_CLOCK_LAUNCH type edges", src_node, out_edge);`
`728`	`731`	`} else if (sink_type == NodeType::SINK && out_edge_type != EdgeType::PRIMITIVE_CLOCK_CAPTURE) {`
`729`		`- throw tatum::Error("CPIN to SINK edges should always be PRIMITIVE_CLOCK_CAPTURE type edges");`
	`732`	`+ throw tatum::Error("CPIN to SINK edges should always be PRIMITIVE_CLOCK_CAPTURE type edges", src_node, out_edge);`
`730`	`733`	`}`
`731`	`734`	`} else {`
`732`		`- throw tatum::Error("Unrecognized node type");`
	`735`	`+ throw tatum::Error("Unrecognized node type", src_node, out_edge);`
`733`	`736`	`}`
`734`	`737`	`}`
`735`	`738`	`}`
`@@ -757,27 +760,27 @@ bool TimingGraph::validate_structure() const {`
`757`	`760`	`for(EdgeId edge : edge_ids) {`
`758`	`761`	`ss << edge << " ";`
`759`	`762`	`}`
`760`		`- throw tatum::Error(ss.str());`
	`763`	`+ throw tatum::Error(ss.str(), src_node);`
`761`	`764`	`}`
`762`	`765`	`}`
`763`	`766`
`764`	`767`	`for(NodeId node : primary_inputs()) {`
`765`	`768`	`if(!node_in_edges(node).empty()) {`
`766`		`- throw tatum::Error("Primary input nodes should have no incoming edges");`
	`769`	`+ throw tatum::Error("Primary input nodes should have no incoming edges", node);`
`767`	`770`	`}`
`768`	`771`
`769`	`772`	`if(node_type(node) != NodeType::SOURCE) {`
`770`		`- throw tatum::Error("Primary inputs should be only SOURCE nodes");`
	`773`	`+ throw tatum::Error("Primary inputs should be only SOURCE nodes", node);`
`771`	`774`	`}`
`772`	`775`	`}`
`773`	`776`
`774`	`777`	`for(NodeId node : logical_outputs()) {`
`775`	`778`	`if(!node_out_edges(node).empty()) {`
`776`		`- throw tatum::Error("Logical output node should have no outgoing edges");`
	`779`	`+ throw tatum::Error("Logical output node should have no outgoing edges", node);`
`777`	`780`	`}`
`778`	`781`
`779`	`782`	`if(node_type(node) != NodeType::SINK) {`
`780`		`- throw tatum::Error("Logical outputs should be only SINK nodes");`
	`783`	`+ throw tatum::Error("Logical outputs should be only SINK nodes", node);`
`781`	`784`	`}`
`782`	`785`	`}`
`783`	`786`
`@@ -912,10 +915,10 @@ EdgeType infer_edge_type(const TimingGraph& tg, EdgeId edge) {`
`912`	`915`	`} else if(sink_node_type == NodeType::SINK) {`
`913`	`916`	`return EdgeType::PRIMITIVE_CLOCK_CAPTURE;`
`914`	`917`	`} else {`
`915`		`- throw tatum::Error("Invalid edge sink node (CPIN source node must connect to SOURCE or SINK sink node)");`
	`918`	`+ throw tatum::Error("Invalid edge sink node (CPIN source node must connect to SOURCE or SINK sink node)", sink_node, edge);`
`916`	`919`	`}`
`917`	`920`	`} else {`
`918`		`- throw tatum::Error("Invalid edge sink/source nodes");`
	`921`	`+ throw tatum::Error("Invalid edge sink/source nodes", edge);`
`919`	`922`	`}`
`920`	`923`	`}`
`921`	`924`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ bool validate_timing_graph_constraints(const TimingGraph& timing_graph, const Ti`
`19`	`19`	`msg = "Clock Domain " + std::to_string(size_t(domain)) + " (" + timing_constraints.clock_domain_name(domain) + ")"`
`20`	`20`	`" source node " + std::to_string(size_t(source_node)) + " is not a node of type SOURCE.";`
`21`	`21`
`22`		`- throw tatum::Error(msg);`
	`22`	`+ throw tatum::Error(msg, source_node);`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`	`}`
`@@ -32,7 +32,7 @@ bool validate_timing_graph_constraints(const TimingGraph& timing_graph, const Ti`
`32`	`32`
`33`	`33`	`msg = "Timing Graph node " + std::to_string(size_t(node)) + " is an OPIN with no incoming edges, but is not marked as a constant generator";`
`34`	`34`
`35`		`- throw tatum::Error(msg);`
	`35`	`+ throw tatum::Error(msg, node);`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`	`}`