Cleanup code. Add time breakdown for SRAM creation.

compiler/router/router.py

@@ -70,8 +70,7 @@ class router(router_tech):
         self.boundary = self.layout.measureBoundary(self.top_name)
         # These must be un-indexed to get rid of the matrix type
         self.ll = vector(self.boundary[0][0], self.boundary[0][1])
-        # Pad the UR by a few tracks to add an extra rail possibly
+        self.ur = vector(self.boundary[1][0], self.boundary[1][1]) 
-        self.ur = vector(self.boundary[1][0], self.boundary[1][1]) + self.track_widths.scale(5,5)
 
     def clear_pins(self):
         """

compiler/router/router_tech.py

@@ -48,9 +48,9 @@ class router_tech:
         self.track_width = max(self.horiz_track_width,self.vert_track_width)
         debug.info(1,"Track width: {:.3f}".format(self.track_width))
         self.track_space = max(self.horiz_layer_spacing,self.vert_layer_spacing)
-        debug.info(1,"Track spacing: {:.3f}".format(self.track_space))
+        debug.info(1,"Track space: {:.3f}".format(self.track_space))
         self.track_wire = self.track_width - self.track_space
-        debug.info(1,"Wire width: {:.3f}".format(self.track_wire))
+        debug.info(1,"Track wire width: {:.3f}".format(self.track_wire))
         
         self.track_widths = vector([self.track_width] * 2)
         self.track_factor = vector([1/self.track_width] * 2)

compiler/router/supply_router.py

@@ -64,17 +64,10 @@ class supply_router(router):
             # but this is simplest for now.
             self.create_routing_grid()
 
-        # Compute the grid dimensions
-        self.compute_supply_rail_dimensions()
-            
         # Get the pin shapes
-        #start_time = datetime.now()
         self.find_pins_and_blockages([self.vdd_name, self.gnd_name])
-        #print_time("Pins and blockages",datetime.now(), start_time)
-        #self.write_debug_gds("pin_enclosures.gds",stop_program=True)
 
         # Add the supply rails in a mesh network and connect H/V with vias
-        #start_time = datetime.now()
         # Block everything
         self.prepare_blockages(self.gnd_name)
         # Determine the rail locations
@@ -84,22 +77,14 @@ class supply_router(router):
         self.prepare_blockages(self.vdd_name)
         # Determine the rail locations
         self.route_supply_rails(self.vdd_name,1)
-        #self.write_debug_gds("debug_rails.gds",stop_program=True)
-        #print_time("Supply rails",datetime.now(), start_time)
         
-        #start_time = datetime.now()
         self.route_simple_overlaps(vdd_name)
         self.route_simple_overlaps(gnd_name)
-        #print_time("Simple overlaps",datetime.now(), start_time)
-        #self.write_debug_gds("debug_simple_route.gds",stop_program=False)
         
         # Route the supply pins to the supply rails
         # Route vdd first since we want it to be shorter
-        #start_time = datetime.now()
         self.route_pins_to_rails(vdd_name)
         self.route_pins_to_rails(gnd_name)
-        #print_time("Routing",datetime.now(), start_time)        
-        #self.write_debug_gds("debug_pin_routes.gds",stop_program=True)
 
         #self.write_debug_gds("final.gds",False)  
         
@@ -227,40 +212,6 @@ class supply_router(router):
                                      width=pin.width(),
                                      height=pin.height())
 
-    def compute_supply_rail_dimensions(self):
-        """
-        Compute the supply rail dimensions including wide metal spacing rules.
-        """
-        
-        self.max_yoffset = self.rg.ur.y
-        self.max_xoffset = self.rg.ur.x
-
-        # # Longest length is conservative
-        # rail_length = max(self.max_yoffset,self.max_xoffset)
-        # # Convert the number of tracks to dimensions to get the design rule spacing
-        # rail_width = self.track_width*self.rail_track_width
-
-        # # Get the conservative width and spacing of the top rails
-        # (horizontal_width, horizontal_space) = self.get_supply_layer_width_space(0)
-        # (vertical_width, vertical_space) = self.get_supply_layer_width_space(1)
-        # width = max(horizontal_width, vertical_width)
-        # space = max(horizontal_space, vertical_space)
-        
-        # track_pitch = width + space
-
-        # # Determine the pitch (in tracks) of the rail wire + spacing
-        # self.supply_rail_width = math.ceil(track_pitch/self.track_width)
-        # debug.info(1,"Rail step: {}".format(self.supply_rail_width))
-        
-        # # Conservatively determine the number of tracks that the rail actually occupies
-        # space_tracks = math.ceil(space/self.track_width)
-        # self.supply_rail_wire_width = self.supply_rail_width - space_tracks
-        # debug.info(1,"Rail wire tracks: {}".format(self.supply_rail_wire_width))
-        # total_space = self.supply_rail_width - self.supply_rail_wire_width
-        # self.supply_rail_space_width = math.floor(0.5*total_space)
-        # debug.info(1,"Rail space tracks: {} (on both sides)".format(self.supply_rail_space_width))
-
-
     def compute_supply_rails(self, name, supply_number):
         """
         Compute the unblocked locations for the horizontal and vertical supply rails.
