diff --git a/compiler/router/router.py b/compiler/router/router.py index 49e74c7c..ef7157da 100644 --- a/compiler/router/router.py +++ b/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.track_widths.scale(5,5) + self.ur = vector(self.boundary[1][0], self.boundary[1][1]) def clear_pins(self): """ diff --git a/compiler/router/router_tech.py b/compiler/router/router_tech.py index a565201d..02b6894f 100644 --- a/compiler/router/router_tech.py +++ b/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) diff --git a/compiler/router/supply_router.py b/compiler/router/supply_router.py index e5c8dd7d..0596aaf0 100644 --- a/compiler/router/supply_router.py +++ b/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,23 +77,15 @@ 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) return True @@ -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 diff --git a/compiler/sram_1bank.py b/compiler/sram_1bank.py index be7f20ff..e43dac72 100644 --- a/compiler/sram_1bank.py +++ b/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 diff --git a/compiler/sram_base.py b/compiler/sram_base.py index 3182c5b3..be0797fc 100644 --- a/compiler/sram_base.py +++ b/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 @@ -63,37 +64,52 @@ 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. """