| #include <map> |
| #include <fstream> |
| #include <sstream> |
| #include <iomanip> |
| #include <vector> |
| |
| #include "tatum/util/tatum_math.hpp" |
| #include "tatum/util/OsFormatGuard.hpp" |
| #include "tatum/error.hpp" |
| #include "tatum/TimingReporter.hpp" |
| #include "tatum/TimingGraph.hpp" |
| #include "tatum/TimingConstraints.hpp" |
| |
| namespace tatum { namespace detail { |
| |
| float convert_to_printable_units(float value, float unit_scale) { |
| return value / unit_scale; |
| } |
| |
| std::string to_printable_string(tatum::Time val, float unit_scale, size_t precision) { |
| std::stringstream ss; |
| if(!std::signbit(val.value())) ss << " "; //Pad possitive values so they align with negative prefixed with - |
| ss << std::fixed << std::setprecision(precision) << convert_to_printable_units(val.value(), unit_scale); |
| |
| return ss.str(); |
| } |
| |
| void ReportTimingPathHelper::update_print_path(std::ostream& os, std::string point, tatum::Time path) { |
| |
| tatum::Time incr = path - prev_path_; |
| |
| print_path_line(os, point, to_printable_string(incr, unit_scale_, precision_), to_printable_string(path, unit_scale_, precision_)); |
| |
| prev_path_ = path; |
| } |
| |
| void ReportTimingPathHelper::update_print_path_no_incr(std::ostream& os, std::string point, tatum::Time path) { |
| print_path_line(os, point, "", to_printable_string(path, unit_scale_, precision_)); |
| |
| prev_path_ = path; |
| } |
| |
| void ReportTimingPathHelper::reset_path() { |
| prev_path_ = tatum::Time(0.); |
| } |
| |
| void ReportTimingPathHelper::print_path_line_no_incr(std::ostream& os, std::string point, tatum::Time path) const { |
| print_path_line(os, point, "", to_printable_string(path, unit_scale_, precision_)); |
| } |
| |
| void ReportTimingPathHelper::print_path_line(std::ostream& os, std::string point, std::string incr, std::string path) const { |
| os << std::setw(point_width_) << std::left << point; |
| os << std::setw(incr_width_) << std::right << incr; |
| os << std::setw(path_width_) << std::right << path; |
| os << "\n"; |
| } |
| |
| void ReportTimingPathHelper::print_divider(std::ostream& os) const { |
| size_t cnt = point_width_ + incr_width_ + path_width_; |
| for(size_t i = 0; i < cnt; ++i) { |
| os << "-"; |
| } |
| os << "\n"; |
| } |
| |
| }} //namespace |
| |
| namespace tatum { |
| |
| /* |
| * Public member functions |
| */ |
| |
| TimingReporter::TimingReporter(const TimingGraphNameResolver& name_resolver, |
| const TimingGraph& timing_graph, |
| const TimingConstraints& timing_constraints, |
| float unit_scale, |
| size_t precision) |
| : name_resolver_(name_resolver) |
| , timing_graph_(timing_graph) |
| , timing_constraints_(timing_constraints) |
| , unit_scale_(unit_scale) |
| , precision_(precision) { |
| //pass |
| } |
| |
| void TimingReporter::report_timing_setup(std::string filename, |
| const SetupTimingAnalyzer& setup_analyzer, |
| size_t npaths) const { |
| std::ofstream os(filename); |
| report_timing_setup(os, setup_analyzer, npaths); |
| } |
| |
| void TimingReporter::report_timing_setup(std::ostream& os, |
| const SetupTimingAnalyzer& setup_analyzer, |
| size_t npaths) const { |
| auto 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 { |
| std::ofstream os(filename); |
| report_timing_hold(os, hold_analyzer, npaths); |
| } |
| |
| void TimingReporter::report_timing_hold(std::ostream& os, |
| const HoldTimingAnalyzer& hold_analyzer, |
| size_t npaths) const { |
| auto 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 { |
| std::ofstream os(filename); |
| report_skew_setup(os, setup_analyzer, nworst); |
| } |
| |
| void TimingReporter::report_skew_setup(std::ostream& os, |
| const SetupTimingAnalyzer& setup_analyzer, |
| size_t nworst) const { |
| auto paths = path_collector_.collect_worst_setup_skew_paths(timing_graph_, timing_constraints_, setup_analyzer, nworst); |
| |
| os << "#Clock skew for setup timing startpoint/endpoint\n"; |
| os << "\n"; |
| report_skew(os, paths, TimingType::SETUP); |
| os << "#End of clock skew for setup timing startpoint/endpoint report\n"; |
| } |
| |
| void TimingReporter::report_skew_hold(std::string filename, |
| const HoldTimingAnalyzer& hold_analyzer, |
| size_t nworst) const { |
| std::ofstream os(filename); |
| report_skew_hold(os, hold_analyzer, nworst); |
| } |
| |
| void TimingReporter::report_skew_hold(std::ostream& os, |
| const HoldTimingAnalyzer& hold_analyzer, |
| size_t nworst) const { |
| auto paths = path_collector_.collect_worst_hold_skew_paths(timing_graph_, timing_constraints_, hold_analyzer, nworst); |
| |
| os << "#Clock skew for hold timing startpoint/endpoint\n"; |
| os << "\n"; |
| report_skew(os, paths, TimingType::HOLD); |
| os << "#End of clock skew for hold timing startpoint/endpoint report\n"; |
| } |
| |
| void TimingReporter::report_unconstrained_setup(std::string filename, |
| const tatum::SetupTimingAnalyzer& setup_analyzer) const { |
| std::ofstream os(filename); |
| report_unconstrained_setup(os, setup_analyzer); |
| } |
| |
| void TimingReporter::report_unconstrained_setup(std::ostream& os, |
| const tatum::SetupTimingAnalyzer& setup_analyzer) const { |
| detail::SetupTagRetriever tag_retriever(setup_analyzer); |
| |
| os << "#Unconstrained setup timing startpoint/endpoint\n"; |
| os << "\n"; |
| os << "timing_node_id node_type node_name\n"; |
| os << "-------------- --------- ---------\n"; |
| report_unconstrained(os, NodeType::SOURCE, tag_retriever); |
| report_unconstrained(os, NodeType::SINK, tag_retriever); |
| os << "\n"; |
| os << "#End of unconstrained setup startpoint/endpoint report\n"; |
| } |
| |
| void TimingReporter::report_unconstrained_hold(std::string filename, |
| const tatum::HoldTimingAnalyzer& hold_analyzer) const { |
| std::ofstream os(filename); |
| report_unconstrained_hold(os, hold_analyzer); |
| } |
| |
| void TimingReporter::report_unconstrained_hold(std::ostream& os, |
| const tatum::HoldTimingAnalyzer& hold_analyzer) const { |
| detail::HoldTagRetriever tag_retriever(hold_analyzer); |
| |
| os << "#Unconstrained hold timing startpoint/endpoint\n"; |
| os << "\n"; |
| os << "timing_node_id node_type node_name\n"; |
| os << "-------------- --------- ---------\n"; |
| report_unconstrained(os, NodeType::SOURCE, tag_retriever); |
| report_unconstrained(os, NodeType::SINK, tag_retriever); |
| os << "\n"; |
| os << "#End of unconstrained hold startpoint/endpoint report\n"; |
| } |
| |
| /* |
| * Private member functions |
| */ |
| |
| void TimingReporter::report_timing(std::ostream& os, |
| const std::vector<TimingPath>& paths) const { |
| tatum::OsFormatGuard flag_guard(os); |
| |
| os << "#Timing report of worst " << paths.size() << " path(s)\n"; |
| os << "# Unit scale: " << std::setprecision(0) << std::scientific << unit_scale_ << " seconds\n"; |
| os << "# Output precision: " << precision_ << "\n"; |
| os << "\n"; |
| |
| size_t i = 0; |
| for(const auto& path : paths) { |
| os << "#Path " << ++i << "\n"; |
| report_timing_path(os, path); |
| os << "\n"; |
| } |
| |
| os << "#End of timing report\n"; |
| } |
| |
| void TimingReporter::report_timing_path(std::ostream& os, const TimingPath& timing_path) const { |
| std::string divider = "--------------------------------------------------------------------------------"; |
| |
| TimingPathInfo path_info = timing_path.path_info(); |
| |
| os << "Startpoint: " << name_resolver_.node_name(path_info.startpoint()) |
| << " (" << name_resolver_.node_type_name(path_info.startpoint()) |
| << " clocked by " << timing_constraints_.clock_domain_name(path_info.launch_domain()) |
| << ")\n"; |
| os << "Endpoint : " << name_resolver_.node_name(path_info.endpoint()) |
| << " (" << name_resolver_.node_type_name(path_info.endpoint()) |
| << " clocked by " << timing_constraints_.clock_domain_name(path_info.capture_domain()) |
| << ")\n"; |
| |
| if(path_info.type() == TimingType::SETUP) { |
| os << "Path Type : setup" << "\n"; |
| } else { |
| TATUM_ASSERT_MSG(path_info.type() == TimingType::HOLD, "Expected path type SETUP or HOLD"); |
| os << "Path Type : hold" << "\n"; |
| } |
| |
| os << "\n"; |
| |
| size_t point_print_width = estimate_point_print_width(timing_path); |
| |
| //Helper to track path state and output formatting |
| detail::ReportTimingPathHelper path_helper(unit_scale_, precision_, point_print_width); |
| path_helper.print_path_line(os, "Point", " Incr", " Path"); |
| path_helper.print_divider(os); |
| |
| |
| //Launch path |
| Time arr_time; |
| Time arr_path; |
| { |
| path_helper.reset_path(); |
| |
| arr_path = report_timing_clock_launch_subpath(os, path_helper, timing_path.clock_launch_path(), path_info.launch_domain(), path_info.type()); |
| |
| arr_path = report_timing_data_arrival_subpath(os, path_helper, timing_path.data_arrival_path(), path_info.launch_domain(), path_info.type(), arr_path); |
| |
| { |
| //Final arrival time |
| const TimingPathElem& path_elem = *(--timing_path.data_arrival_path().elements().end()); |
| |
| TATUM_ASSERT(timing_graph_.node_type(path_elem.node()) == NodeType::SINK); |
| |
| TATUM_ASSERT(path_elem.tag().type() == TagType::DATA_ARRIVAL); |
| arr_time = path_elem.tag().time(); |
| path_helper.update_print_path_no_incr(os, "data arrival time", arr_time); |
| os << "\n"; |
| } |
| |
| //Sanity check the arrival time calculated by this timing report (i.e. path) and the one calculated by |
| //the analyzer (i.e. arr_time) agree |
| if(!nearly_equal(arr_time, arr_path)) { |
| os.flush(); |
| std::stringstream ss; |
| ss << "Internal Error: analyzer arrival time (" << arr_time.value() << ")" |
| << " differs from timing report path arrival time (" << arr_path.value() << ")" |
| << " beyond tolerance"; |
| throw tatum::Error(ss.str()); |
| } |
| } |
| |
| |
| //Capture path (required time) |
| Time req_time; |
| Time req_path; |
| { |
| path_helper.reset_path(); |
| |
| req_path = report_timing_clock_capture_subpath(os, path_helper, timing_path.clock_capture_path(), |
| path_info.launch_domain(), path_info.capture_domain(), |
| path_info.endpoint(), |
| path_info.type()); |
| |
| const TimingPathElem& path_elem = timing_path.data_required_element(); |
| |
| req_path = report_timing_data_required_element(os, path_helper, path_elem, |
| path_info.capture_domain(), path_info.type(), |
| req_path); |
| //Final arrival time |
| req_time = path_elem.tag().time(); |
| path_helper.update_print_path_no_incr(os, "data required time", req_time); |
| |
| |
| //Sanity check required time |
| if(!nearly_equal(req_time, req_path)) { |
| os.flush(); |
| std::stringstream ss; |
| ss << "Internal Error: analyzer required time (" << req_time.value() << ")" |
| << " differs from report_timing path required time (" << req_path.value() << ")" |
| << " beyond tolerance"; |
| throw tatum::Error(ss.str()); |
| } |
| } |
| |
| //Summary and slack |
| path_helper.print_divider(os); |
| if (path_info.type() == TimingType::SETUP) { |
| path_helper.print_path_line_no_incr(os, "data required time", req_time); |
| path_helper.print_path_line_no_incr(os, "data arrival time", -arr_time); |
| } else { |
| TATUM_ASSERT(path_info.type() == TimingType::HOLD); |
| path_helper.print_path_line_no_incr(os, "data required time", -req_time); |
| path_helper.print_path_line_no_incr(os, "data arrival time", arr_time); |
| } |
| path_helper.print_divider(os); |
| Time slack = timing_path.slack_tag().time(); |
| if(slack.value() < 0. || std::signbit(slack.value())) { |
| path_helper.print_path_line_no_incr(os, "slack (VIOLATED)", slack); |
| } else { |
| path_helper.print_path_line_no_incr(os, "slack (MET)", slack); |
| } |
| os << "\n"; |
| os.flush(); |
| |
| //Sanity check slack |
| Time path_slack; |
| if (path_info.type() == TimingType::SETUP) { |
| path_slack = req_path - arr_path; |
| } else { |
| TATUM_ASSERT(path_info.type() == TimingType::HOLD); |
| path_slack = arr_path - req_path; |
| } |
| if(!nearly_equal(slack, path_slack)) { |
| os.flush(); |
| std::stringstream ss; |
| ss << "Internal Error: analyzer slack (" << slack << ")" |
| << " differs from report_timing path slack (" << path_slack << ")" |
| << " beyond tolerance"; |
| throw tatum::Error(ss.str()); |
| } |
| } |
| |
| void TimingReporter::report_unconstrained(std::ostream& os, const NodeType type, const detail::TagRetriever& tag_retriever) const { |
| for(NodeId node : timing_graph_.nodes()) { |
| NodeType node_type = timing_graph_.node_type(node); |
| if(node_type == type) { |
| auto tags = tag_retriever.tags(node); |
| if(!is_constrained(node_type, tags)) { |
| os << size_t(node) |
| << " " << name_resolver_.node_type_name(node) |
| << " " << name_resolver_.node_name(node) |
| << "\n"; |
| } |
| } |
| } |
| } |
| |
| void TimingReporter::report_skew(std::ostream& os, const std::vector<SkewPath>& skew_paths, TimingType timing_type) const { |
| tatum::OsFormatGuard flag_guard(os); |
| |
| int i = 1; |
| for (const auto& skew_path : skew_paths) { |
| os << "#Skew Path " << i << "\n"; |
| report_skew_path(os, skew_path, timing_type); |
| os << "\n"; |
| ++i; |
| } |
| } |
| |
| void TimingReporter::report_skew_path(std::ostream& os, const SkewPath& skew_path, TimingType timing_type) const { |
| |
| auto& launch_path = skew_path.clock_launch_path; |
| auto& capture_path = skew_path.clock_capture_path; |
| |
| NodeId launch_node = skew_path.data_launch_node; |
| NodeId capture_node = skew_path.data_capture_node; |
| |
| os << "Startpoint: " << name_resolver_.node_name(launch_node) |
| << " (" << name_resolver_.node_type_name(launch_node) |
| << " clocked by " << timing_constraints_.clock_domain_name(skew_path.launch_domain) |
| << ")\n"; |
| os << "Endpoint : " << name_resolver_.node_name(capture_node) |
| << " (" << name_resolver_.node_type_name(capture_node) |
| << " clocked by " << timing_constraints_.clock_domain_name(skew_path.capture_domain) |
| << ")\n"; |
| |
| if(timing_type == TimingType::SETUP) { |
| os << "Path Type : setup" << "\n"; |
| } else { |
| TATUM_ASSERT_MSG(timing_type == TimingType::HOLD, "Expected path type SETUP or HOLD"); |
| os << "Path Type : hold" << "\n"; |
| } |
| os << "\n"; |
| |
| std::string launch_name = name_resolver_.node_name(launch_node) |
| + " (" |
| + name_resolver_.node_type_name(launch_node) |
| + ")"; |
| std::string capture_name = name_resolver_.node_name(capture_node) |
| + " (" |
| + name_resolver_.node_type_name(capture_node) |
| + ")"; |
| |
| size_t point_print_width = std::max(launch_name.size(), capture_name.size()); |
| point_print_width = std::max(point_print_width, std::string("clock data capture (normalized)").size()); |
| |
| detail::ReportTimingPathHelper path_helper(unit_scale_, precision_, point_print_width); |
| |
| |
| path_helper.print_path_line(os, "Point", " Incr", " Path"); |
| path_helper.print_divider(os); |
| |
| Time data_launch_time = report_timing_clock_launch_subpath(os, path_helper, launch_path, skew_path.launch_domain, timing_type); |
| TATUM_ASSERT(nearly_equal(data_launch_time, skew_path.clock_launch_arrival)); |
| |
| path_helper.update_print_path_no_incr(os, "data launch", data_launch_time); |
| os << "\n"; |
| |
| os << "\n"; |
| |
| path_helper.reset_path(); |
| |
| Time data_capture_time = report_timing_clock_capture_subpath(os, path_helper, capture_path, skew_path.launch_domain, skew_path.capture_domain, skew_path.data_capture_node, timing_type); |
| TATUM_ASSERT(nearly_equal(data_capture_time, skew_path.clock_capture_arrival)); |
| |
| path_helper.update_print_path_no_incr(os, "data capture", data_capture_time); |
| path_helper.print_divider(os); |
| |
| Time clock_constraint; |
| if (timing_type == TimingType::SETUP) { |
| clock_constraint = timing_constraints_.setup_constraint(skew_path.launch_domain, skew_path.capture_domain); |
| } else { |
| clock_constraint = timing_constraints_.hold_constraint(skew_path.launch_domain, skew_path.capture_domain); |
| } |
| path_helper.print_path_line_no_incr(os, "data capture", data_capture_time); |
| path_helper.print_path_line_no_incr(os, "clock constraint", -clock_constraint); |
| path_helper.print_path_line_no_incr(os, "data launch", -data_launch_time); |
| path_helper.print_divider(os); |
| |
| Time skew = data_capture_time - clock_constraint - data_launch_time; |
| TATUM_ASSERT(nearly_equal(skew, skew_path.clock_skew)); |
| path_helper.print_path_line_no_incr(os, "skew", skew); |
| } |
| |
| Time TimingReporter::report_timing_clock_launch_subpath(std::ostream& os, |
| detail::ReportTimingPathHelper& path_helper, |
| const TimingSubPath& subpath, |
| DomainId domain, |
| TimingType timing_type) const { |
| Time path(0.); |
| |
| { |
| //Launch clock origin |
| path += Time(0.); |
| std::string point = "clock " + timing_constraints_.clock_domain_name(domain) + " (rise edge)"; |
| path_helper.update_print_path(os, point, path); |
| } |
| |
| return report_timing_clock_subpath(os, path_helper, subpath, domain, timing_type, path, Time(0.)); |
| } |
| |
| Time TimingReporter::report_timing_clock_capture_subpath(std::ostream& os, |
| detail::ReportTimingPathHelper& path_helper, |
| const TimingSubPath& subpath, |
| DomainId launch_domain, |
| DomainId capture_domain, |
| NodeId capture_node, |
| TimingType timing_type) const { |
| Time path(0.); |
| Time offset(0.); //Offset required since the clock launch tag doesn't have the actual (potentially |
| //capture node dependent) constraint annotated. We determine this up front by |
| //looking up the actual constraint and add it into the subpath printed as an offset. |
| //Note that the required times 'path' values are correct it is only the increments |
| //which need to be offset when being reported (with the exception of the original |
| //rising edge). |
| { |
| //Launch clock origin |
| if (timing_type == TimingType::SETUP) { |
| path = timing_constraints_.setup_constraint(launch_domain, capture_domain, capture_node); |
| offset = path - timing_constraints_.setup_constraint(launch_domain, capture_domain); |
| } else { |
| TATUM_ASSERT(timing_type == TimingType::HOLD); |
| path = timing_constraints_.hold_constraint(launch_domain, capture_domain, capture_node); |
| offset = path - timing_constraints_.hold_constraint(launch_domain, capture_domain); |
| } |
| |
| //os << "[offset]" << tatum::detail::to_printable_string(offset, 1e-9,3) << "\n"; |
| std::string point = "clock " + timing_constraints_.clock_domain_name(capture_domain) + " (rise edge)"; |
| path_helper.update_print_path(os, point, path); |
| } |
| |
| path = report_timing_clock_subpath(os, path_helper, subpath, capture_domain, timing_type, path, offset); |
| |
| { |
| //Uncertainty |
| Time uncertainty; |
| if(timing_type == TimingType::SETUP) { |
| uncertainty = -Time(timing_constraints_.setup_clock_uncertainty(launch_domain, capture_domain)); |
| } else { |
| TATUM_ASSERT(timing_type == TimingType::HOLD); |
| uncertainty = Time(timing_constraints_.hold_clock_uncertainty(launch_domain, capture_domain)); |
| } |
| path += uncertainty; |
| path_helper.update_print_path(os, "clock uncertainty", path + offset); |
| } |
| |
| return path; |
| } |
| |
| Time TimingReporter::report_timing_clock_subpath(std::ostream& os, |
| detail::ReportTimingPathHelper& path_helper, |
| const TimingSubPath& subpath, |
| DomainId domain, |
| TimingType timing_type, |
| Time path, |
| Time offset) const { |
| { |
| //Launch clock latency |
| Time latency; |
| if (timing_type == TimingType::SETUP) { |
| //Setup clock launches late |
| latency = Time(timing_constraints_.source_latency(domain, ArrivalType::LATE)); |
| } else { |
| TATUM_ASSERT(timing_type == TimingType::HOLD); |
| //Hold clock launches early |
| latency = Time(timing_constraints_.source_latency(domain, ArrivalType::EARLY)); |
| } |
| path += latency; |
| std::string point = "clock source latency"; |
| path_helper.update_print_path(os, point, path); |
| } |
| |
| |
| DelayType delay_type; |
| if (timing_type == TimingType::SETUP) { |
| delay_type = DelayType::MAX; |
| } else { |
| delay_type = DelayType::MIN; |
| } |
| |
| //Launch clock path |
| for(const TimingPathElem& path_elem : subpath.elements()) { |
| |
| //Ask the application for a detailed breakdown of the edge delays |
| auto delay_breakdown = name_resolver_.edge_delay_breakdown(path_elem.incomming_edge(), delay_type); |
| if (!delay_breakdown.components.empty()) { |
| //Application provided detailed delay breakdown of edge delay, report it |
| for (auto& delay_component : delay_breakdown.components) { |
| std::string point = "|"; |
| if (!delay_component.inst_name.empty()) { |
| point += " " + delay_component.inst_name; |
| } |
| if (!delay_component.type_name.empty()) { |
| point += " (" + delay_component.type_name + ")"; |
| } |
| path += delay_component.delay; |
| path_helper.update_print_path(os, point, path); |
| } |
| TATUM_ASSERT_MSG(nearly_equal(path, path_elem.tag().time()), "Delay breakdown must match calculated delay"); |
| } |
| |
| |
| std::string point = name_resolver_.node_name(path_elem.node()) + " (" + name_resolver_.node_type_name(path_elem.node()) + ")"; |
| |
| path = path_elem.tag().time(); |
| |
| path_helper.update_print_path(os, point, path + offset); |
| } |
| |
| return path; |
| } |
| |
| Time TimingReporter::report_timing_data_arrival_subpath(std::ostream& os, |
| detail::ReportTimingPathHelper& path_helper, |
| const TimingSubPath& subpath, |
| DomainId domain, |
| TimingType timing_type, |
| Time path) const { |
| |
| { |
| //Input constraint |
| TATUM_ASSERT(subpath.elements().size() > 0); |
| const TimingPathElem& path_elem = *(subpath.elements().begin()); |
| |
| Time input_constraint; |
| if (timing_type == TimingType::SETUP) { |
| input_constraint = timing_constraints_.input_constraint(path_elem.node(), domain, DelayType::MAX); |
| } else { |
| TATUM_ASSERT(timing_type == TimingType::HOLD); |
| input_constraint = timing_constraints_.input_constraint(path_elem.node(), domain, DelayType::MIN); |
| } |
| |
| if(input_constraint.valid()) { |
| path += Time(input_constraint); |
| |
| path_helper.update_print_path(os, "input external delay", path); |
| } |
| } |
| |
| DelayType delay_type; |
| if (timing_type == TimingType::SETUP) { |
| delay_type = DelayType::MAX; |
| } else { |
| delay_type = DelayType::MIN; |
| } |
| |
| //Launch data |
| for(const TimingPathElem& path_elem : subpath.elements()) { |
| |
| //Ask the application for a detailed breakdown of the edge delays |
| auto delay_breakdown = name_resolver_.edge_delay_breakdown(path_elem.incomming_edge(), delay_type); |
| if (!delay_breakdown.components.empty()) { |
| //Application provided detailed delay breakdown of edge delay, report it |
| for (auto& delay_component : delay_breakdown.components) { |
| std::string point = "|"; |
| if (!delay_component.inst_name.empty()) { |
| point += " " + delay_component.inst_name; |
| } |
| if (!delay_component.type_name.empty()) { |
| point += " (" + delay_component.type_name + ")"; |
| } |
| path += delay_component.delay; |
| path_helper.update_print_path(os, point, path); |
| } |
| TATUM_ASSERT_MSG(nearly_equal(path, path_elem.tag().time()), "Delay breakdown must match calculated delay"); |
| } |
| |
| std::string point = name_resolver_.node_name(path_elem.node()) + " (" + name_resolver_.node_type_name(path_elem.node()) + ")"; |
| |
| EdgeId in_edge = path_elem.incomming_edge(); |
| if(in_edge && timing_graph_.edge_type(in_edge) == EdgeType::PRIMITIVE_CLOCK_LAUNCH) { |
| point += " [clock-to-output]"; |
| } |
| |
| path = path_elem.tag().time(); |
| |
| path_helper.update_print_path(os, point, path); |
| } |
| return path; |
| } |
| |
| Time TimingReporter::report_timing_data_required_element(std::ostream& os, |
| detail::ReportTimingPathHelper& path_helper, |
| const TimingPathElem& data_required_elem, |
| DomainId capture_domain, |
| TimingType timing_type, |
| Time path) const { |
| { |
| TATUM_ASSERT(timing_graph_.node_type(data_required_elem.node()) == NodeType::SINK); |
| |
| //Setup/hold time |
| EdgeId in_edge = data_required_elem.incomming_edge(); |
| if(in_edge && timing_graph_.edge_type(in_edge) == EdgeType::PRIMITIVE_CLOCK_CAPTURE) { |
| std::string point; |
| if(timing_type == TimingType::SETUP) { |
| point = "cell setup time"; |
| } else { |
| TATUM_ASSERT_MSG(timing_type == TimingType::HOLD, "Expected path type SETUP or HOLD"); |
| point = "cell hold time"; |
| } |
| path = data_required_elem.tag().time(); |
| path_helper.update_print_path(os, point, path); |
| } |
| |
| //Output constraint |
| Time output_constraint; |
| if (timing_type == TimingType::SETUP) { |
| output_constraint = timing_constraints_.output_constraint(data_required_elem.node(), capture_domain, DelayType::MAX); |
| } else { |
| TATUM_ASSERT(timing_type == TimingType::HOLD); |
| output_constraint = timing_constraints_.output_constraint(data_required_elem.node(), capture_domain, DelayType::MIN); |
| } |
| if(output_constraint.valid()) { |
| path += -Time(output_constraint); |
| path_helper.update_print_path(os, "output external delay", path); |
| } |
| } |
| |
| return path; |
| } |
| |
| bool TimingReporter::nearly_equal(const Time& lhs, const Time& rhs) const { |
| return tatum::util::nearly_equal(lhs.value(), rhs.value(), absolute_error_tolerance_, relative_error_tolerance_); |
| } |
| |
| size_t TimingReporter::estimate_point_print_width(const TimingPath& path) const { |
| size_t width = 60; //default |
| for(auto subpath : {path.clock_launch_path(), path.data_arrival_path(), path.clock_capture_path()}) { |
| for(auto elem : subpath.elements()) { |
| //Take the longest typical point name |
| std::string point = name_resolver_.node_name(elem.node()) + " (" + name_resolver_.node_type_name(elem.node()) + ")"; |
| point += " [clock-to-output]"; |
| |
| //Keep the max over all points |
| width = std::max(width, point.size()); |
| } |
| } |
| return width; |
| } |
| |
| } //namespace tatum |