@@ -270,14 +221,19 @@ class supply_router(router):
 
         self.supply_rails[name]=[]
         
-        start_offset = supply_number
+        max_yoffset = self.rg.ur.y
+        max_xoffset = self.rg.ur.x
+        min_yoffset = self.rg.ll.y
+        min_xoffset = self.rg.ll.x
+
+        start_offset = min_yoffset + supply_number
         
         # Horizontal supply rails
-        for offset in range(start_offset, self.max_yoffset, 2):
+        for offset in range(start_offset, max_yoffset, 2):
             # Seed the function at the location with the given width
-            wave = [vector3d(0,offset,0)]
+            wave = [vector3d(min_xoffset,offset,0)]
             # While we can keep expanding east in this horizontal track
-            while wave and wave[0].x < self.max_xoffset:
+            while wave and wave[0].x < max_xoffset:
                 added_rail = self.find_supply_rail(name, wave, direction.EAST)
                 if not added_rail:
                     # Just seed with the next one
@@ -288,11 +244,11 @@ class supply_router(router):
 
         # Vertical supply rails
         max_offset = self.rg.ur.x
-        for offset in range(start_offset, self.max_xoffset, 2):
+        for offset in range(start_offset, max_xoffset, 2):
             # Seed the function at the location with the given width
-            wave = [vector3d(offset,0,1)]
+            wave = [vector3d(offset,min_yoffset,1)]
             # While we can keep expanding north in this vertical track
-            while wave and wave[0].y < self.max_yoffset:
+            while wave and wave[0].y < max_yoffset:
                 added_rail = self.find_supply_rail(name, wave, direction.NORTH)
                 if not added_rail:
                     # Just seed with the next one

compiler/sram_1bank.py

@@ -21,11 +21,6 @@ class sram_1bank(sram_base):
     def __init__(self, name, sram_config):
         sram_base.__init__(self, name, sram_config)
         
-
-    def create_netlist(self):
-        sram_base.create_netlist(self)
-        self.create_modules()
-
     def create_modules(self):
         """ 
         This adds the modules for a single bank SRAM with control

compiler/sram_base.py

@@ -2,6 +2,7 @@ import sys
 import datetime
 import getpass
 import debug
+from datetime import datetime
 from importlib import reload
 from vector import vector
 from globals import OPTS, print_time
@@ -64,35 +65,50 @@ class sram_base(design):
     def create_netlist(self):
         """ Netlist creation """
         
+        start_time = datetime.now()
+        
         # Must create the control logic before pins to get the pins
         self.add_modules()
         self.add_pins()
+        self.create_modules()
         
         # This is for the lib file if we don't create layout
         self.width=0
         self.height=0
         
 
+        if not OPTS.is_unit_test:
+            print_time("Netlisting",datetime.now(), start_time)
+
+        
     def create_layout(self):
         """ Layout creation """    
+        start_time = datetime.now()
         self.place_instances()
+        if not OPTS.is_unit_test:
+            print_time("Placement",datetime.now(), start_time)
 
+        start_time = datetime.now()
         self.route_layout()
+        self.route_supplies()
+        if not OPTS.is_unit_test:
+            print_time("Routing",datetime.now(), start_time)
 
         self.add_lvs_correspondence_points()
         
         self.offset_all_coordinates()
 
-        # Must be done after offsetting lower-left
-        self.route_supplies()
-
         highest_coord = self.find_highest_coords()
         self.width = highest_coord[0]
         self.height = highest_coord[1]
 
-        
+        start_time = datetime.now()
         self.DRC_LVS(final_verification=True)
+        if not OPTS.is_unit_test:
+            print_time("Verification",datetime.now(), start_time)
 
+    def create_modules(self):
+        debug.error("Must override pure virtual function.",-1)
     
     def route_supplies(self):
         """ Route the supply grid and connect the pins to them. """