Merge pull request #1516 from HackerFoo/reorder-metadata

Apply reordering to node and edge metadata

Author: HackerFoo

vpr/src/base/metadata_storage.h

@@ -28,6 +28,26 @@ class MetadataStorage {
         data_.push_back(std::make_tuple(lookup_key, meta_key, meta_value));
     }
 
+    // Use the given mapping function to change the keys
+    void remap_keys(std::function<LookupKey(LookupKey)> key_map) {
+        if (map_.empty()) {
+            for (auto& entry : data_) {
+                std::get<0>(entry) = key_map(std::get<0>(entry));
+            }
+        } else {
+            VTR_ASSERT(data_.empty());
+            for (auto& dict : map_) {
+                for (auto& entry : dict.second) {
+                    for (auto& value : entry.second) {
+                        data_.push_back(std::make_tuple(key_map(dict.first), entry.first, value.as_string()));
+                    }
+                }
+            }
+            map_.clear();
+            build_map();
+        }
+    }
+
     typename vtr::flat_map<LookupKey, t_metadata_dict>::const_iterator find(const LookupKey& lookup_key) const {
         check_for_map();
 

vpr/src/route/rr_graph_util.cpp

@@ -169,4 +169,11 @@ void reorder_rr_graph_nodes(const t_router_opts& router_opts) {
             }
         }
     }
+
+    device_ctx.rr_node_metadata.remap_keys([&](int node) { return size_t(dest_order[RRNodeId(node)]); });
+    device_ctx.rr_edge_metadata.remap_keys([&](std::tuple<int, int, short> edge) {
+        return std::make_tuple(size_t(dest_order[RRNodeId(std::get<0>(edge))]),
+                               size_t(dest_order[RRNodeId(std::get<1>(edge))]),
+                               std::get<2>(edge));
+    });
 }

vpr/test/test_vpr.cpp

@@ -125,8 +125,7 @@ TEST_CASE("read_rr_graph_metadata", "[vpr]") {
             kArchFile,
             "wire.eblif",
             "--route_chan_width",
-            "100",
-        };
+            "100"};
         vpr_init(sizeof(argv) / sizeof(argv[0]), argv,
                  &options, &vpr_setup, &arch);
         vpr_setup.RouterOpts.read_rr_edge_metadata = true;
@@ -165,6 +164,10 @@ TEST_CASE("read_rr_graph_metadata", "[vpr]") {
         "wire.eblif",
         "--route_chan_width",
         "100",
+        "--reorder_rr_graph_nodes_seed",
+        "1",
+        "--reorder_rr_graph_nodes_algorithm",
+        "random_shuffle", // Tests node reordering with metadata
         "--read_rr_graph",
         kRrGraphFile,
     };
@@ -175,23 +178,30 @@ TEST_CASE("read_rr_graph_metadata", "[vpr]") {
     vpr_create_device(vpr_setup, arch);
 
     const auto& device_ctx = g_vpr_ctx.device();
+
+    // recompute ordering from 'random_shuffle'
+    std::vector<int> src_order(device_ctx.rr_nodes.size()); // new id -> old id
+    std::iota(src_order.begin(), src_order.end(), 0);       // Initialize to [0, 1, 2 ...]
+    std::mt19937 g(1);
+    std::shuffle(src_order.begin(), src_order.end(), g);
+
     CHECK(device_ctx.rr_node_metadata.size() == 1);
     CHECK(device_ctx.rr_edge_metadata.size() == 1);
 
     auto node = arch.strings.intern_string(vtr::string_view("node"));
     auto edge = arch.strings.intern_string(vtr::string_view("edge"));
 
     for (const auto& node_meta : device_ctx.rr_node_metadata) {
-        CHECK(node_meta.first == src_inode);
+        CHECK(src_order[node_meta.first] == src_inode);
         REQUIRE(node_meta.second.has(node));
         auto* value = node_meta.second.one(node);
         REQUIRE(value != nullptr);
         CHECK_THAT(value->as_string().get(&arch.strings), Equals("test node"));
     }
 
     for (const auto& edge_meta : device_ctx.rr_edge_metadata) {
-        CHECK(std::get<0>(edge_meta.first) == src_inode);
-        CHECK(std::get<1>(edge_meta.first) == sink_inode);
+        CHECK(src_order[std::get<0>(edge_meta.first)] == src_inode);
+        CHECK(src_order[std::get<1>(edge_meta.first)] == sink_inode);
         CHECK(std::get<2>(edge_meta.first) == switch_id);
 
         REQUIRE(edge_meta.second.has(edge));