Merge pull request #3023 from verilog-to-routing/routing_path_timing

[Analysis] Printing Nets timing Information

Author: vaughnbetz

doc/src/vpr/command_line_usage.rst

@@ -1517,6 +1517,35 @@ VPR uses a negotiated congestion algorithm (based on Pathfinder) to perform rout
     * `swns` - setup Worst Negative Slack (sWNS) [ns]
     * `stns` - Setup Total Negative Slack (sTNS) [ns]
 
+
+.. option:: --generate_net_timing_report {on | off}
+
+    Generates a report that lists the bounding box, slack, and delay of every routed connection in a design in CSV format (``report_net_timing.csv``). Each row in the CSV corresponds to a single net.
+
+    The report can later be used by other tools to enable further optimizations. For example, the Synopsys synthesis tool (Synplify) can use this information to re-synthesize the design and improve the Quality of Results (QoR).
+
+    Fields in the report are:
+
+    .. code-block:: none
+        
+        netname         : The name assigned to the net in the atom netlist
+        Fanout          : Net's fanout (number of sinks)
+        bb_xmin         : X coordinate of the net's bounding box's bottom-left corner
+        bb_ymin         : Y coordinate of the net's bounding box's bottom-left corner
+        bb_layer_min    : Lowest layer number of the net's bounding box
+        bb_xmax         : X coordinate of the net's bounding box's top-right corner
+        bb_ymax         : Y coordinate of the net's bounding box's top-right corner
+        bb_layer_max    : Highest layer number of the net's bounding box
+        src_pin_name    : Name of the net's source pin
+        src_pin_slack   : Setup slack of the net's source pin
+        sinks           : A semicolon-separated list of sink pin entries, each in the format:
+                          <sink_pin_name>,<sink_pin_slack>,<sink_pin_delay>
+
+    Example value for the ``sinks`` field:
+    ``"U2.B,0.12,0.5;U3.C,0.10,0.6;U4.D,0.08,0.7"``
+
+    **Default:** ``off``
+
 .. option:: --route_verbosity <int>
 
     Controls the verbosity of routing output.

vpr/src/analysis/timing_reports.cpp

@@ -1,7 +1,14 @@
 #include "timing_reports.h"
 
+#include <fstream>
+#include <sstream>
+
+#include "timing_reports.h"
+#include "rr_graph.h"
+
 #include "tatum/TimingReporter.hpp"
 
+#include "vtr_version.h"
 #include "vpr_types.h"
 #include "globals.h"
 
@@ -10,6 +17,117 @@
 
 #include "VprTimingGraphResolver.h"
 
