copy router from dev

compiler/router/graph.py

@@ -185,7 +185,7 @@ class graph:
         return False
 
 
-    def create_graph(self, source, target, scale=1):
+    def create_graph(self, source, target):
         """ Create the graph to run routing on later. """
         debug.info(3, "Creating the graph for source '{}' and target'{}'.".format(source, target))
 
@@ -223,9 +223,6 @@ class graph:
         debug.info(4, "Number of vias detected in the routing region: {}".format(len(self.graph_vias)))
         debug.info(4, "Number of nodes in the routing graph: {}".format(len(self.nodes)))
 
-        # Return the region to scale later if no path is found
-        return region.rect
-
 
     def find_graph_blockages(self, region):
         """ Find blockages that overlap the routing region. """
@@ -439,6 +436,7 @@ class graph:
                     path.append(current)
                     current = came_from[current.id]
                 path.append(current)
+                path.reverse()
                 return path
 
             # Get the previous node to better calculate the next costs

compiler/router/graph_shape.py

@@ -72,17 +72,6 @@ class graph_shape(pin_layout):
         return graph_shape(self.name, inflated_area, self.layer, self)
 
 
-    def multiply(self, scale):
-        """ Multiply the width and height with the scale value. """
-
-        width = (self.width() * (scale - 1)) / 2
-        height = (self.height() * (scale - 1)) / 2
-        ll, ur = self.rect
-        newll = vector(ll.x - width, ll.y - height)
-        newur = vector(ur.x + width, ur.y + height)
-        self.rect = [snap(newll), snap(newur)]
-
-
     def core_contained_by_any(self, shape_list):
         """
         Return if the core of this shape is contained by any shape's core in the

compiler/router/router.py

@@ -59,6 +59,8 @@ class router(router_tech):
     def prepare_gds_reader(self):
         """ Write the current layout to a temporary file to read the layout. """
 
+        # NOTE: Avoid using this function if possible since it is too slow to
+        # write/read these files
         self.design.gds_write(self.gds_filename)
         self.layout = gdsMill.VlsiLayout(units=GDS["unit"])
         self.reader = gdsMill.Gds2reader(self.layout)
@@ -109,16 +111,26 @@ class router(router_tech):
         self.all_pins.update(pin_set)
 
 
-    def find_blockages(self, name="blockage"):
+    def find_blockages(self, name="blockage", shape_list=None):
         """ Find all blockages in the routing layers. """
         debug.info(4, "Finding blockages...")
 
         for lpp in [self.vert_lpp, self.horiz_lpp]:
-            shapes = self.layout.getAllShapes(lpp)
+            # If the list of shapes is given, don't get them from gdsMill
+            if shape_list is None:
+                shapes = self.layout.getAllShapes(lpp)
+            else:
+                shapes = shape_list
             for boundary in shapes:
-                # gdsMill boundaries are in (left, bottom, right, top) order
-                ll = vector(boundary[0], boundary[1])
-                ur = vector(boundary[2], boundary[3])
+                if shape_list is not None:
+                    if boundary.lpp != lpp:
+                        continue
+                    ll = boundary.ll()
+                    ur = boundary.ur()
+                else:
+                    # gdsMill boundaries are in (left, bottom, right, top) order
+                    ll = vector(boundary[0], boundary[1])
+                    ur = vector(boundary[2], boundary[3])
                 rect = [ll, ur]
                 new_shape = graph_shape(name, rect, lpp)
                 new_shape = self.inflate_shape(new_shape)
@@ -132,20 +144,28 @@ class router(router_tech):
                 self.blockages.append(new_shape)
 
 
-    def find_vias(self):
+    def find_vias(self, shape_list=None):
         """ Find all vias in the routing layers. """
         debug.info(4, "Finding vias...")
 
         # Prepare lpp values here
         from openram.tech import layer
         via_lpp = layer[self.via_layer_name]
-        valid_lpp = self.horiz_lpp
+        valid_lpp = self.horiz_lpp # Just a temporary lpp to prevent errors
 
-        shapes = self.layout.getAllShapes(via_lpp)
+        # If the list of shapes is given, don't get them from gdsMill
+        if shape_list is None:
+            shapes = self.layout.getAllShapes(via_lpp)
+        else:
+            shapes = shape_list
         for boundary in shapes:
-            # gdsMill boundaries are in (left, bottom, right, top) order
-            ll = vector(boundary[0], boundary[1])
-            ur = vector(boundary[2], boundary[3])
+            if shape_list is not None:
+                ll = boundary.ll()
+                ur = boundary.ur()
+            else:
+                # gdsMill boundaries are in (left, bottom, right, top) order
+                ll = vector(boundary[0], boundary[1])
+                ur = vector(boundary[2], boundary[3])
             rect = [ll, ur]
             new_shape = graph_shape("via", rect, valid_lpp)
             # Skip this via if it's contained by an existing via blockage
@@ -264,7 +284,8 @@ class router(router_tech):
         working for this router.
         """
 
-        new_shapes = []
+        new_wires = []
+        new_vias = []
         for i in range(0, len(nodes) - 1):
             start = nodes[i].center
             end = nodes[i + 1].center
@@ -275,15 +296,16 @@ class router(router_tech):
                             offset.y - self.half_wire)
             if direction == (1, 1): # Via
                 offset = vector(start.x, start.y)
-                self.design.add_via_center(layers=self.layers,
-                                           offset=offset)
+                via = self.design.add_via_center(layers=self.layers,
+                                                 offset=offset)
+                new_vias.append(via)
             else: # Wire
-                shape = self.design.add_rect(layer=self.get_layer(start.z),
-                                             offset=offset,
-                                             width=abs(diff.x) + self.track_wire,
-                                             height=abs(diff.y) + self.track_wire)
-                new_shapes.append(shape)
-        return new_shapes
+                wire = self.design.add_rect(layer=self.get_layer(start.z),
+                                            offset=offset,
+                                            width=abs(diff.x) + self.track_wire,
+                                            height=abs(diff.y) + self.track_wire)
+                new_wires.append(wire)
+        return new_wires, new_vias
 
 
     def write_debug_gds(self, gds_name, g=None, source=None, target=None):