upgrade router arg parser using more advanced arg parser; finished putting everything together; need to add test for conv_3_3

Author: Kuree

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "thunder/lib/leidenalg"]
 	path = thunder/lib/leidenalg
 	url = https://github.com/kuree/leidenalg
+[submodule "cyclone/extern/argparse"]
+	path = cyclone/extern/argparse
+	url = https://github.com/p-ranav/argparse

cyclone/example/CMakeLists.txt

@@ -6,5 +6,6 @@ target_link_libraries(example2 cyclone)
 
 add_executable(router router.cc)
 target_link_libraries(router PRIVATE cyclone)
+target_include_directories(router PRIVATE ../extern/argparse/include)
 
 target_link_libraries(router PUBLIC ${STATIC_FLAG})

cyclone/example/router.cc

@@ -1,9 +1,11 @@
 #include "../src/global.hh"
-#include "../src/graph.hh"
 #include "../src/io.hh"
+#include "../src/timing.hh"
+#include "../src/thunder_io.hh"
 #include <cstdio>
 #include <fstream>
 #include <iostream>
+#include "argparse/argparse.hpp"
 
 using namespace std;
 
@@ -37,6 +39,73 @@ bool process_args(int argc, char *argv[], ::vector<::string> &args) {
     return pd_aware;
 }
 
+void setup_argparse(argparse::ArgumentParser &parser) {
+    parser.add_argument("--pd").help("If set, will use PD-oriented routing strategy").default_value(
+            false).implicit_value(true);
+    parser.add_argument("-p", "--packed").help("Packed netlist file").required();
+    parser.add_argument("-P", "--placement").help("Placement file").required();
+    parser.add_argument("-o", "-r", "--route").help("Routing result").required();
+    parser.add_argument("-g").help("Routing graph information").required().append();
+    parser.add_argument("-l", "--layout").help("Chip layout").default_value("");
+    parser.add_argument("-t", "--retime").help(
+            "Set timing file. Default is none, which turns off re-timing. Set to default to use the default timing information").default_value(
+            "none");
+}
+
+struct RouterInput {
+    bool pd = false;
+    std::string packed_filename;
+    std::string placement_filename;
+    std::string output_file;
+    std::vector<std::pair<uint32_t, std::string>> graph_info;
+    std::string timing_file;
+    std::string chip_layout;
+};
+
+std::optional<RouterInput> parse_args(int argc, char *argv[]) {
+    argparse::ArgumentParser parser("CGRA Router");
+    setup_argparse(parser);
+
+    try {
+        parser.parse_args(argc, argv);
+    }
+    catch (const std::runtime_error &err) {
+        std::cerr << err.what() << std::endl;
+        std::cerr << parser;
+        return std::nullopt;
+    }
+    // fill out information
+    RouterInput result;
+    result.pd = parser["--pd"] == true;
+    result.packed_filename = parser.get<std::string>("-p");
+    result.placement_filename = parser.get<std::string>("-P");
+    result.output_file = parser.get<std::string>("-o");
+    auto values = parser.get<std::vector<std::string>>("-g");
+    if (values.size() % 2 != 0) {
+        std::cerr << "Incorrect number of graph args" << std::endl;
+        std::cerr << parser;
+        return std::nullopt;
+    }
+    for (auto i = 0u; i < values.size(); i += 2) {
+        auto bit_width = std::stoul(values[i * 2]);
+        auto path = values[i * 2 + 1];
+        result.graph_info.emplace_back(std::make_pair(bit_width, path));
+    }
+
+    auto timing_file = parser.get<std::string>("-t");
+    if (timing_file != "none") {
+        auto layout = parser.get<std::string>("-l");
+        if (layout.empty()) {
+            std::cerr << "When re-timing is specified, layout file is required" << std::endl;
+            std::cerr << parser << std::endl;
+            return std::nullopt;
+        }
+        result.chip_layout = layout;
+    }
+
+    return result;
+}
+
 void
 adjust_node_cost_power_domain(RoutingGraph *graph,
                               const std::map<std::string, std::pair<int, int>> &placement_result) {
@@ -52,30 +121,43 @@ adjust_node_cost_power_domain(RoutingGraph *graph,
             auto switchbox = tile.switchbox;
             for (uint32_t i = 0; i < 4; i++) {
                 auto sbs = switchbox.get_sbs_by_side(SwitchBoxSide(i));
-                for (const auto& sb: sbs) {
+                for (const auto &sb: sbs) {
                     sb->delay = power_domain_cost;
                 }
             }
         }
     }
 }
 