+/**
+ * @brief Get the bounding box of a routed net.
+ * If the net is completely absorbed into a cluster block, return the bounding box of the cluster block.
+ * Otherwise, return the bounding box of the net's route tree.
+ * 
+ * @param atom_net_id The id of the atom net to get the bounding box of.
+ * 
+ * @return The bounding box of the net. If the net is not routed, a bounding box 
+ * is returned with default values (OPEN).
+ */
+static t_bb get_net_bounding_box(const AtomNetId atom_net_id) {
+    const auto& route_trees = g_vpr_ctx.routing().route_trees;
+    const auto& rr_graph = g_vpr_ctx.device().rr_graph;
+
+    // Lambda to get the bounding box of a route tree
+    auto route_tree_bb = [&](const RouteTree& route_tree) {
+        t_bb bb;
+
+        // Set the initial bounding box to the root node's location
+        RRNodeId route_tree_root = route_tree.root().inode;
+        bb.xmin = rr_graph.node_xlow(route_tree_root);
+        bb.xmax = rr_graph.node_xhigh(route_tree_root);
+        bb.ymin = rr_graph.node_ylow(route_tree_root);
+        bb.ymax = rr_graph.node_yhigh(route_tree_root);
+        bb.layer_min = rr_graph.node_layer(route_tree_root);
+        bb.layer_max = rr_graph.node_layer(route_tree_root);
+
+        // Iterate over all nodes in the route tree and update the bounding box
+        for (auto& rt_node : route_tree.all_nodes()) {
+            RRNodeId inode = rt_node.inode;
+
+            bb.xmin = std::min(static_cast<int>(rr_graph.node_xlow(inode)), bb.xmin);
+            bb.xmax = std::max(static_cast<int>(rr_graph.node_xhigh(inode)), bb.xmax);
+
+            bb.ymin = std::min(static_cast<int>(rr_graph.node_ylow(inode)), bb.ymin);
+            bb.ymax = std::max(static_cast<int>(rr_graph.node_yhigh(inode)), bb.ymax);
+
+            bb.layer_min = std::min(static_cast<int>(rr_graph.node_layer(inode)), bb.layer_min);
+            bb.layer_max = std::max(static_cast<int>(rr_graph.node_layer(inode)), bb.layer_max);
+        }
+        return bb;
+    };
+
+    if (g_vpr_ctx.routing().is_flat) {
+        // If flat router is used, route tree data structure can be used
+        // directly to get the bounding box of the net
+        const auto& route_tree = route_trees[atom_net_id];
+        if (!route_tree)
+            return t_bb();
+        return route_tree_bb(*route_tree);
+    } else {
+        // If two-stage router is used, we need to first get the cluster net id
+        // corresponding to the atom net and then get the bounding box of the net
+        // from the route tree. If the net is completely absorbed into a cluster block,
+        const auto& atom_lookup = g_vpr_ctx.atom().lookup();
+        const auto& cluster_net_id = atom_lookup.clb_nets(atom_net_id);
+        std::vector<t_bb> bbs;
+        t_bb max_bb;
+        // There maybe multiple cluster nets corresponding to a single atom net.
+        // We iterate over all cluster nets and the final bounding box is the union
+        // of all cluster net bounding boxes
+        if (cluster_net_id != vtr::nullopt) {
+            for (const auto& clb_net_id : *cluster_net_id) {
+                const auto& route_tree = route_trees[clb_net_id];
+                if (!route_tree)
+                    continue;
+                bbs.push_back(route_tree_bb(*route_tree));
+            }
+            if (bbs.empty()) {
+                return t_bb();
+            }
+            // Assign the first cluster net's bounding box to the final bounding box
+            // and then iteratively update it with the union of bounding boxes of
+            // all cluster nets
+            max_bb = bbs[0];
+            for (size_t i = 1; i < bbs.size(); ++i) {
+                max_bb.xmin = std::min(bbs[i].xmin, max_bb.xmin);
+                max_bb.xmax = std::max(bbs[i].xmax, max_bb.xmax);
+                max_bb.ymin = std::min(bbs[i].ymin, max_bb.ymin);
+                max_bb.ymax = std::max(bbs[i].ymax, max_bb.ymax);
+                max_bb.layer_min = std::min(bbs[i].layer_min, max_bb.layer_min);
+                max_bb.layer_max = std::max(bbs[i].layer_max, max_bb.layer_max);
+            }
+            return max_bb;
+        } else {
+            // If there is no cluster net corresponding to the atom net,
+            // it means the net is completely absorbed into a cluster block.
+            // In that case, we set the bounding box the cluster block's bounding box
+            const auto& atom_ctx = g_vpr_ctx.atom();
+            const auto& atom_nlist = atom_ctx.netlist();
+            AtomPinId source_pin = atom_nlist.net_driver(atom_net_id);
+
+            AtomBlockId atom_block = atom_nlist.pin_block(source_pin);
+            VTR_ASSERT(atom_block != AtomBlockId::INVALID());
+            ClusterBlockId cluster_block = atom_lookup.atom_clb(atom_block);
+            VTR_ASSERT(cluster_block != ClusterBlockId::INVALID());
+
+            const t_pl_loc& cluster_block_loc = g_vpr_ctx.placement().block_locs()[cluster_block].loc;
+            const auto& grid = g_vpr_ctx.device().grid;
+            vtr::Rect<int> tile_bb = grid.get_tile_bb({cluster_block_loc.x, cluster_block_loc.y, cluster_block_loc.layer});
+            const int block_layer = cluster_block_loc.layer;
+            return t_bb(tile_bb.xmin(),
+                        tile_bb.xmax(),
+                        tile_bb.ymin(),
+                        tile_bb.ymax(),
+                        block_layer,
+                        block_layer);
+        }
+    }
+}
+
 void generate_setup_timing_stats(const std::string& prefix,
                                  const SetupTimingInfo& timing_info,
                                  const AnalysisDelayCalculator& delay_calc,
@@ -61,3 +179,55 @@ void generate_hold_timing_stats(const std::string& prefix,
 
     timing_reporter.report_unconstrained_hold(prefix + "report_unconstrained_timing.hold.rpt", *timing_info.hold_analyzer());
 }
+
+void generate_net_timing_report(const std::string& prefix,
+                                const SetupHoldTimingInfo& timing_info,
+                                const AnalysisDelayCalculator& delay_calc) {
+    std::ofstream os(prefix + "report_net_timing.csv");
+    const auto& atom_netlist = g_vpr_ctx.atom().netlist();
+    const auto& atom_lookup = g_vpr_ctx.atom().lookup();
+    const auto& timing_ctx = g_vpr_ctx.timing();
+    const auto& timing_graph = timing_ctx.graph;
+
+    // Write CSV header
+    os << "netname,Fanout,bb_xmin,bb_ymin,bb_layer_min,"
+       << "bb_xmax,bb_ymax,bb_layer_max,"
+       << "src_pin_name,src_pin_slack,sinks" << std::endl;
+
+    for (const auto& net : atom_netlist.nets()) {
+        const auto& net_name = atom_netlist.net_name(net);
+        const auto& source_pin = *atom_netlist.net_pins(net).begin();
+        // for the driver/source, this is the worst slack to any fanout.
+        auto source_pin_slack = timing_info.setup_pin_slack(source_pin);
+        auto tg_source_node = atom_lookup.atom_pin_tnode(source_pin);
+        VTR_ASSERT(tg_source_node.is_valid());
+
+        const size_t fanout = atom_netlist.net_sinks(net).size();
+        const auto& net_bb = get_net_bounding_box(net);
+
+        os << "\"" << net_name << "\"," // netname (quoted for safety)
+           << fanout << ","
+           << net_bb.xmin << "," << net_bb.ymin << "," << net_bb.layer_min << ","
+           << net_bb.xmax << "," << net_bb.ymax << "," << net_bb.layer_max << ","
+           << "\"" << atom_netlist.pin_name(source_pin) << "\"," << source_pin_slack << ",";
+
+        // Write sinks column (quoted, semicolon-delimited, each sink: name,slack,delay)
+        os << "\"";
+        for (size_t i = 0; i < fanout; ++i) {
+            const auto& pin = *(atom_netlist.net_pins(net).begin() + i + 1);
+            auto tg_sink_node = atom_lookup.atom_pin_tnode(pin);
+            VTR_ASSERT(tg_sink_node.is_valid());
+
+            auto tg_edge_id = timing_graph->find_edge(tg_source_node, tg_sink_node);
+            VTR_ASSERT(tg_edge_id.is_valid());
+
+            auto pin_setup_slack = timing_info.setup_pin_slack(pin);
+            auto pin_delay = delay_calc.max_edge_delay(*timing_graph, tg_edge_id);
+            const auto& pin_name = atom_netlist.pin_name(pin);
+
+            os << pin_name << "," << pin_setup_slack << "," << pin_delay;
+            if (i != fanout - 1) os << ";";
+        }
+        os << "\"" << std::endl; // Close quoted sinks field and finish the row
+    }
+}

vpr/src/analysis/timing_reports.h

@@ -21,4 +21,29 @@ void generate_hold_timing_stats(const std::string& prefix,
                                 bool is_flat,
                                 const BlkLocRegistry& blk_loc_registry);
 
+/**
+ * @brief Generates a CSV report of timing information for each net in the atom netlist.
+ * 
+ * Each row in the CSV corresponds to a single net and includes:
+ * - Net name
+ * - Fanout count
+ * - Bounding box (xmin, ymin, layer_min, xmax, ymax, layer_max)
+ * - Source pin name and slack
+ * - A single "sinks" field that encodes information for all sink pins
+ * 
+ * The "sinks" field is a semicolon-separated list of all sink pins.
+ * Each sink pin is represented as a comma-separated triple:
+ *   <sink_pin_name>,<sink_pin_slack>,<sink_pin_delay>
+ * 
+ * Example row:
+ * netA,2,0,0,0,5,5,1,U1.A,0.25,"U2.B,0.12,0.5;U3.C,0.10,0.6"
+ * 
+ * @param prefix       Prefix for the output file name (report will be saved as <prefix>report_net_timing.csv)
+ * @param timing_info  Timing analysis results (slacks)
+ * @param delay_calc   Delay calculator used to extract delay between nodes
+ */
+void generate_net_timing_report(const std::string& prefix,
+                                const SetupHoldTimingInfo& timing_info,
+                                const AnalysisDelayCalculator& delay_calc);
+
 #endif

vpr/src/base/SetupVPR.cpp

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

vpr/src/base/read_options.cpp

@@ -3088,6 +3088,14 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio
         .help("Writes implemented design final timing summary to the specified JSON, XML or TXT file.")
         .show_in(argparse::ShowIn::HELP_ONLY);
 
+    analysis_grp.add_argument<bool, ParseOnOff>(args.generate_net_timing_report, "--generate_net_timing_report")
+        .help(
+            "Generates a net timing report in CSV format, reporting the delay and slack\n"
+            "for every routed connection in the design.\n"
+            "The report is saved as 'report_net_timing.csv'.")
+        .default_value("off")
+        .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

@@ -272,6 +272,7 @@ struct t_options {
     argparse::ArgValue<e_post_synth_netlist_unconn_handling> post_synth_netlist_unconn_output_handling;
     argparse::ArgValue<bool> post_synth_netlist_module_parameters;
     argparse::ArgValue<std::string> write_timing_summary;
+    argparse::ArgValue<bool> generate_net_timing_report;
 };
 
 argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_options& args);

