vpr: analysis: optionally write timing summary in JSON or XML file

Signed-off-by: Pawel Czarnecki <[email protected]>

Author: lpawelcz

vpr/src/analysis/timing_reports.cpp

@@ -16,7 +16,7 @@ void generate_setup_timing_stats(const std::string& prefix, const SetupTimingInf
     auto& timing_ctx = g_vpr_ctx.timing();
     auto& atom_ctx = g_vpr_ctx.atom();
 
-    print_setup_timing_summary(*timing_ctx.constraints, *timing_info.setup_analyzer(), "Final ");
+    print_setup_timing_summary(*timing_ctx.constraints, *timing_info.setup_analyzer(), "Final ", analysis_opts.write_timing_summary);
 
     VprTimingGraphResolver resolver(atom_ctx.nlist, atom_ctx.lookup, *timing_ctx.graph, delay_calc);
     resolver.set_detail_level(analysis_opts.timing_report_detail);

vpr/src/base/SetupVPR.cpp

@@ -625,6 +625,7 @@ static void SetupAnalysisOpts(const t_options& Options, t_analysis_opts& analysi
     analysis_opts.echo_dot_timing_graph_node = Options.echo_dot_timing_graph_node;
 
     analysis_opts.timing_update_type = Options.timing_update_type;
+    analysis_opts.write_timing_summary = Options.write_timing_summary;
 }
 
 static void SetupPowerOpts(const t_options& Options, t_power_opts* power_opts, t_arch* Arch) {

vpr/src/base/read_options.cpp

@@ -2476,6 +2476,10 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .default_value("-1")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    analysis_grp.add_argument(args.write_timing_summary, "--write_timing_summary")
+        .help("Writes implemented design final timing summary to the specified JSON or XML file.")
+        .show_in(argparse::ShowIn::HELP_ONLY);
+
     auto& power_grp = parser.add_argument_group("power analysis options");
 
     power_grp.add_argument<bool, ParseOnOff>(args.do_power, "--power")

vpr/src/base/read_options.h

@@ -210,6 +210,7 @@ struct t_options {
     argparse::ArgValue<e_timing_report_detail> timing_report_detail;
     argparse::ArgValue<bool> timing_report_skew;
     argparse::ArgValue<std::string> echo_dot_timing_graph_node;
+    argparse::ArgValue<std::string> write_timing_summary;
 };
 
 argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& args);

vpr/src/base/vpr_types.h

@@ -1292,6 +1292,7 @@ struct t_analysis_opts {
     e_timing_report_detail timing_report_detail;
     bool timing_report_skew;
     std::string echo_dot_timing_graph_node;
+    std::string write_timing_summary;
 
     e_timing_update_type timing_update_type;
 };

vpr/src/place/place.cpp

@@ -950,7 +950,7 @@ void try_place(const t_placer_opts& placer_opts,
         /* Print critical path delay metrics */
         VTR_LOG("\n");
         print_setup_timing_summary(*timing_ctx.constraints,
-                                   *timing_info->setup_analyzer(), "Placement estimated ");
+                                   *timing_info->setup_analyzer(), "Placement estimated ", "");
     }
 
     sprintf(msg,

vpr/src/timing/timing_util.cpp

@@ -191,27 +191,77 @@ std::vector<HistogramBucket> create_criticality_histogram(const SetupTimingInfo&
     return histogram;
 }
 
-void print_setup_timing_summary(const tatum::TimingConstraints& constraints, const tatum::SetupTimingAnalyzer& setup_analyzer, std::string prefix) {
+void write_setup_timing_summary(std::string timing_summary_filename,
+                                double least_slack_cpd,
+                                double fmax,
+                                double setup_worst_neg_slack,
+                                double setup_total_neg_slack) {
+    if (vtr::check_file_name_extension(timing_summary_filename.c_str(), ".json")) {
+        // write report in JSON format
+        std::fstream fp;
+        fp.open(timing_summary_filename, std::fstream::out | std::fstream::trunc);
+        fp << "{\n";
+
+        fp << "  \"cpd\": " << least_slack_cpd << ",\n";
+        fp << "  \"fmax\": " << fmax << ",\n";
+
+        fp << "  \"swns\": " << setup_worst_neg_slack << ",\n";
+        fp << "  \"stns\": " << setup_total_neg_slack << "\n";
+        fp << "}\n";
+    } else if (vtr::check_file_name_extension(timing_summary_filename.c_str(), ".xml")) {
+        // write report in XML format
+        std::fstream fp;
+        fp.open(timing_summary_filename, std::fstream::out | std::fstream::trunc);
+        fp << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+        fp << "<timing_summary_report>\n";
+
+        fp << "  <cpd value=\"" << least_slack_cpd << "\" unit=\"ns\" description=\"Final critical path delay\"></nets>\n";
+        fp << "  <fmax value=\"" << fmax << "\" unit=\"MHz\" description=\"Max circuit frequency\"></fmax>\n";
+        fp << "  <swns value=\"" << setup_worst_neg_slack << "\" unit=\"ns\" description=\"setup Worst Negative Slack (sWNS)\"></swns>\n";
+        fp << "  <stns value=\"" << setup_total_neg_slack << "\" unit=\"ns\" description=\"setup Total Negative Slack (sTNS)\"></stns>\n";
+
+        fp << "</block_usage_report>\n";
+    } else {
+        VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
+                        "Unknown extension on output %s",
+                        timing_summary_filename.c_str());
+    }
+}
+
+void print_setup_timing_summary(const tatum::TimingConstraints& constraints,
+                                const tatum::SetupTimingAnalyzer& setup_analyzer,
+                                std::string prefix,
+                                std::string timing_summary_filename) {
     auto& timing_ctx = g_vpr_ctx.timing();
 
     auto crit_paths = tatum::find_critical_paths(*timing_ctx.graph, constraints, setup_analyzer);
 
     auto least_slack_cpd = find_least_slack_critical_path_delay(constraints, setup_analyzer);
-    VTR_LOG("%scritical path delay (least slack): %g ns", prefix.c_str(), sec_to_nanosec(least_slack_cpd.delay()));
+
+    double least_slack_cpd_delay = sec_to_nanosec(least_slack_cpd.delay());
+    double fmax = sec_to_mhz(least_slack_cpd.delay());
+    double setup_worst_neg_slack = sec_to_nanosec(find_setup_worst_negative_slack(setup_analyzer));
+    double setup_total_neg_slack = sec_to_nanosec(find_setup_total_negative_slack(setup_analyzer));
+
+    VTR_LOG("%scritical path delay (least slack): %g ns", prefix.c_str(), least_slack_cpd_delay);
 
     if (crit_paths.size() == 1) {
         //Fmax is only meaningful for a single-clock circuit
-        VTR_LOG(", Fmax: %g MHz", sec_to_mhz(least_slack_cpd.delay()));
+        VTR_LOG(", Fmax: %g MHz", fmax);
     }
     VTR_LOG("\n");
 
-    VTR_LOG("%ssetup Worst Negative Slack (sWNS): %g ns\n", prefix.c_str(), sec_to_nanosec(find_setup_worst_negative_slack(setup_analyzer)));
-    VTR_LOG("%ssetup Total Negative Slack (sTNS): %g ns\n", prefix.c_str(), sec_to_nanosec(find_setup_total_negative_slack(setup_analyzer)));
+    VTR_LOG("%ssetup Worst Negative Slack (sWNS): %g ns\n", prefix.c_str(), setup_worst_neg_slack);
+    VTR_LOG("%ssetup Total Negative Slack (sTNS): %g ns\n", prefix.c_str(), setup_total_neg_slack);
     VTR_LOG("\n");
 
     VTR_LOG("%ssetup slack histogram:\n", prefix.c_str());
     print_histogram(create_setup_slack_histogram(setup_analyzer));
 
+    if (!timing_summary_filename.empty())
+        write_setup_timing_summary(timing_summary_filename, least_slack_cpd_delay,
+                                   fmax, setup_worst_neg_slack, setup_total_neg_slack);
+
     if (crit_paths.size() > 1) {
         //Multi-clock
         VTR_LOG("\n");

vpr/src/timing/timing_util.h

@@ -48,8 +48,14 @@ std::vector<HistogramBucket> create_criticality_histogram(const SetupTimingInfo&
                                                           size_t num_bins = 10);
 
 //Print a useful summary of timing information
-void print_setup_timing_summary(const tatum::TimingConstraints& constraints, const tatum::SetupTimingAnalyzer& setup_analyzer, std::string prefix);
-
+void print_setup_timing_summary(const tatum::TimingConstraints& constraints, const tatum::SetupTimingAnalyzer& setup_analyzer, std::string prefix, std::string timing_summary_filename);
+
+//Write a useful summary of timing information to JSON file
+void write_setup_timing_summary(std::string timing_summary_filename,
+                                double least_slack_cpd,
+                                double fmax,
+                                double setup_worst_neg_slack,
+                                double setup_total_neg_slack);
 /*
  * Hold-time related statistics
  */