+void retime_router(Router &router, const RouterInput &args) {
+    const auto &timing_file = args.timing_file;
+    if (timing_file == "none") {
+        return;
+    } else if (timing_file == "default") {
+        auto const &layout_file = args.chip_layout;
+        auto layout = load_layout(layout_file);
+        TimingAnalysis timing(router);
+        timing.set_timing_cost(get_default_timing_info());
+        timing.retime();
+    } else {
+        throw std::runtime_error("Timing file not implemented");
+    }
+}
+
 int main(int argc, char *argv[]) {
-    if (argc < 6) {
-        print_help(argv[0]);
+    auto args_opt = parse_args(argc, argv);
+    if (!args_opt) {
         return EXIT_FAILURE;
     }
-    ::vector<::string> args;
-    bool power_domain = process_args(argc, argv, args);
+    auto const &args = *args_opt;
 
-    string packed_filename = args[1];
-    string placement_filename = args[2];
-    // reassign the size
-    argc = args.size();
+    bool power_domain = args.pd;
+    const auto &packed_filename = args.packed_filename;
+    auto const &placement_filename = args.placement_filename;
 
     auto[netlist, track_mode] = load_netlist(packed_filename);
     auto placement = load_placement(placement_filename);
-    auto output_file = args[argc - 1];
+    auto output_file = args.output_file;
 
     // delete the old file if exists
     if (exists(output_file)) {
@@ -85,9 +167,7 @@ int main(int argc, char *argv[]) {
         }
     }
 
-    for (int arg_index = 3; arg_index < argc - 1; arg_index += 2) {
-        auto bit_width = static_cast<uint32_t>(stoi(args[arg_index]));
-        string graph_filename = args[arg_index + 1];
+    for (auto const &[bit_width, graph_filename]: args.graph_info) {
         cout << "using bit_width " << bit_width << endl;
         auto graph = load_routing_graph(graph_filename);
 
@@ -113,6 +193,8 @@ int main(int argc, char *argv[]) {
 
         r.route();
 
+        retime_router(r, args);
+
         dump_routing_result(r, output_file);
     }
     return EXIT_SUCCESS;

cyclone/extern/argparse

@@ -386,7 +386,7 @@ std::shared_ptr<Node> RoutedGraph::get_node(std::unordered_map<const Node *, std
     return node_mapping.at(node);
 }
 
-std::vector<std::vector<std::shared_ptr<Node>>> RoutedGraph::get_route() const {
+std::map<uint32_t, std::vector<std::shared_ptr<Node>>> RoutedGraph::get_route() const {
     std::map<uint32_t, std::vector<std::shared_ptr<Node>>> result;
     std::unordered_set<const Node *> visited;
 
@@ -417,12 +417,7 @@ std::vector<std::vector<std::shared_ptr<Node>>> RoutedGraph::get_route() const {
         result.emplace(pin_id, segment);
     }
 
-    std::vector<std::vector<std::shared_ptr<Node>>> segments;
-    segments.reserve(result.size());
-    for (auto const &iter: result) {
-        segments.emplace_back(iter.second);
-    }
-    return segments;
+    return result;
 }
 
 

cyclone/src/graph.cc

@@ -299,7 +299,7 @@ public:
     explicit RoutedGraph(const std::map<uint32_t,
                          std::vector<std::shared_ptr<Node>>>& route);
 
-    std::vector<std::vector<std::shared_ptr<Node>>> get_route() const;
+    std::map<uint32_t, std::vector<std::shared_ptr<Node>>>  get_route() const;
     [[nodiscard]] std::set<uint32_t> insert_pipeline_reg(uint32_t pin_id);
     [[nodiscard]] std::set<uint32_t> insert_reg_output(std::shared_ptr<Node> src_node);
     std::shared_ptr<Node> src_node() const { return src_node_; }

cyclone/src/graph.hh

@@ -40,6 +40,10 @@ public:
     // get final routed graph
     std::unordered_map<int, RoutedGraph> get_routed_graph() const;
 
+    void set_current_routes(const std::map<int,
+            std::map<uint32_t,
+                    std::vector<std::shared_ptr<Node>>>> &routes) { current_routes = routes; }
+
 
 protected:
     RoutingGraph graph_;

cyclone/src/route.hh

@@ -206,7 +206,7 @@ uint64_t TimingAnalysis::retime() {
 
     auto nodes = timing_graph.topological_sort();
     auto timing_node_mapping = get_timing_node_mapping(nodes);
-    std::map<std::string, std::vector<std::vector<std::shared_ptr<Node>>>> final_result;
+    std::map<int, std::map<uint32_t, std::vector<std::shared_ptr<Node>>>> final_result;
 
     // start STA on each node
     for (auto const *timing_node: nodes) {
@@ -246,7 +246,7 @@ uint64_t TimingAnalysis::retime() {
             bool updated;
             do {
                 updated = false;
-                for (auto const &segment: segments) {
+                for (auto const &[pin_id, segment]: segments) {
                     for (uint64_t i = 1; i < segment.size(); i++) {
                         auto const &current_node = segment[i];
                         auto const &pre_node = segment[i - 1];
@@ -293,10 +293,11 @@ uint64_t TimingAnalysis::retime() {
 
             // get the updated route
             segments = routed_graph.get_route();
-            final_result.emplace(net.name, segments);
+            final_result.emplace(net.id, segments);
         }
     }
 
+    router_.set_current_routes(final_result);
     auto r = get_max_wave_number(pin_wave_);
     return r;
 }

cyclone/src/timing.cc

@@ -20,7 +20,7 @@ enum class TimingCost {
 };
 
 
-std::unordered_map<TimingCost, uint64_t> get_default_timing_info() {
+inline std::unordered_map<TimingCost, uint64_t> get_default_timing_info() {
     return {{TimingCost::CLB_OP, 1000},
             {TimingCost::MEM,    0},
             {TimingCost::CLB_SB, 200},
@@ -32,7 +32,7 @@ std::unordered_map<TimingCost, uint64_t> get_default_timing_info() {
 
 class TimingAnalysis {
 public:
-    explicit TimingAnalysis(const Router &router) : router_(router) {}
+    explicit TimingAnalysis(Router &router) : router_(router) {}
 
     void set_timing_cost(const std::unordered_map<TimingCost, uint64_t> &timing_cost) { timing_cost_ = timing_cost; }
 
@@ -41,7 +41,7 @@ public:
     void set_minimum_frequency(uint64_t f) { min_frequency_ = f; }
 
 private:
-    const Router &router_;
+    Router &router_;
     Layout layout_;
     uint64_t min_frequency_ = 200;