riscv
/
OpenFPGA
mirror of https://github.com/lnis-uofu/OpenFPGA.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
OpenFPGA/libs/EXTERNAL/libtatum/tatum_test/main.cpp

615 lines
30 KiB
C++
Raw Normal View History

add missing tatum
2020-01-03 21:42:17 -06:00
#include <ctime>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <memory>
#include <numeric>
#include <iomanip>
#include "tatum/util/tatum_assert.hpp"
#include "tatum/timing_analyzers.hpp"
#include "tatum/graph_walkers.hpp"
#include "tatum/analyzer_factory.hpp"
#include "tatum/TimingGraph.hpp"
#include "tatum/TimingConstraints.hpp"
#include "tatum/TimingReporter.hpp"
#include "tatum/report/NodeNumNameResolver.hpp"
#include "tatum/timing_paths.hpp"
#include "tatum/delay_calc/FixedDelayCalculator.hpp"
#include "tatum/report/graphviz_dot_writer.hpp"
#include "tatum/base/sta_util.hpp"
#include "tatum/echo_writer.hpp"
#include "golden_reference.hpp"
#include "echo_loader.hpp"
#include "verify.hpp"
#include "util.hpp"
#include "profile.hpp"
#if defined(TATUM_USE_TBB)
# include <tbb/task_scheduler_init.h>
#endif
typedef std::chrono::duration<double> dsec;
typedef std::chrono::high_resolution_clock Clock;
using std::cout;
using std::endl;
using tatum::Time;
using tatum::TimingTag;
using tatum::TimingTags;
using tatum::TimingGraph;
using tatum::TimingConstraints;
using tatum::NodeId;
using tatum::EdgeId;
using tatum::DomainId;
struct Args {
//Input file to load
std::string input_file = "";
//Concurrency (0 is machine concurrency)
size_t num_workers = 0;
//Number of serial runs to perform
size_t num_serial_runs = 10;
//Number of parallel runs to perform
size_t num_parallel_runs = 30;
//Use unit delays instead of from file?
float unit_delay = 0;
//Write an echo file of resutls?
std::string write_echo;
//Optimize graph memory layout?
size_t opt_graph_layout = 0;
//Print tag size info
size_t print_sizes = 0;
//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.
int debug_dot_node = -1;
};
void usage(std::string prog);
void cmd_error(std::string prog, std::string msg);
Args parse_args(int argc, char** argv);
double median(std::vector<double> values);
double arithmean(std::vector<double> values);
void usage(std::string prog) {
Args default_args;
cout << "Usage: " << prog << " [options] tg_file\n";
cout << "\n";
cout << " Positional Arguments:\n";
cout << " tg_file: The input file (or '-' for stdin)\n";
cout << "\n";
cout << " Options:\n";
cout << " --num_workers NUM_WORKERS: Number of parallel workers.\n";
cout << " 0 implies machine concurrency.\n";
cout << " (default " << default_args.num_workers << ")\n";
cout << " --num_serial NUM_SERIAL_RUNS: Number of serial runs to perform.\n";
cout << " (default " << default_args.num_serial_runs << ")\n";
cout << " --num_parallel NUM_PARALLEL_RUNS: Number of serial runs to perform.\n";
cout << " (default " << default_args.num_parallel_runs << ")\n";
cout << " --unit_delay UNIT_DELAY: Use specified unit delay for all edges.\n";
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 << " 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 < -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.debug_dot_node << ")\n";
}
void cmd_error(std::string prog, std::string msg) {
cout << "Error: " << msg << "\n";
cout << "\n";
usage(prog);
exit(1);
}
Args parse_args(int argc, char** argv) {
Args args;
auto prog = argv[0];
for (int i = 0; i < argc; ++i) {
cout << argv[i] << " ";
}
cout << "\n";
int i = 1;
while (i < argc) {
std::string arg_str(argv[i]);
if (arg_str == "-h" || arg_str == "--help") {
usage(prog);
exit(0);
} else if (arg_str.size() >= 2 && arg_str[0] == '-' && arg_str[1] == '-') {
if (arg_str == "--write_echo") {
args.write_echo = argv[i+1];
} else {
std::istringstream ss(argv[i+1]);
float arg_val;
ss >> arg_val;
if (ss.fail() || !ss.eof()) {
std::stringstream msg;
msg << "Invalid option value '" << argv[i+1] << "'\n";
cmd_error(prog, msg.str());
}
if (arg_str == "--num_workers") {
args.num_workers = arg_val;
} else if (argv[i] == std::string("--num_serial")) {
args.num_serial_runs = arg_val;
} else if (argv[i] == std::string("--num_parallel")) {
args.num_parallel_runs = arg_val;
} else if (argv[i] == std::string("--unit_delay")) {
args.unit_delay = arg_val;
} else if (argv[i] == std::string("--opt_graph_layout")) {
args.opt_graph_layout = arg_val;
} else if (argv[i] == std::string("--verify")) {
args.verify = arg_val;
} else if (argv[i] == std::string("--print_sizes")) {
args.print_sizes = 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 {
std::stringstream msg;
msg << "Invalid option '" << arg_str << "'\n";
cmd_error(prog, msg.str());
}
}
i += 2;
} else {
if (i == argc - 1) {
args.input_file = arg_str;
} else {
std::stringstream msg;
msg << "Unrecognized positional argument '" << arg_str<< "'\n";
cmd_error(prog, msg.str());
}
i++;
}
}
if (args.input_file.empty()) {
cmd_error(prog, "Missing required positional argument 'tg_file'");
}
return args;
}
int main(int argc, char** argv) {
Args args = parse_args(argc, argv);
int exit_code = 0;
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);
if (args.print_sizes) {
cout << "Time class sizeof = " << sizeof(Time) << " bytes. Time Vec Width: " << TIME_VEC_WIDTH << endl;
cout << "Time class alignof = " << alignof(Time) << endl;
cout << "TimingTag class sizeof = " << sizeof(TimingTag) << " bytes." << endl;
cout << "TimingTag class alignof = " << alignof(TimingTag) << " bytes." << endl;
cout << "TimingTags class sizeof = " << sizeof(TimingTags) << " bytes." << endl;
cout << "TimingTags class alignof = " << alignof(TimingTags) << " bytes." << endl;
cout << "NodeId class sizeof = " << sizeof(tatum::NodeId) << " bytes." << endl;
cout << "NodeId class alignof = " << alignof(tatum::NodeId) << " bytes." << endl;
cout << "EdgeId class sizeof = " << sizeof(tatum::EdgeId) << " bytes." << endl;
cout << "EdgeId class alignof = " << alignof(tatum::EdgeId) << " bytes." << endl;
cout << "DomainId class sizeof = " << sizeof(tatum::DomainId) << " bytes." << endl;
cout << "DomainId class alignof = " << alignof(tatum::DomainId) << " bytes." << endl;
cout << "TagType class sizeof = " << sizeof(tatum::TagType) << " bytes." << endl;
cout << "TagType class alignof = " << alignof(tatum::TagType) << " bytes." << endl;
cout << "NodeType class sizeof = " << sizeof(tatum::NodeType) << " bytes." << endl;
cout << "NodeType class alignof = " << alignof(tatum::NodeType) << " bytes." << endl;
}
#if defined(TATUM_USE_TBB)
size_t actual_num_workers = args.num_workers;
if (actual_num_workers == 0) {
actual_num_workers = tbb::task_scheduler_init::default_num_threads();
}
auto tbb_scheduler = std::make_unique<tbb::task_scheduler_init>(actual_num_workers);
cout << "Tatum executing with up to " << actual_num_workers << " workers via TBB\n";
#else //Serial
cout << "Tatum built with only serial execution support, ignoring --num_workers != 1\n";
#endif
//Raw outputs of parser
std::shared_ptr<TimingGraph> timing_graph;
std::shared_ptr<TimingConstraints> timing_constraints;
std::shared_ptr<tatum::FixedDelayCalculator> delay_calculator;
std::shared_ptr<GoldenReference> golden_reference;
{
clock_gettime(CLOCK_MONOTONIC, &load_start);
//Load the echo file
EchoLoader loader;
if(args.input_file == "-") {
tatum_parse_file(stdin, loader);
} else {
tatum_parse_filename(args.input_file, loader);
}
timing_graph = loader.timing_graph();
timing_graph->set_allow_dangling_combinational_nodes(true);
timing_constraints = loader.timing_constraints();
if (args.unit_delay) {
delay_calculator = std::make_shared<tatum::FixedDelayCalculator>(
tatum::util::linear_map<tatum::EdgeId,tatum::Time>(timing_graph->edges().size(), tatum::Time(args.unit_delay)),
tatum::util::linear_map<tatum::EdgeId,tatum::Time>(timing_graph->edges().size(), tatum::Time(args.unit_delay)),
tatum::util::linear_map<tatum::EdgeId,tatum::Time>(timing_graph->edges().size(), tatum::Time(args.unit_delay)),
tatum::util::linear_map<tatum::EdgeId,tatum::Time>(timing_graph->edges().size(), tatum::Time(args.unit_delay)));
} else {
delay_calculator = loader.delay_calculator();
}
golden_reference = loader.golden_reference();
clock_gettime(CLOCK_MONOTONIC, &load_end);
cout << "Loading took: " << tatum::time_sec(load_start, load_end) << " sec" << endl;
cout << endl;
}
timing_constraints->print_constraints();
timing_graph->levelize();
timing_graph->validate();
cout << "Timing Graph Nodes: " << timing_graph->nodes().size() << "\n";
cout << "Timing Graph Edges: " << timing_graph->edges().size() << "\n";
cout << "Timing Graph Levels: " << timing_graph->levels().size() << "\n";
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);
golden_reference->remap_nodes(id_maps.node_id_map);
}
/*
*timing_constraints->print();
*/
int n_histo_bins = 10;
tatum::print_level_histogram(*timing_graph, n_histo_bins);
tatum::print_node_fanin_histogram(*timing_graph, n_histo_bins);
tatum::print_node_fanout_histogram(*timing_graph, n_histo_bins);
cout << endl;
/*
*cout << "Timing Graph" << endl;
*print_timing_graph(timing_graph);
*cout << endl;
*/
/*
*cout << "Levelization" << endl;
*print_levelization(timing_graph);
*cout << endl;
*/
std::ofstream ofs(args.write_echo);
if (!args.write_echo.empty()) {
tatum::write_timing_graph(ofs, *timing_graph);
tatum::write_timing_constraints(ofs, *timing_constraints);
tatum::write_delay_model(ofs, *timing_graph, *delay_calculator);
ofs.flush();
}
//Make all the analyzer types to test templates
std::shared_ptr<tatum::TimingAnalyzer> setup_analyzer = tatum::AnalyzerFactory<tatum::SetupAnalysis>::make(*timing_graph, *timing_constraints, *delay_calculator);
std::shared_ptr<tatum::TimingAnalyzer> hold_analyzer = tatum::AnalyzerFactory<tatum::SetupAnalysis>::make(*timing_graph, *timing_constraints, *delay_calculator);
std::shared_ptr<tatum::TimingAnalyzer> setup_hold_analyzer = tatum::AnalyzerFactory<tatum::SetupHoldAnalysis>::make(*timing_graph, *timing_constraints, *delay_calculator);
//Create the timing analyzer
std::shared_ptr<tatum::TimingAnalyzer> serial_analyzer = tatum::AnalyzerFactory<tatum::SetupHoldAnalysis>::make(*timing_graph, *timing_constraints, *delay_calculator);
auto serial_setup_analyzer = std::dynamic_pointer_cast<tatum::SetupTimingAnalyzer>(serial_analyzer);
auto serial_hold_analyzer = std::dynamic_pointer_cast<tatum::HoldTimingAnalyzer>(serial_analyzer);
//Performance variables
float serial_verify_time = 0.;
size_t serial_tags_verified = 0;
std::map<std::string,std::vector<double>> serial_prof_data;
{
cout << "Running Serial Analysis " << args.num_serial_runs << " times" << endl;
serial_prof_data = profile(args.num_serial_runs, serial_analyzer);
cout << "\n";
if(serial_analyzer->num_unconstrained_startpoints() > 0) {
cout << "Warning: " << serial_analyzer->num_unconstrained_startpoints() << " sources are unconstrained\n";
}
if(serial_analyzer->num_unconstrained_endpoints() > 0) {
cout << "Warning: " << serial_analyzer->num_unconstrained_endpoints() << " sinks are unconstrained\n";
}
tatum::NodeNumResolver name_resolver(*timing_graph, *delay_calculator, false);
tatum::TimingReporter timing_reporter(name_resolver, *timing_graph, *timing_constraints);
tatum::NodeNumResolver detailed_name_resolver(*timing_graph, *delay_calculator, true);
tatum::TimingReporter detailed_timing_reporter(detailed_name_resolver, *timing_graph, *timing_constraints);
auto dot_writer = make_graphviz_dot_writer(*timing_graph, *delay_calculator);
std::vector<NodeId> nodes;
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);
std::shared_ptr<tatum::SetupTimingAnalyzer> echo_setup_analyzer = std::dynamic_pointer_cast<tatum::SetupTimingAnalyzer>(serial_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);
timing_reporter.report_skew_setup("report_skew.setup.rpt", *echo_setup_analyzer);
timing_reporter.report_unconstrained_setup("report_unconstrained_timing.setup.rpt", *echo_setup_analyzer);
detailed_timing_reporter.report_timing_setup("report_timing_detailed.setup.rpt", *echo_setup_analyzer);
detailed_timing_reporter.report_skew_setup("report_skew_detailed.setup.rpt", *echo_setup_analyzer);
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(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);
timing_reporter.report_skew_hold("report_skew.hold.rpt", *echo_hold_analyzer);
timing_reporter.report_unconstrained_hold("report_unconstrained_timing.hold.rpt", *echo_hold_analyzer);
detailed_timing_reporter.report_timing_hold("report_timing_detailed.hold.rpt", *echo_hold_analyzer);
detailed_timing_reporter.report_skew_hold("report_skew_detailed.hold.rpt", *echo_hold_analyzer);
detailed_timing_reporter.report_unconstrained_hold("report_unconstrained_timing_detailed.hold.rpt", *echo_hold_analyzer);
}
//Verify
clock_gettime(CLOCK_MONOTONIC, &verify_start);
if (args.verify) {
auto res = verify_analyzer(*timing_graph, serial_analyzer, *golden_reference);
serial_tags_verified = res.first;
if(!res.second) {
cout << "Verification failed!\n";
exit_code = 1;
}
}
clock_gettime(CLOCK_MONOTONIC, &verify_end);
serial_verify_time += tatum::time_sec(verify_start, verify_end);
cout << endl;
cout << "Serial Analysis took " << std::setprecision(6) << std::setw(6) << arithmean(serial_prof_data["analysis_sec"])*args.num_serial_runs << " sec";
if(serial_prof_data["analysis_sec"].size() > 0) {
cout << " AVG: " << arithmean(serial_prof_data["analysis_sec"]);
cout << " Median: " << median(serial_prof_data["analysis_sec"]);
cout << " Min: " << *std::min_element(serial_prof_data["analysis_sec"].begin(), serial_prof_data["analysis_sec"].end());
cout << " Max: " << *std::max_element(serial_prof_data["analysis_sec"].begin(), serial_prof_data["analysis_sec"].end());
}
cout << endl;
cout << "\tReset Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["reset_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["reset_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tArr Pre-traversal Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["arrival_pre_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["arrival_pre_traversal_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tReq Pre-traversal Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["required_pre_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["required_pre_traversal_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tArr traversal Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["arrival_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["arrival_traversal_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tReq traversal Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["required_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["required_traversal_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tUpdate slack Median: " << std::setprecision(6) << std::setw(6) << median(serial_prof_data["update_slack_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(serial_prof_data["update_slack_sec"])/median(serial_prof_data["analysis_sec"]) << ")" << endl;
cout << "Verifying Serial Analysis took: " << serial_verify_time << " sec" << endl;
if(serial_tags_verified != golden_reference->num_tags() && serial_tags_verified != golden_reference->num_tags() / 2) {
//Potentially alow / 2 for setup only analysis from setup/hold golden
cout << "WARNING: Expected tags (" << golden_reference->num_tags() << ") differs from tags checked (" << serial_tags_verified << ") , verification may not have occured!" << endl;
} else {
cout << "\tVerified " << serial_tags_verified << " tags (expected " << golden_reference->num_tags() << " or " << golden_reference->num_tags()/2 << ") accross " << timing_graph->nodes().size() << " nodes" << endl;
}
cout << endl;
cout << endl << "Net Serial Analysis elapsed time: " << serial_analyzer->get_profiling_data("total_analysis_sec") << " sec over " << serial_analyzer->get_profiling_data("num_full_updates") << " full updates" << endl;
}
if (!args.write_echo.empty()) {
tatum::write_analysis_result(ofs, *timing_graph, serial_analyzer);
ofs.flush();
}
std::cout << endl;
if (args.num_parallel_runs) {
std::shared_ptr<tatum::TimingAnalyzer> parallel_analyzer = tatum::AnalyzerFactory<tatum::SetupHoldAnalysis,tatum::ParallelWalker>::make(*timing_graph, *timing_constraints, *delay_calculator);
auto parallel_setup_analyzer = std::dynamic_pointer_cast<tatum::SetupTimingAnalyzer>(parallel_analyzer);
auto parallel_hold_analyzer = std::dynamic_pointer_cast<tatum::HoldTimingAnalyzer>(parallel_analyzer);
float parallel_verify_time = 0;
size_t parallel_tags_verified = 0;
std::map<std::string,std::vector<double>> parallel_prof_data;
{
cout << "Running Parrallel Analysis " << args.num_parallel_runs << " times" << endl;
//Analyze
parallel_prof_data = profile(args.num_parallel_runs, parallel_analyzer);
//Verify
clock_gettime(CLOCK_MONOTONIC, &verify_start);
if (args.verify) {
cout << "\n";
auto res = verify_analyzer(*timing_graph, parallel_analyzer, *golden_reference);
parallel_tags_verified = res.first;
if(!res.second) {
cout << "Verification failed!\n";
exit_code = 1;
}
}
clock_gettime(CLOCK_MONOTONIC, &verify_end);
parallel_verify_time += tatum::time_sec(verify_start, verify_end);
cout << endl;
cout << "Parallel Analysis took " << std::setprecision(6) << std::setw(6) << arithmean(parallel_prof_data["analysis_sec"])*args.num_parallel_runs << " sec";
if(parallel_prof_data["analysis_sec"].size() > 0) {
cout << " AVG: " << arithmean(parallel_prof_data["analysis_sec"]);
cout << " Median: " << median(parallel_prof_data["analysis_sec"]);
cout << " Min: " << *std::min_element(parallel_prof_data["analysis_sec"].begin(), parallel_prof_data["analysis_sec"].end());
cout << " Max: " << *std::max_element(parallel_prof_data["analysis_sec"].begin(), parallel_prof_data["analysis_sec"].end());
}
cout << endl;
cout << "\tReset Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["reset_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["reset_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tArr Pre-traversal Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["arrival_pre_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["arrival_pre_traversal_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tReq Pre-traversal Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["required_pre_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["required_pre_traversal_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tArr traversal Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["arrival_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["arrival_traversal_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tReq traversal Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["required_traversal_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["required_traversal_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "\tUpdate slack Median: " << std::setprecision(6) << std::setw(6) << median(parallel_prof_data["update_slack_sec"]) << " s";
cout << " (" << std::setprecision(2) << median(parallel_prof_data["update_slack_sec"])/median(parallel_prof_data["analysis_sec"]) << ")" << endl;
cout << "Verifying Parallel Analysis took: " << parallel_verify_time<< " sec" << endl;
if(parallel_tags_verified != golden_reference->num_tags() && parallel_tags_verified != golden_reference->num_tags()/2) {
//Potentially alow / 2 for setup only analysis from setup/hold golden
cout << "WARNING: Expected tags (" << golden_reference->num_tags() << ") differs from tags checked (" << serial_tags_verified << ") , verification may not have occured!" << endl;
} else {
cout << "\tVerified " << serial_tags_verified << " tags (expected " << golden_reference->num_tags() << " or " << golden_reference->num_tags()/2 << ") accross " << timing_graph->nodes().size() << " nodes" << endl;
}
}
cout << endl;
cout << "Parallel Speed-Up: " << std::fixed << median(serial_prof_data["analysis_sec"]) / median(parallel_prof_data["analysis_sec"]) << "x" << endl;
cout << "\t Reset: " << std::fixed << median(serial_prof_data["reset_sec"]) / median(parallel_prof_data["reset_sec"]) << "x" << endl;
cout << "\tArr Pre-traversal: " << std::fixed << median(serial_prof_data["arrival_pre_traversal_sec"]) / median(parallel_prof_data["arrival_pre_traversal_sec"]) << "x" << endl;
cout << "\tReq Pre-traversal: " << std::fixed << median(serial_prof_data["required_pre_traversal_sec"]) / median(parallel_prof_data["required_pre_traversal_sec"]) << "x" << endl;
cout << "\t Arr-traversal: " << std::fixed << median(serial_prof_data["arrival_traversal_sec"]) / median(parallel_prof_data["arrival_traversal_sec"]) << "x" << endl;
cout << "\t Req-traversal: " << std::fixed << median(serial_prof_data["required_traversal_sec"]) / median(parallel_prof_data["required_traversal_sec"]) << "x" << endl;
cout << "\t Update-slack: " << std::fixed << median(serial_prof_data["update_slack_sec"]) / median(parallel_prof_data["update_slack_sec"]) << "x" << endl;
cout << endl;
cout << endl << "Net Parallel Analysis elapsed time: " << parallel_analyzer->get_profiling_data("total_analysis_sec") << " sec over " << parallel_analyzer->get_profiling_data("num_full_updates") << " full updates" << endl;
}
//Tag stats
if(serial_setup_analyzer) {
print_setup_tags_histogram(*timing_graph, *serial_setup_analyzer);
}
if(serial_hold_analyzer) {
print_hold_tags_histogram(*timing_graph, *serial_hold_analyzer);
}
//Critical paths
cout << "\nCritical Paths:\n";
auto cpds = find_critical_paths(*timing_graph, *timing_constraints, *serial_setup_analyzer);
for(auto cpd : cpds) {
cout << " " << cpd.launch_domain() << " -> " << cpd.capture_domain() << ": " << std::scientific << cpd.delay() << "\n";
}
clock_gettime(CLOCK_MONOTONIC, &prog_end);
cout << endl << "Total time: " << tatum::time_sec(prog_start, prog_end) << " sec" << endl;
return exit_code;
}
double median(std::vector<double> values) {
std::sort(values.begin(), values.end());
if(values.size() % 2 == 0) {
return(values[values.size() / 2 - 1] + values[values.size() / 2]) / 2;
} else {
return values[values.size() / 2];
}
}
double arithmean(std::vector<double> values) {
return std::accumulate(values.begin(), values.end(), 0.) / values.size();
}