vpr/src/base/vpr_api.cpp

@@ -1475,6 +1475,10 @@ void vpr_analysis(const Netlist<>& net_list,
             merged_netlist_writer(atom_ctx.netlist().netlist_name(), analysis_delay_calc, Arch.models, vpr_setup.AnalysisOpts);
         }
 
+        if (vpr_setup.AnalysisOpts.generate_net_timing_report) {
+            generate_net_timing_report(/*prefix=*/"", *timing_info, *analysis_delay_calc);
+        }
+
         //Do power analysis
         // TODO: Still assumes that cluster net list is used
         if (vpr_setup.PowerOpts.do_power) {

vpr/src/base/vpr_types.h

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

vtr_flow/tasks/regression_tests/vtr_reg_strong/strong_timing_report_detail/config/config.txt

@@ -24,7 +24,10 @@ qor_parse_file=qor_standard.txt
 pass_requirements_file=pass_requirements.txt
 
 # Script parameters
-script_params_common = -starting_stage vpr
+script_params_common = -starting_stage vpr --generate_net_timing_report on
 script_params_list_add=--timing_report_detail netlist
 script_params_list_add=--timing_report_detail aggregated
 script_params_list_add=--timing_report_detail detailed
+script_params_list_add=--timing_report_detail netlist --flat_routing on
+script_params_list_add=--timing_report_detail aggregated --flat_routing on
+script_params_list_add=--timing_report_detail detailed --flat_routing on