mirror of https://github.com/VLSIDA/OpenRAM.git
247 lines
8.7 KiB
Python
247 lines
8.7 KiB
Python
import gdsMill
|
|
import tech
|
|
from contact import contact
|
|
import math
|
|
import debug
|
|
from globals import OPTS
|
|
import grid
|
|
from pin_layout import pin_layout
|
|
from vector import vector
|
|
from vector3d import vector3d
|
|
from router import router
|
|
from direction import direction
|
|
|
|
class supply_router(router):
|
|
"""
|
|
A router class to read an obstruction map from a gds and
|
|
routes a grid to connect the supply on the two layers.
|
|
"""
|
|
|
|
def __init__(self, gds_name=None, module=None):
|
|
"""
|
|
Use the gds file for the blockages with the top module topName and
|
|
layers for the layers to route on
|
|
"""
|
|
router.__init__(self, gds_name, module)
|
|
|
|
# Power rail width in grid units.
|
|
self.rail_track_width = 2
|
|
|
|
|
|
def create_routing_grid(self):
|
|
"""
|
|
Create a sprase routing grid with A* expansion functions.
|
|
"""
|
|
size = self.ur - self.ll
|
|
debug.info(1,"Size: {0} x {1}".format(size.x,size.y))
|
|
|
|
import supply_grid
|
|
self.rg = supply_grid.supply_grid(self.ll, self.ur, self.track_width)
|
|
|
|
def route(self, cell, layers, vdd_name="vdd", gnd_name="gnd"):
|
|
"""
|
|
Add power supply rails and connect all pins to these rails.
|
|
"""
|
|
debug.info(1,"Running supply router on {0} and {1}...".format(vdd_name, gnd_name))
|
|
self.cell = cell
|
|
self.vdd_name = vdd_name
|
|
self.gnd_name = gnd_name
|
|
|
|
# Clear the pins if we have previously routed
|
|
if (hasattr(self,'rg')):
|
|
self.clear_pins()
|
|
else:
|
|
# Set up layers and track sizes
|
|
self.set_layers(layers)
|
|
# Creat a routing grid over the entire area
|
|
# FIXME: This could be created only over the routing region,
|
|
# but this is simplest for now.
|
|
self.create_routing_grid()
|
|
# This will get all shapes as blockages
|
|
self.find_blockages()
|
|
|
|
# Get the pin shapes
|
|
self.find_pins(self.vdd_name)
|
|
self.find_pins(self.gnd_name)
|
|
|
|
# Add the supply rails in a mesh network and connect H/V with vias
|
|
self.prepare_blockages(block_names=[self.vdd_name],unblock_names=[self.gnd_name])
|
|
self.route_supply_rails(self.gnd_name,0)
|
|
|
|
self.prepare_blockages(block_names=[self.gnd_name],unblock_names=[self.vdd_name])
|
|
self.route_supply_rails(self.vdd_name,1)
|
|
|
|
|
|
# Route the supply pins to the supply rails
|
|
#self.route_pins_to_rails(gnd_name)
|
|
#self.route_pins_to_rails(vdd_name)
|
|
|
|
self.write_debug_gds()
|
|
return False
|
|
|
|
def prepare_blockages(self, block_names=None, unblock_names=None):
|
|
"""
|
|
Reset and add all of the blockages in the design.
|
|
Names is a list of pins to add as a blockage.
|
|
"""
|
|
# Start fresh. Not the best for run-time, but simpler.
|
|
self.clear_blockages()
|
|
# This adds the initial blockges of the design
|
|
print("BLOCKING:",self.blocked_grids)
|
|
self.set_blockages(self.blocked_grids,True)
|
|
# This is conservative to prevent DRC violations on partially blocked tracks
|
|
if block_names:
|
|
for name in block_names:
|
|
# These are the partially blocked tracks around supply pins.
|
|
print("BLOCKING PARTIALS:",name,self.pin_partials[name])
|
|
self.set_blockages(self.pin_partials[name],True)
|
|
# These are the actual supply pins
|
|
self.set_blockages(self.pin_grids[name],True)
|
|
print("BLOCKING GRIDS:",name,self.pin_grids[name])
|
|
# This will unblock
|
|
if unblock_names:
|
|
for name in unblock_names:
|
|
# These are the partially blocked tracks around supply pins.
|
|
self.set_blockages(self.pin_partials[name],False)
|
|
print("UNBLOCKING PARTIALS:",name,self.pin_partials[name])
|
|
# These are the actual supply pins
|
|
self.set_blockages(self.pin_grids[name],False)
|
|
print("UNBLOCKING GRIDS:",name,self.pin_grids[name])
|
|
|
|
# These are the paths that have already been routed.
|
|
self.set_path_blockages()
|
|
|
|
def connect_supply_rails(self, name):
|
|
"""
|
|
Add vias between overlapping supply rails.
|
|
"""
|
|
paths = [x for x in self.paths if x.name == name]
|
|
|
|
# Split into horizontal and vertical
|
|
vertical_paths = [x for x in paths if x[0][0].z==1]
|
|
horizontal_paths = [x for x in paths if x[0][0].z==0]
|
|
|
|
shared_areas = []
|
|
for v in vertical_paths:
|
|
for h in horizontal_paths:
|
|
overlap = v.overlap(h)
|
|
if overlap:
|
|
(ll,ur) = overlap
|
|
# Only add if the overlap is wide enough
|
|
if ur.x-ll.x >= self.rail_track_width-1 and ur.y-ll.y >= self.rail_track_width-1:
|
|
shared_areas.append(overlap)
|
|
|
|
|
|
for (ll,ur) in shared_areas:
|
|
center = (ll + ur).scale(0.5,0.5,0)
|
|
self.add_via(center,self.rail_track_width)
|
|
|
|
|
|
|
|
def route_supply_rails(self, name, supply_number):
|
|
"""
|
|
Route the horizontal and vertical supply rails across the entire design.
|
|
"""
|
|
|
|
start_offset = supply_number*self.rail_track_width
|
|
max_yoffset = self.rg.ur.y
|
|
max_xoffset = self.rg.ur.x
|
|
step_offset = 2*self.rail_track_width
|
|
|
|
# Horizontal supply rails
|
|
for offset in range(start_offset, max_yoffset, step_offset):
|
|
# Seed the function at the location with the given width
|
|
wave = [vector3d(0,offset+i,0) for i in range(self.rail_track_width)]
|
|
# While we can keep expanding east in this horizontal track
|
|
while wave and wave[0].x < max_xoffset:
|
|
wave = self.route_supply_rail(name, wave, direction.EAST)
|
|
|
|
|
|
# Vertical supply rails
|
|
max_offset = self.rg.ur.x
|
|
for offset in range(start_offset, max_xoffset, step_offset):
|
|
# Seed the function at the location with the given width
|
|
wave = [vector3d(offset+i,0,1) for i in range(self.rail_track_width)]
|
|
# While we can keep expanding north in this vertical track
|
|
while wave and wave[0].y < max_yoffset:
|
|
wave = self.route_supply_rail(name, wave, direction.NORTH)
|
|
|
|
# Remember index of path size which is how many rails we had at the start
|
|
self.num_rails = len(self.paths)
|
|
|
|
# Add teh supply rail vias
|
|
self.connect_supply_rails(name)
|
|
|
|
|
|
def route_supply_rail(self, name, seed_wave, direct):
|
|
"""
|
|
This finds the first valid starting location and routes a supply rail
|
|
in the given direction.
|
|
It returns the space after the end of the rail to seed another call for multiple
|
|
supply rails in the same "track" when there is a blockage.
|
|
"""
|
|
|
|
# Sweep to find an initial unblocked valid wave
|
|
start_wave = self.rg.find_start_wave(seed_wave, len(seed_wave), direct)
|
|
if not start_wave:
|
|
return None
|
|
|
|
# Expand the wave to the right
|
|
wave_path = self.rg.probe(start_wave, direct)
|
|
if not wave_path:
|
|
return None
|
|
|
|
# Filter any path that won't span 2 rails
|
|
# so that we can guarantee it is connected
|
|
if len(wave_path)>=2*self.rail_track_width:
|
|
self.add_wavepath(name, wave_path)
|
|
wave_path.name = name
|
|
self.paths.append(wave_path)
|
|
|
|
# seed the next start wave location
|
|
wave_end = wave_path[-1]
|
|
return wave_path.neighbor(direct)
|
|
|
|
|
|
|
|
|
|
|
|
def route_pins_to_rails(self,pin_name):
|
|
"""
|
|
This will route each of the pin components to the supply rails.
|
|
After it is done, the cells are added to the pin blockage list.
|
|
"""
|
|
|
|
|
|
# For every component
|
|
for index in range(self.num_pin_components(pin_name)):
|
|
|
|
self.rg.reinit()
|
|
|
|
self.prepare_blockages(block_names=None,unblock_names=[pin_name])
|
|
|
|
# Block all the pin components first
|
|
self.set_component_blockages(pin_name, True)
|
|
|
|
# Add the single component of the pin as the source
|
|
# which unmarks it as a blockage too
|
|
self.add_pin_component(pin_name,index,is_source=True)
|
|
|
|
# Add all of the rails as targets
|
|
# Don't add the other pins, but we could?
|
|
self.add_supply_rail_target(pin_name)
|
|
|
|
# Actually run the A* router
|
|
self.run_router(detour_scale=5)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|