vpr: analysis: use structs in --write_timing_usage

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

Author: lpawelcz

vpr/src/base/read_options.cpp

@@ -2477,7 +2477,7 @@ argparse::ArgumentParser create_arg_parser(std::string prog_name, t_options& arg
         .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.")
+        .help("Writes implemented design final timing summary to the specified JSON, XML or TXT file.")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
     auto& power_grp = parser.add_argument_group("power analysis options");

vpr/src/timing/timing_util.cpp

@@ -191,40 +191,85 @@ std::vector<HistogramBucket> create_criticality_histogram(const SetupTimingInfo&
     return histogram;
 }
 
-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";
+void TimingStats::writeHuman(std::ostream& output) const {
+    output << prefix << "critical path delay (least slack): " << least_slack_cpd_delay << " ns";
 
-        fp << "  \"cpd\": " << least_slack_cpd << ",\n";
-        fp << "  \"fmax\": " << fmax << ",\n";
+    //Fmax is only meaningful for a single-clock circuit
+    output << ", Fmax: " << fmax << " MHz";
+    output << "\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";
+    output << prefix << "setup Worst Negative Slack (sWNS): " << setup_worst_neg_slack << " ns\n";
+    output << prefix << "setup Total Negative Slack (sTNS): " << setup_total_neg_slack << " ns\n";
+    output << "\n";
+}
+void TimingStats::writeJSON(std::ostream& output) const {
+    output << "{\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";
+    output << "  \"cpd\": " << least_slack_cpd_delay << ",\n";
+    output << "  \"fmax\": " << fmax << ",\n";
 
-        fp << "</block_usage_report>\n";
-    } else {
-        VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
-                        "Unknown extension on output %s",
-                        timing_summary_filename.c_str());
+    output << "  \"swns\": " << setup_worst_neg_slack << ",\n";
+    output << "  \"stns\": " << setup_total_neg_slack << "\n";
+    output << "}\n";
+}
+
+void TimingStats::writeXML(std::ostream& output) const {
+    output << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    output << "<timing_summary_report>\n";
+
+    output << "  <cpd value=\"" << least_slack_cpd_delay << "\" unit=\"ns\" description=\"Final critical path delay\"></nets>\n";
+    output << "  <fmax value=\"" << fmax << "\" unit=\"MHz\" description=\"Max circuit frequency\"></fmax>\n";
+    output << "  <swns value=\"" << setup_worst_neg_slack << "\" unit=\"ns\" description=\"setup Worst Negative Slack (sWNS)\"></swns>\n";
+    output << "  <stns value=\"" << setup_total_neg_slack << "\" unit=\"ns\" description=\"setup Total Negative Slack (sTNS)\"></stns>\n";
+
+    output << "</block_usage_report>\n";
+}
+
+TimingStats::TimingStats(std::string pref, double cpd, double f_max, double swns, double stns) {
+    least_slack_cpd_delay = cpd;
+    fmax = f_max;
+    setup_worst_neg_slack = swns;
+    setup_total_neg_slack = stns;
+    prefix = pref;
+}
+
+void TimingStats::write(OutputFormat fmt, std::ostream& output) const {
+    switch (fmt) {
+        case HumanReadable:
+            writeHuman(output);
+            break;
+        case JSON:
+            writeJSON(output);
+            break;
+        case XML:
+            writeXML(output);
+            break;
+        default:
+            VPR_FATAL_ERROR(VPR_ERROR_PACK,
+                            "Unknown extension on in timing summary file");
+            break;
+    }
+}
+
+void write_setup_timing_summary(std::string timing_summary_filename, const TimingStats& stats) {
+    if (timing_summary_filename.size() > 0) {
+        TimingStats::OutputFormat fmt;
+
+        if (vtr::check_file_name_extension(timing_summary_filename.c_str(), ".json")) {
+            fmt = TimingStats::OutputFormat::JSON;
+        } else if (vtr::check_file_name_extension(timing_summary_filename.c_str(), ".xml")) {
+            fmt = TimingStats::OutputFormat::XML;
+        } else if (vtr::check_file_name_extension(timing_summary_filename.c_str(), ".txt")) {
+            fmt = TimingStats::OutputFormat::HumanReadable;
+        } else {
+            VPR_FATAL_ERROR(VPR_ERROR_PACK, "Unknown extension on output %s", timing_summary_filename.c_str());
+        }
+
+        std::fstream fp;
+
+        fp.open(timing_summary_filename, std::fstream::out | std::fstream::trunc);
+        stats.write(fmt, fp);
+        fp.close();
     }
 }
 
@@ -243,6 +288,11 @@ void print_setup_timing_summary(const tatum::TimingConstraints& constraints,
     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));
 
+    const auto stats = TimingStats(prefix, least_slack_cpd_delay, fmax,
+                                   setup_worst_neg_slack, setup_total_neg_slack);
+    if (!timing_summary_filename.empty())
+        write_setup_timing_summary(timing_summary_filename, stats);
+
     VTR_LOG("%scritical path delay (least slack): %g ns", prefix.c_str(), least_slack_cpd_delay);
 
     if (crit_paths.size() == 1) {
@@ -258,10 +308,6 @@ void print_setup_timing_summary(const tatum::TimingConstraints& constraints,
     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

@@ -50,12 +50,6 @@ std::vector<HistogramBucket> create_criticality_histogram(const SetupTimingInfo&
 //Print a useful summary of timing information
 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
  */
@@ -219,4 +213,31 @@ tatum::NodeId pin_name_to_tnode(std::string name);
 void write_setup_timing_graph_dot(std::string filename, SetupTimingInfo& timing_info, tatum::NodeId debug_node = tatum::NodeId::INVALID());
 void write_hold_timing_graph_dot(std::string filename, HoldTimingInfo& timing_info, tatum::NodeId debug_node = tatum::NodeId::INVALID());
 
+struct TimingStats {
+  private:
+    void writeHuman(std::ostream& output) const;
+    void writeJSON(std::ostream& output) const;
+    void writeXML(std::ostream& output) const;
+
+  public:
+    TimingStats(std::string prefix, double least_slack_cpd_delay, double fmax, double setup_worst_neg_slack, double setup_total_neg_slack);
+
+    enum OutputFormat {
+        HumanReadable,
+        JSON,
+        XML
+    };
+
+    double least_slack_cpd_delay;
+    double fmax;
+    double setup_worst_neg_slack;
+    double setup_total_neg_slack;
+    std::string prefix;
+
+    void write(OutputFormat fmt, std::ostream& output) const;
+};
+
+//Write a useful summary of timing information to JSON file
+void write_setup_timing_summary(std::string timing_summary_filename, const TimingStats& stats);
+
 #endif