Added Switchs into reverse lookup

Author: mustafabbas

vpr/src/route/clock_network_types.cpp

@@ -73,11 +73,19 @@ void ClockRib::set_drive_switch(int switch_idx) {
     drive.switch_idx = switch_idx;
 }
 
+void ClockRib::set_drive_name(std::string name) {
+    drive.name = name;
+}
+
 void ClockRib::set_tap_locations(int offset_x, int increment_x) {
     tap.offset = offset_x;
     tap.increment = increment_x;
 }
 
+void ClockRib::set_tap_name(std::string name) {
+    tap.name = name;
+}
+
 /*
  * ClockRib (member functions)
  */
@@ -98,7 +106,7 @@ void ClockRib::create_rr_nodes_for_one_instance(int inst_num, ClockRRGraph& cloc
             int drive_x = x_start + drive.offset;
             // create drive point (length zero wire)
             auto drive_node_idx = create_chanx_wire(drive_x, drive_x, y, ptc_num, rr_nodes);
-            clock_graph.add_switch_location(get_name(), "drive", drive_x, y, drive_node_idx);
+            clock_graph.add_switch_location(get_name(), drive.name, drive_x, y, drive_node_idx);
 
             // create rib wire to the right and left of the drive point 
             auto left_node_idx = create_chanx_wire(x_start, drive_x, y, ptc_num, rr_nodes);
@@ -139,12 +147,11 @@ void ClockRib::record_tap_locations(
         int right_rr_node_idx,
         ClockRRGraph& clock_graph)
 {
-    std::string tap_name = "tap"; // only supporting one tap
     for(unsigned x = x_start+tap.offset; x <= x_end; x+=tap.increment) {
         if(x < x_start + drive.offset) {
-            clock_graph.add_switch_location(get_name(), tap_name, x, y, left_rr_node_idx);
+            clock_graph.add_switch_location(get_name(), tap.name, x, y, left_rr_node_idx);
         } else {
-            clock_graph.add_switch_location(get_name(), tap_name, x, y, right_rr_node_idx);
+            clock_graph.add_switch_location(get_name(), tap.name, x, y, right_rr_node_idx);
         }
     }
 }
@@ -188,11 +195,19 @@ void ClockSpine::set_drive_switch(int switch_idx) {
     drive.switch_idx = switch_idx;
 }
 
+void ClockSpine::set_drive_name(std::string name) {
+    drive.name = name;
+}
+
 void ClockSpine::set_tap_locations(int offset_y, int increment_y) {
     tap.offset = offset_y;
     tap.increment = increment_y;
 }
 
+void ClockSpine::set_tap_name(std::string name) {
+    tap.name = name;
+}
+
 /*
  * ClockSpine (member functions)
  */
@@ -203,14 +218,27 @@ void ClockSpine::create_rr_nodes_for_one_instance(int inst_num, ClockRRGraph& cl
     auto& rr_nodes = device_ctx.rr_nodes;
     auto& grid = device_ctx.grid;
 
-    int ptc_num = inst_num;
+    int ptc_num = inst_num + 50;
 
-    for(unsigned y_start = y_chan_wire.start, y_end = y_chan_wire.end;
-        y_end < grid.height();
+    for(unsigned y_start = y_chan_wire.start + 1, y_end = y_chan_wire.end;
+        y_end < grid.height() - 1;
         y_start += repeat.y, y_end += repeat.y) {
-        for(unsigned x = y_chan_wire.position; x < grid.width(); x += repeat.x) {
-            auto rr_node_index = create_chany_wire(y_start, y_end, x, ptc_num, rr_nodes);
-            record_switch_point_locations_for_rr_node(y_start, y_end, x, rr_node_index, clock_graph);
+        for(unsigned x = y_chan_wire.position; x < grid.width() - 1; x += repeat.x) {
+
+            int drive_y = y_start + drive.offset;
+            //create drive point (length zero wire)
+            auto drive_node_idx = create_chany_wire(drive_y, drive_y, x, ptc_num, rr_nodes);
+            clock_graph.add_switch_location(get_name(), drive.name, x, drive_y, drive_node_idx);
+
+            // create spine wire to the right and left of the drive point
+            auto left_node_idx = create_chany_wire(y_start, drive_y, x, ptc_num, rr_nodes);
+            auto right_node_idx = create_chany_wire(drive_y, y_end, x, ptc_num, rr_nodes);
+
+            record_tap_locations(y_start, y_end, x, left_node_idx, right_node_idx, clock_graph);
+
+            // connect drive point to each half spine using a directed switch
+            rr_nodes[drive_node_idx].add_edge(left_node_idx, drive.switch_idx);
+            rr_nodes[drive_node_idx].add_edge(right_node_idx, drive.switch_idx);
         }
     }
 }
@@ -233,13 +261,21 @@ int ClockSpine::create_chany_wire(
     return node_index;
 }
 
-void ClockSpine::record_switch_point_locations_for_rr_node(
-        int y_start,
-        int y_end,
-        int x,
-        int rr_node_index,
-        ClockRRGraph& clock_graph) {
-
+void ClockSpine::record_tap_locations(
+        unsigned y_start,
+        unsigned y_end,
+        unsigned x,
+        int left_node_idx,
+        int right_node_idx,
+        ClockRRGraph& clock_graph)
+{
+    for (unsigned y = y_start+tap.offset; y <= y_end; y+=tap.increment) {
+        if(y < y_start + drive.offset) {
+            clock_graph.add_switch_location(get_name(), tap.name, x, y, left_node_idx);
+        } else {
+            clock_graph.add_switch_location(get_name(), tap.name, x, y, right_node_idx);
+        }
+    }
 }
 
 

vpr/src/route/clock_network_types.h

@@ -34,31 +34,37 @@ struct WireRepeat {
 };
 
 struct RibDrive {
+    std::string name;
     int offset;
     int switch_idx;
 };
 
 struct RibTaps {
+    std::string name;
     int offset;
     int increment;
 };
 
 struct SpineDrive {
+    std::string name;
     int offset;
     int switch_idx;
 };
 
 struct SpineTaps {
+    std::string name;
     int offset;
     int increment;
 };
 
 struct HtreeDrive {
+    std::string name;
     Point offset;
     int switch_idx;
 };
 
 struct HtreeTaps {
+    std::string name;
     Point offset;
     Point increment;
 };
@@ -126,7 +132,9 @@ class ClockRib : public ClockNetwork {
         void set_wire_repeat(int repeat_x, int repeat_y);
         void set_drive_location(int offset_x);
         void set_drive_switch(int switch_idx);
+        void set_drive_name(std::string name);
         void set_tap_locations(int offset_x, int increment_x);
+        void set_tap_name(std::string name);
 
         /*
          * Member functions
@@ -174,7 +182,9 @@ class ClockSpine : public ClockNetwork {
         void set_wire_repeat(int repeat_x, int repeat_y);
         void set_drive_location(int offset_y);
         void set_drive_switch(int switch_idx);
+        void set_drive_name(std::string name);
         void set_tap_locations(int offset_y, int increment_y);
+        void set_tap_name(std::string name);
 
         /*
          * Member functions
@@ -186,11 +196,12 @@ class ClockSpine : public ClockNetwork {
             int x,
             int ptc_num,
             std::vector<t_rr_node>& rr_nodes);
-        void record_switch_point_locations_for_rr_node(
-                int y_start,
-                int y_end,
-                int x,
-                int rr_node_index,
+        void record_tap_locations(
+                unsigned y_start,
+                unsigned y_end,
+                unsigned x,
+                int left_node_idx,
+                int right_node_idx,
                 ClockRRGraph& clock_graph);
 
 };

vpr/src/route/rr_graph_clock.cpp

@@ -32,7 +32,9 @@ void ClockRRGraph::create_and_append_clock_rr_graph() {
     rib->set_wire_repeat(9, 1);
     rib->set_drive_location(5);
     rib->set_drive_switch(2);
+    rib->set_drive_name("drive");
     rib->set_tap_locations(0,1);
+    rib->set_tap_name("tap");
 
     // Clock Spines
     clock_networks.emplace_back(new ClockSpine());
@@ -41,14 +43,16 @@ void ClockRRGraph::create_and_append_clock_rr_graph() {
     spine->set_num_instance(10);
     spine->set_clock_name("spine1");
     spine->set_metal_layer(0,0);
-    spine->set_initial_wire_location(0,10,5);
-    spine->set_wire_repeat(10,10);
+    spine->set_initial_wire_location(0,9,5);
+    spine->set_wire_repeat(10,9);
     spine->set_drive_location(5);
     spine->set_drive_switch(2);
+    spine->set_drive_name("drive");
     spine->set_tap_locations(0,1);
+    spine->set_tap_name("tap");
 
     ClockRRGraph clock_graph = ClockRRGraph();
-    clock_graph.allocate_lookup(clock_networks);
+//    clock_graph.allocate_lookup(clock_networks);
     clock_graph.create_clock_networks_wires(clock_networks);
 
 //    std::vector<ClockConnection> clock_routing;
@@ -67,38 +71,37 @@ void ClockRRGraph::create_clock_networks_wires(
     }
 }
 
-void ClockRRGraph::allocate_lookup(const std::vector<std::unique_ptr<ClockNetwork>>& clock_networks) {
-
-    auto& grid = g_vpr_ctx.mutable_device().grid;
-
-    for(auto& clock_network : clock_networks) {
-       
-        SwitchPoints switch_points;
-        
-        /* TODO: loop over all switchs and insert into map. */
-        // Currently only supporting two switch points
-        // Single Drive
-        std::string drive_switch_name = "drive";
-        SwitchPoint drive_switch_locations(grid.width(), grid.height());
-        switch_points.insert_switch(drive_switch_name, drive_switch_locations);
-        // Single Tap
-        std::string tap_switch_name = "tap";
-        SwitchPoint tap_switch_locations(grid.width(), grid.height());
-        switch_points.insert_switch(tap_switch_name, tap_switch_locations);
-
-        clock_name_to_switch_points.emplace(clock_network->get_name(), switch_points);
-    }
-}
-
 void ClockRRGraph::add_switch_location(
         std::string clock_name,
         std::string switch_name,
         int x,
         int y,
         int node_index) {
+    // Note use of operator[] will automatically insert clock name if it doesn't exist
     clock_name_to_switch_points[clock_name].insert_switch_node_idx(switch_name, x, y, node_index);
 }
 
+void SwitchPoints::insert_switch_node_idx(std::string switch_name, int x, int y, int node_idx) {
+    // Note use of operator[] will automatically insert switch name if it doesn't exit
+    switch_name_to_switch_location[switch_name].insert_node_idx(x, y, node_idx);
+}
+
+void SwitchPoint::insert_node_idx(int x, int y, int node_idx) {
+
+    // allocate 2d vector of grid size
+    if (rr_node_indices.empty()) {
+        auto& grid = g_vpr_ctx.device().grid;
+        rr_node_indices.resize(grid.width());
+        for (size_t i = 0; i < grid.width(); i++) {
+            rr_node_indices[i].resize(grid.height());
+        }
+    }
+
+    // insert node_idx at location
+    rr_node_indices[x][y].push_back(node_idx);
+    Coordinates location = {x, y};
+    locations.push_back(location);
+}
 
 //void ClockRRGraph::create_star_model_network() {
 //

vpr/src/route/rr_graph_clock.h

@@ -35,19 +35,7 @@ class SwitchPoint {
         std::vector<std::vector<std::vector<int>>> rr_node_indices;
         std::vector<Coordinates> locations;
     public:
-        /*
-         * Constructors
-         */
-        SwitchPoint() {};
-        SwitchPoint(int grid_width, int grid_height) :
-            rr_node_indices(
-                    grid_width,
-                    std::vector<std::vector<int>>(grid_height, std::vector<int>())) {};
-        void insert_node_idx(int x, int y, int node_idx) {
-            rr_node_indices[x][y].push_back(node_idx);
-            Coordinates location = {x, y};
-            locations.push_back(location);
-        }
+        void insert_node_idx(int x, int y, int node_idx);
 };
 
 class SwitchPoints {
@@ -57,13 +45,7 @@ class SwitchPoints {
         /** Getters **/
 
         /** Setters **/
-        void insert_switch(std::string switch_name, SwitchPoint switch_point) {
-            // TODO make sure every switch name is unique
-            switch_name_to_switch_location.emplace(switch_name, switch_point);
-        }
-        void insert_switch_node_idx(std::string switch_name, int x, int y, int node_index) {
-            switch_name_to_switch_location[switch_name].insert_node_idx(x, y, node_index);
-        }
+        void insert_switch_node_idx(std::string switch_name, int x, int y, int node_idx);
 };
 
 class ClockRRGraph {