luke
/
OpenRAM
mirror of https://github.com/VLSIDA/OpenRAM.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reduce verbosity of level 1 debug.

This commit is contained in:
Matt Guthaus 2018-11-02 17:30:28 -07:00
parent f8e761313a
commit a3666d82ab
3 changed files with 27 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
compiler/router/router.py
View File

@ -114,7 +114,7 @@ class router(router_tech):
self.all_pins.update(pin_set) self.all_pins.update(pin_set)
for pin in self.pins[pin_name]: for pin in self.pins[pin_name]:
debug.info(2,"Retrieved pin {}".format(str(pin))) debug.info(3,"Retrieved pin {}".format(str(pin)))
@ -123,6 +123,8 @@ class router(router_tech):
Finds the pin shapes and converts to tracks. Finds the pin shapes and converts to tracks.
Pin can either be a label or a location,layer pair: [[x,y],layer]. Pin can either be a label or a location,layer pair: [[x,y],layer].
""" """
debug.info(1,"Finding pins for {}.".format(pin_name))
self.retrieve_pins(pin_name) self.retrieve_pins(pin_name)
self.analyze_pins(pin_name) self.analyze_pins(pin_name)
@ -133,6 +135,7 @@ class router(router_tech):
This doesn't consider whether the obstacles will be pins or not. They get reset later This doesn't consider whether the obstacles will be pins or not. They get reset later
if they are not actually a blockage. if they are not actually a blockage.
""" """
debug.info(1,"Finding blockages.")
for layer in [self.vert_layer_number,self.horiz_layer_number]: for layer in [self.vert_layer_number,self.horiz_layer_number]:
self.retrieve_blockages(layer) self.retrieve_blockages(layer)
@ -203,15 +206,15 @@ class router(router_tech):
if pg1.adjacent(pg2): if pg1.adjacent(pg2):
combined = pin_group(pin_name, [], self) combined = pin_group(pin_name, [], self)
combined.combine_groups(pg1, pg2) combined.combine_groups(pg1, pg2)
debug.info(2,"Combining {0} {1} {2}:".format(pin_name, index1, index2)) debug.info(3,"Combining {0} {1} {2}:".format(pin_name, index1, index2))
debug.info(2, " {0}\n {1}".format(pg1.pins, pg2.pins)) debug.info(3, " {0}\n {1}".format(pg1.pins, pg2.pins))
debug.info(2," --> {0}\n {1}".format(combined.pins,combined.grids)) debug.info(3," --> {0}\n {1}".format(combined.pins,combined.grids))
remove_indices.update([index1,index2]) remove_indices.update([index1,index2])
pin_groups.append(combined) pin_groups.append(combined)
break break
# Remove them in decreasing order to not invalidate the indices # Remove them in decreasing order to not invalidate the indices
debug.info(2,"Removing {}".format(sorted(remove_indices))) debug.info(4,"Removing {}".format(sorted(remove_indices)))
for i in sorted(remove_indices, reverse=True): for i in sorted(remove_indices, reverse=True):
del pin_groups[i] del pin_groups[i]
@ -228,7 +231,7 @@ class router(router_tech):
Make multiple passes of the combine adjacent pins until we have no Make multiple passes of the combine adjacent pins until we have no
more combinations or hit an iteration limit. more combinations or hit an iteration limit.
""" """
debug.info(1,"Combining adjacent pins for {}.".format(pin_name))
# Start as None to signal the first iteration # Start as None to signal the first iteration
num_removed_pairs = None num_removed_pairs = None
@ -245,6 +248,7 @@ class router(router_tech):
This will try to separate all grid pins by the supplied number of separation This will try to separate all grid pins by the supplied number of separation
tracks (default is to prevent adjacency). tracks (default is to prevent adjacency).
""" """
debug.info(1,"Separating adjacent pins.")
# Commented out to debug with SCMOS # Commented out to debug with SCMOS
#if separation==0: #if separation==0:
# return # return
@ -270,7 +274,7 @@ class router(router_tech):
grids_g1, grids_g2 = pg1.adjacent_grids(pg2, separation) grids_g1, grids_g2 = pg1.adjacent_grids(pg2, separation)
# These should have the same length, so... # These should have the same length, so...
if len(grids_g1)>0: if len(grids_g1)>0:
debug.info(1,"Adjacent grids {0} {1} {2} {3}".format(index1,grids_g1,index2,grids_g2)) debug.info(3,"Adjacent grids {0} {1} {2} {3}".format(index1,grids_g1,index2,grids_g2))
self.remove_adjacent_grid(pg1, grids_g1, pg2, grids_g2) self.remove_adjacent_grid(pg1, grids_g1, pg2, grids_g2)
def remove_adjacent_grid(self, pg1, grids1, pg2, grids2): def remove_adjacent_grid(self, pg1, grids1, pg2, grids2):
@ -292,12 +296,12 @@ class router(router_tech):
# First, see if we can remove grids that are in the secondary grids # First, see if we can remove grids that are in the secondary grids
# i.e. they aren't necessary to the pin grids # i.e. they aren't necessary to the pin grids
if bigger_grids.issubset(bigger.secondary_grids): if bigger_grids.issubset(bigger.secondary_grids):
debug.info(1,"Removing {} from bigger {}".format(str(bigger_grids), bigger)) debug.info(3,"Removing {} from bigger {}".format(str(bigger_grids), bigger))
bigger.grids.difference_update(bigger_grids) bigger.grids.difference_update(bigger_grids)
self.blocked_grids.update(bigger_grids) self.blocked_grids.update(bigger_grids)
return return
elif smaller_grids.issubset(smaller.secondary_grids): elif smaller_grids.issubset(smaller.secondary_grids):
debug.info(1,"Removing {} from smaller {}".format(str(smaller_grids), smaller)) debug.info(3,"Removing {} from smaller {}".format(str(smaller_grids), smaller))
smaller.grids.difference_update(smaller_grids) smaller.grids.difference_update(smaller_grids)
self.blocked_grids.update(smaller_grids) self.blocked_grids.update(smaller_grids)
return return
@ -426,7 +430,7 @@ class router(router_tech):
def convert_blockages(self): def convert_blockages(self):
""" Convert blockages to grid tracks. """ """ Convert blockages to grid tracks. """
debug.info(1,"Converting blockages.")
for blockage in self.blockages: for blockage in self.blockages:
debug.info(3,"Converting blockage {}".format(str(blockage))) debug.info(3,"Converting blockage {}".format(str(blockage)))
blockage_list = self.convert_blockage(blockage) blockage_list = self.convert_blockage(blockage)
@ -684,6 +688,7 @@ class router(router_tech):
""" """
Convert the pin groups into pin tracks and blockage tracks. Convert the pin groups into pin tracks and blockage tracks.
""" """
debug.info(1,"Converting pins for {}.".format(pin_name))
for pg in self.pin_groups[pin_name]: for pg in self.pin_groups[pin_name]:
pg.convert_pin() pg.convert_pin()
@ -733,7 +738,7 @@ class router(router_tech):
debug.check(index<self.num_pin_components(pin_name),"Pin component index too large.") debug.check(index<self.num_pin_components(pin_name),"Pin component index too large.")
pin_in_tracks = self.pin_groups[pin_name][index].grids pin_in_tracks = self.pin_groups[pin_name][index].grids
debug.info(1,"Set source: " + str(pin_name) + " " + str(pin_in_tracks)) debug.info(2,"Set source: " + str(pin_name) + " " + str(pin_in_tracks))
self.rg.add_source(pin_in_tracks) self.rg.add_source(pin_in_tracks)
def add_path_target(self, paths): def add_path_target(self, paths):
@ -752,7 +757,7 @@ class router(router_tech):
debug.check(index<self.num_pin_grids(pin_name),"Pin component index too large.") debug.check(index<self.num_pin_grids(pin_name),"Pin component index too large.")
pin_in_tracks = self.pin_groups[pin_name][index].grids pin_in_tracks = self.pin_groups[pin_name][index].grids
debug.info(1,"Set target: " + str(pin_name) + " " + str(pin_in_tracks)) debug.info(2,"Set target: " + str(pin_name) + " " + str(pin_in_tracks))
self.rg.add_target(pin_in_tracks) self.rg.add_target(pin_in_tracks)
@ -760,7 +765,7 @@ class router(router_tech):
""" """
Block all of the pin components. Block all of the pin components.
""" """
debug.info(2,"Setting blockages {0} {1}".format(pin_name,value)) debug.info(3,"Setting blockages {0} {1}".format(pin_name,value))
for pg in self.pin_groups[pin_name]: for pg in self.pin_groups[pin_name]:
self.set_blockages(pg.grids, value) self.set_blockages(pg.grids, value)
@ -796,7 +801,7 @@ class router(router_tech):
""" """
path=self.prepare_path(path) path=self.prepare_path(path)
debug.info(1,"Adding route: {}".format(str(path))) debug.info(2,"Adding route: {}".format(str(path)))
# If it is only a square, add an enclosure to the track # If it is only a square, add an enclosure to the track
if len(path)==1: if len(path)==1:
self.add_single_enclosure(path[0][0]) self.add_single_enclosure(path[0][0])

