From 1db3a87c62acc79de0b3c7bd8c4c155c61c864ee Mon Sep 17 00:00:00 2001 From: Maciej Kurc Date: Wed, 29 Sep 2021 14:59:09 +0200 Subject: [PATCH] Code formatting Signed-off-by: Maciej Kurc --- common/command.cc | 3 +- common/nextpnr_types.h | 16 ++++--- common/report.cc | 105 +++++++++++++++++------------------------ common/timing.cc | 80 +++++++++++++------------------ 4 files changed, 86 insertions(+), 118 deletions(-) diff --git a/common/command.cc b/common/command.cc index 006a6217..38de8344 100644 --- a/common/command.cc +++ b/common/command.cc @@ -179,8 +179,7 @@ po::options_description CommandHandler::getGeneralOptions() general.add_options()("report", po::value(), "write timing and utilization report in JSON format to file"); - general.add_options()("detailed-timing-report", - "Append detailed net timing data to the JSON report"); + general.add_options()("detailed-timing-report", "Append detailed net timing data to the JSON report"); general.add_options()("placed-svg", po::value(), "write render of placement to SVG file"); general.add_options()("routed-svg", po::value(), "write render of routing to SVG file"); diff --git a/common/nextpnr_types.h b/common/nextpnr_types.h index 8b19595b..6b594d64 100644 --- a/common/nextpnr_types.h +++ b/common/nextpnr_types.h @@ -242,15 +242,17 @@ struct ClockPair struct CriticalPath { - struct Segment { + struct Segment + { // Segment type - enum class Type { - CLK_TO_Q, // Clock-to-Q delay - SOURCE, // Delayless source - LOGIC, // Combinational logic delay - ROUTING, // Routing delay - SETUP // Setup time in sink + enum class Type + { + CLK_TO_Q, // Clock-to-Q delay + SOURCE, // Delayless source + LOGIC, // Combinational logic delay + ROUTING, // Routing delay + SETUP // Setup time in sink }; // Type diff --git a/common/report.cc b/common/report.cc index 1338ade5..98ff14fb 100644 --- a/common/report.cc +++ b/common/report.cc @@ -41,60 +41,53 @@ dict> get_utilization(const Context *ctx) } } // namespace -static std::string clock_event_name (const Context* ctx, const ClockEvent& e) { +static std::string clock_event_name(const Context *ctx, const ClockEvent &e) +{ std::string value; if (e.clock == ctx->id("$async$")) value = std::string(""); else - value = (e.edge == FALLING_EDGE ? std::string("negedge ") : - std::string("posedge ")) + e.clock.str(ctx); + value = (e.edge == FALLING_EDGE ? std::string("negedge ") : std::string("posedge ")) + e.clock.str(ctx); return value; }; -static Json::array report_critical_paths (const Context* ctx) { +static Json::array report_critical_paths(const Context *ctx) +{ - auto report_critical_path = [ctx](const CriticalPath& report) { + auto report_critical_path = [ctx](const CriticalPath &report) { Json::array pathJson; - for (const auto& segment : report.segments) { + for (const auto &segment : report.segments) { - const auto& driver = ctx->cells.at(segment.from.first); - const auto& sink = ctx->cells.at(segment.to.first); + const auto &driver = ctx->cells.at(segment.from.first); + const auto &sink = ctx->cells.at(segment.to.first); auto fromLoc = ctx->getBelLocation(driver->bel); auto toLoc = ctx->getBelLocation(sink->bel); - auto fromJson = Json::object({ - {"cell", segment.from.first.c_str(ctx)}, - {"port", segment.from.second.c_str(ctx)}, - {"loc", Json::array({fromLoc.x, fromLoc.y})} - }); + auto fromJson = Json::object({{"cell", segment.from.first.c_str(ctx)}, + {"port", segment.from.second.c_str(ctx)}, + {"loc", Json::array({fromLoc.x, fromLoc.y})}}); - auto toJson = Json::object({ - {"cell", segment.to.first.c_str(ctx)}, - {"port", segment.to.second.c_str(ctx)}, - {"loc", Json::array({toLoc.x, toLoc.y})} - }); + auto toJson = Json::object({{"cell", segment.to.first.c_str(ctx)}, + {"port", segment.to.second.c_str(ctx)}, + {"loc", Json::array({toLoc.x, toLoc.y})}}); auto segmentJson = Json::object({ - {"delay", ctx->getDelayNS(segment.delay)}, - {"from", fromJson}, - {"to", toJson}, + {"delay", ctx->getDelayNS(segment.delay)}, + {"from", fromJson}, + {"to", toJson}, }); if (segment.type == CriticalPath::Segment::Type::CLK_TO_Q) { segmentJson["type"] = "clk-to-q"; - } - else if (segment.type == CriticalPath::Segment::Type::SOURCE) { + } else if (segment.type == CriticalPath::Segment::Type::SOURCE) { segmentJson["type"] = "source"; - } - else if (segment.type == CriticalPath::Segment::Type::LOGIC) { + } else if (segment.type == CriticalPath::Segment::Type::LOGIC) { segmentJson["type"] = "logic"; - } - else if (segment.type == CriticalPath::Segment::Type::SETUP) { + } else if (segment.type == CriticalPath::Segment::Type::SETUP) { segmentJson["type"] = "setup"; - } - else if (segment.type == CriticalPath::Segment::Type::ROUTING) { + } else if (segment.type == CriticalPath::Segment::Type::ROUTING) { segmentJson["type"] = "routing"; segmentJson["net"] = segment.net.c_str(ctx); segmentJson["budget"] = ctx->getDelayNS(segment.budget); @@ -111,58 +104,51 @@ static Json::array report_critical_paths (const Context* ctx) { // Critical paths for (auto &report : ctx->timing_result.clock_paths) { - critPathsJson.push_back(Json::object({ - {"from", clock_event_name(ctx, report.second.clock_pair.start)}, - {"to", clock_event_name(ctx, report.second.clock_pair.end)}, - {"path", report_critical_path(report.second)} - })); + critPathsJson.push_back(Json::object({{"from", clock_event_name(ctx, report.second.clock_pair.start)}, + {"to", clock_event_name(ctx, report.second.clock_pair.end)}, + {"path", report_critical_path(report.second)}})); } // Cross-domain paths for (auto &report : ctx->timing_result.xclock_paths) { - critPathsJson.push_back(Json::object({ - {"from", clock_event_name(ctx, report.clock_pair.start)}, - {"to", clock_event_name(ctx, report.clock_pair.end)}, - {"path", report_critical_path(report)} - })); + critPathsJson.push_back(Json::object({{"from", clock_event_name(ctx, report.clock_pair.start)}, + {"to", clock_event_name(ctx, report.clock_pair.end)}, + {"path", report_critical_path(report)}})); } return critPathsJson; } -static Json::array report_detailed_net_timings (const Context* ctx) { +static Json::array report_detailed_net_timings(const Context *ctx) +{ auto detailedNetTimingsJson = Json::array(); // Detailed per-net timing analysis - for (const auto& it : ctx->timing_result.detailed_net_timings) { + for (const auto &it : ctx->timing_result.detailed_net_timings) { - const NetInfo* net = ctx->nets.at(it.first).get(); + const NetInfo *net = ctx->nets.at(it.first).get(); ClockEvent start = it.second[0].clock_pair.start; Json::array endpointsJson; - for (const auto& sink_timing : it.second) { + for (const auto &sink_timing : it.second) { // FIXME: Is it possible that there are multiple different start // events for a single net? It has a single driver NPNR_ASSERT(sink_timing.clock_pair.start == start); - auto endpointJson = Json::object({ - {"cell", sink_timing.cell_port.first.c_str(ctx)}, - {"port", sink_timing.cell_port.second.c_str(ctx)}, - {"event", clock_event_name(ctx, sink_timing.clock_pair.end)}, - {"delay", ctx->getDelayNS(sink_timing.delay)}, - {"budget", ctx->getDelayNS(sink_timing.budget)} - }); + auto endpointJson = Json::object({{"cell", sink_timing.cell_port.first.c_str(ctx)}, + {"port", sink_timing.cell_port.second.c_str(ctx)}, + {"event", clock_event_name(ctx, sink_timing.clock_pair.end)}, + {"delay", ctx->getDelayNS(sink_timing.delay)}, + {"budget", ctx->getDelayNS(sink_timing.budget)}}); endpointsJson.push_back(endpointJson); } - auto netTimingJson = Json::object({ - {"net", net->name.c_str(ctx)}, - {"driver", net->driver.cell->name.c_str(ctx)}, - {"port", net->driver.port.c_str(ctx)}, - {"event", clock_event_name(ctx, start)}, - {"endpoints", endpointsJson} - }); + auto netTimingJson = Json::object({{"net", net->name.c_str(ctx)}, + {"driver", net->driver.cell->name.c_str(ctx)}, + {"port", net->driver.port.c_str(ctx)}, + {"event", clock_event_name(ctx, start)}, + {"endpoints", endpointsJson}}); detailedNetTimingsJson.push_back(netTimingJson); } @@ -261,10 +247,7 @@ void Context::writeReport(std::ostream &out) const } Json::object jsonRoot{ - {"utilization", util_json}, - {"fmax", fmax_json}, - {"critical_paths", report_critical_paths(this)} - }; + {"utilization", util_json}, {"fmax", fmax_json}, {"critical_paths", report_critical_paths(this)}}; if (detailed_timing_report) { jsonRoot["detailed_net_timings"] = report_detailed_net_timings(this); diff --git a/common/timing.cc b/common/timing.cc index 41dd358b..e305d82d 100644 --- a/common/timing.cc +++ b/common/timing.cc @@ -644,8 +644,7 @@ struct Timing }; Timing(Context *ctx, bool net_delays, bool update, CriticalPathDataMap *crit_path = nullptr, - DelayFrequency *slack_histogram = nullptr, - DetailedNetTimings *detailed_net_timings = nullptr) + DelayFrequency *slack_histogram = nullptr, DetailedNetTimings *detailed_net_timings = nullptr) : ctx(ctx), net_delays(net_delays), update(update), min_slack(1.0e12 / ctx->setting("target_freq")), crit_path(crit_path), slack_histogram(slack_histogram), detailed_net_timings(detailed_net_timings), async_clock(ctx->id("$async$")) @@ -1108,7 +1107,8 @@ void assign_budget(Context *ctx, bool quiet) log_info("Checksum: 0x%08x\n", ctx->checksum()); } -CriticalPath build_critical_path_report(Context* ctx, ClockPair &clocks, const PortRefVector &crit_path) { +CriticalPath build_critical_path_report(Context *ctx, ClockPair &clocks, const PortRefVector &crit_path) +{ CriticalPath report; report.clock_pair = clocks; @@ -1120,7 +1120,7 @@ CriticalPath build_critical_path_report(Context* ctx, ClockPair &clocks, const P int port_clocks; auto portClass = ctx->getPortTimingClass(front_driver.cell, front_driver.port, port_clocks); - const CellInfo* last_cell = front->cell; + const CellInfo *last_cell = front->cell; IdString last_port = front_driver.port; int clock_start = -1; @@ -1128,8 +1128,7 @@ CriticalPath build_critical_path_report(Context* ctx, ClockPair &clocks, const P for (int i = 0; i < port_clocks; i++) { TimingClockingInfo clockInfo = ctx->getPortClockingInfo(front_driver.cell, front_driver.port, i); const NetInfo *clknet = get_net_or_empty(front_driver.cell, clockInfo.clock_port); - if (clknet != nullptr && clknet->name == clocks.start.clock && - clockInfo.edge == clocks.start.edge) { + if (clknet != nullptr && clknet->name == clocks.start.clock && clockInfo.edge == clocks.start.edge) { last_port = clockInfo.clock_port; clock_start = i; break; @@ -1202,7 +1201,8 @@ CriticalPath build_critical_path_report(Context* ctx, ClockPair &clocks, const P return report; } -void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool print_path, bool warn_on_failure, bool update_results) +void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool print_path, bool warn_on_failure, + bool update_results) { auto format_event = [ctx](const ClockEvent &e, int field_width = 0) { std::string value; @@ -1251,7 +1251,7 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p else Fmax = 500 / ctx->getDelayNS(path.second.path_delay); if (!clock_fmax.count(a.clock) || Fmax < clock_fmax.at(a.clock).achieved) { - clock_fmax[a.clock].achieved = Fmax; + clock_fmax[a.clock].achieved = Fmax; clock_fmax[a.clock].constraint = 0.0f; // Will be filled later clock_reports[a.clock] = build_critical_path_report(ctx, path.first, path.second.ports); clock_reports[a.clock].period = path.second.path_period; @@ -1274,9 +1274,8 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p } std::sort(xclock_reports.begin(), xclock_reports.end(), [ctx](const CriticalPath &ra, const CriticalPath &rb) { - - const auto& a = ra.clock_pair; - const auto& b = rb.clock_pair; + const auto &a = ra.clock_pair; + const auto &b = rb.clock_pair; if (a.start.clock.str(ctx) < b.start.clock.str(ctx)) return true; @@ -1334,55 +1333,40 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p }; // A helper function for reporting one critical path - auto print_path_report = [ctx](const CriticalPath& path) { + auto print_path_report = [ctx](const CriticalPath &path) { delay_t total = 0, logic_total = 0, route_total = 0; log_info("curr total\n"); - for (const auto& segment : path.segments) { + for (const auto &segment : path.segments) { total += segment.delay; if (segment.type == CriticalPath::Segment::Type::CLK_TO_Q || segment.type == CriticalPath::Segment::Type::SOURCE || segment.type == CriticalPath::Segment::Type::LOGIC || - segment.type == CriticalPath::Segment::Type::SETUP) - { + segment.type == CriticalPath::Segment::Type::SETUP) { logic_total += segment.delay; const std::string type_name = - (segment.type == CriticalPath::Segment::Type::SETUP) ? - "Setup" : "Source"; + (segment.type == CriticalPath::Segment::Type::SETUP) ? "Setup" : "Source"; - log_info("%4.1f %4.1f %s %s.%s\n", - ctx->getDelayNS(segment.delay), - ctx->getDelayNS(total), - type_name.c_str(), - segment.to.first.c_str(ctx), - segment.to.second.c_str(ctx) - ); - } - else if (segment.type == CriticalPath::Segment::Type::ROUTING) { + log_info("%4.1f %4.1f %s %s.%s\n", ctx->getDelayNS(segment.delay), ctx->getDelayNS(total), + type_name.c_str(), segment.to.first.c_str(ctx), segment.to.second.c_str(ctx)); + } else if (segment.type == CriticalPath::Segment::Type::ROUTING) { route_total += segment.delay; - const auto& driver = ctx->cells.at(segment.from.first); - const auto& sink = ctx->cells.at(segment.to.first); + const auto &driver = ctx->cells.at(segment.from.first); + const auto &sink = ctx->cells.at(segment.to.first); auto driver_loc = ctx->getBelLocation(driver->bel); auto sink_loc = ctx->getBelLocation(sink->bel); - log_info("%4.1f %4.1f Net %s budget %f ns (%d,%d) -> (%d,%d)\n", - ctx->getDelayNS(segment.delay), - ctx->getDelayNS(total), - segment.net.c_str(ctx), - ctx->getDelayNS(segment.budget), - driver_loc.x, driver_loc.y, sink_loc.x, sink_loc.y - ); - log_info(" Sink %s.%s\n", - segment.to.first.c_str(ctx), - segment.to.second.c_str(ctx) - ); + log_info("%4.1f %4.1f Net %s budget %f ns (%d,%d) -> (%d,%d)\n", ctx->getDelayNS(segment.delay), + ctx->getDelayNS(total), segment.net.c_str(ctx), ctx->getDelayNS(segment.budget), + driver_loc.x, driver_loc.y, sink_loc.x, sink_loc.y); + log_info(" Sink %s.%s\n", segment.to.first.c_str(ctx), segment.to.second.c_str(ctx)); - const NetInfo* net = ctx->nets.at(segment.net).get(); + const NetInfo *net = ctx->nets.at(segment.net).get(); if (ctx->verbose) { @@ -1424,8 +1408,8 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p // Single domain paths for (auto &clock : clock_reports) { log_break(); - std::string start = - clock.second.clock_pair.start.edge == FALLING_EDGE ? std::string("negedge") : std::string("posedge"); + std::string start = clock.second.clock_pair.start.edge == FALLING_EDGE ? std::string("negedge") + : std::string("posedge"); std::string end = clock.second.clock_pair.end.edge == FALLING_EDGE ? std::string("negedge") : std::string("posedge"); log_info("Critical path report for clock '%s' (%s -> %s):\n", clock.first.c_str(ctx), start.c_str(), @@ -1455,9 +1439,9 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p const auto &clock_name = clock.first.str(ctx); const int width = max_width - clock_name.size(); - float fmax = clock_fmax[clock.first].achieved; + float fmax = clock_fmax[clock.first].achieved; float target = clock_fmax[clock.first].constraint; - bool passed = target < fmax; + bool passed = target < fmax; if (!warn_on_failure || passed) log_info("Max frequency for clock %*s'%s': %.02f MHz (%s at %.02f MHz)\n", width, "", @@ -1485,7 +1469,7 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p const ClockEvent &a = report.clock_pair.start; const ClockEvent &b = report.clock_pair.end; delay_t path_delay = 0; - for (const auto& segment : report.segments) { + for (const auto &segment : report.segments) { path_delay += segment.delay; } auto ev_a = format_event(a, start_field_width), ev_b = format_event(b, end_field_width); @@ -1526,10 +1510,10 @@ void timing_analysis(Context *ctx, bool print_histogram, bool print_fmax, bool p // Update timing results in the context if (update_results) { - auto& results = ctx->timing_result; + auto &results = ctx->timing_result; - results.clock_fmax = std::move(clock_fmax); - results.clock_paths = std::move(clock_reports); + results.clock_fmax = std::move(clock_fmax); + results.clock_paths = std::move(clock_reports); results.xclock_paths = std::move(xclock_reports); results.detailed_net_timings = std::move(detailed_net_timings);