2
compiler/router/router_tech.py
View File

@ -37,7 +37,7 @@ class router_tech:
self.track_widths = [self.track_width] * 2 self.track_widths = [self.track_width] * 2
self.track_factor = [1/self.track_width] * 2 self.track_factor = [1/self.track_width] * 2
debug.info(1,"Track factor: {0}".format(self.track_factor)) debug.info(2,"Track factor: {0}".format(self.track_factor))
# When we actually create the routes, make them the width of the track (minus 1/2 spacing on each side) # When we actually create the routes, make them the width of the track (minus 1/2 spacing on each side)
self.layer_widths = [self.track_width - self.horiz_layer_spacing, 1, self.track_width - self.vert_layer_spacing] self.layer_widths = [self.track_width - self.horiz_layer_spacing, 1, self.track_width - self.vert_layer_spacing]

13
compiler/router/supply_router.py
View File

@ -218,7 +218,7 @@ class supply_router(router):
ur = grid_utils.get_upper_right(rail) ur = grid_utils.get_upper_right(rail)
z = ll.z z = ll.z
pin = self.compute_wide_enclosure(ll, ur, z, name) pin = self.compute_wide_enclosure(ll, ur, z, name)
debug.info(1,"Adding supply rail {0} {1}->{2} {3}".format(name,ll,ur,pin)) debug.info(2,"Adding supply rail {0} {1}->{2} {3}".format(name,ll,ur,pin))
self.cell.add_layout_pin(text=name, self.cell.add_layout_pin(text=name,
layer=pin.layer, layer=pin.layer,
offset=pin.ll(), offset=pin.ll(),
@ -387,6 +387,7 @@ class supply_router(router):
Route the horizontal and vertical supply rails across the entire design. Route the horizontal and vertical supply rails across the entire design.
Must be done with lower left at 0,0 Must be done with lower left at 0,0
""" """
debug.info(1,"Routing supply rail {0}.".format(name))
# Compute the grid locations of the supply rails # Compute the grid locations of the supply rails
self.compute_supply_rails(name, supply_number) self.compute_supply_rails(name, supply_number)
@ -420,14 +421,14 @@ class supply_router(router):
""" """
remaining_components = sum(not x.is_routed() for x in self.pin_groups[pin_name]) remaining_components = sum(not x.is_routed() for x in self.pin_groups[pin_name])
debug.info(1,"Pin {0} has {1} remaining components to route.".format(pin_name, debug.info(1,"Routing {0} with {1} pin components to route.".format(pin_name,
remaining_components)) remaining_components))
for index,pg in enumerate(self.pin_groups[pin_name]): for index,pg in enumerate(self.pin_groups[pin_name]):
if pg.is_routed(): if pg.is_routed():
continue continue
debug.info(2,"Routing component {0} {1}".format(pin_name, index)) debug.info(3,"Routing component {0} {1}".format(pin_name, index))
# Clear everything in the routing grid. # Clear everything in the routing grid.
self.rg.reinit() self.rg.reinit()
@ -453,7 +454,7 @@ class supply_router(router):
""" """
Add the supply rails of given name as a routing target. Add the supply rails of given name as a routing target.
""" """
debug.info(2,"Add supply rail target {}".format(pin_name)) debug.info(4,"Add supply rail target {}".format(pin_name))
# Add the wire itself as the target # Add the wire itself as the target
self.rg.set_target(self.supply_rail_wire_tracks[pin_name]) self.rg.set_target(self.supply_rail_wire_tracks[pin_name])
# But unblock all the rail tracks including the space # But unblock all the rail tracks including the space
@ -464,7 +465,7 @@ class supply_router(router):
""" """
Add the supply rails of given name as a routing target. Add the supply rails of given name as a routing target.
""" """
debug.info(3,"Blocking supply rail") debug.info(4,"Blocking supply rail")
for rail_name in self.supply_rail_tracks: for rail_name in self.supply_rail_tracks:
self.rg.set_blocked(self.supply_rail_tracks[rail_name]) self.rg.set_blocked(self.supply_rail_tracks[rail_name])