blob: 1cdc52cbea8fd1e986a52ccba192a0fff8482324 [file] [log] [blame]
#!/usr/bin/env python3
#
#--------------------------------------------------------
# Padframe Editor and Core Floorplanner
#
#--------------------------------------------------------
# Written by Tim Edwards
# efabless, inc.
# April 24, 2019
# Version 0.5
# Based on https://github.com/YosysHQ/padring (requirement)
# Update: May 9, 2019 to add console message window
# Update: May 10, 2019 to incorporate core floorplanning
# Update: Jan 31, 2020 to allow batch operation
#--------------------------------------------------------
import os
import re
import sys
import glob
import json
import math
import shutil
import signal
import select
import subprocess
import faulthandler
import tkinter
from tkinter import ttk
from tkinter import filedialog
import tksimpledialog
from consoletext import ConsoleText
# User preferences file (if it exists)
prefsfile = '~/design/.profile/prefs.json'
#------------------------------------------------------
# Dialog for entering a pad
#------------------------------------------------------
class PadNameDialog(tksimpledialog.Dialog):
def body(self, master, warning=None, seed=None):
if warning:
ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
ttk.Label(master, text="Enter new group name:").grid(row = 1, column = 0, sticky = 'wns')
self.nentry = ttk.Entry(master)
self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
if seed:
self.nentry.insert(0, seed)
return self.nentry # initial focus
def apply(self):
return self.nentry.get()
#------------------------------------------------------
# Dialog for entering core dimensions
#------------------------------------------------------
class CoreSizeDialog(tksimpledialog.Dialog):
def body(self, master, warning="Chip core dimensions", seed=None):
if warning:
ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
ttk.Label(master, text="Enter core width x height (microns):").grid(row = 1, column = 0, sticky = 'wns')
self.nentry = ttk.Entry(master)
self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
if seed:
self.nentry.insert(0, seed)
return self.nentry # initial focus
def apply(self):
return self.nentry.get()
#------------------------------------------------
# SoC Floorplanner and Padframe Generator GUI
#------------------------------------------------
class SoCFloorplanner(ttk.Frame):
"""Open Galaxy Pad Frame Generator."""
def __init__(self, parent = None, *args, **kwargs):
'''See the __init__ for Tkinter.Toplevel.'''
ttk.Frame.__init__(self, parent, *args[1:], **kwargs)
self.root = parent
self.init_data()
if args[0] == True:
self.do_gui = True
self.init_gui()
else:
self.do_gui = False
self.use_console = False
def on_quit(self):
"""Exits program."""
quit()
def init_gui(self):
"""Builds GUI."""
global prefsfile
message = []
fontsize = 11
# Read user preferences file, get default font size from it.
prefspath = os.path.expanduser(prefsfile)
if os.path.exists(prefspath):
with open(prefspath, 'r') as f:
self.prefs = json.load(f)
if 'fontsize' in self.prefs:
fontsize = self.prefs['fontsize']
else:
self.prefs = {}
s = ttk.Style()
available_themes = s.theme_names()
s.theme_use(available_themes[0])
s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'),
foreground = 'brown', anchor = 'center')
s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue')
s.configure('normal.TLabel', font=('Helvetica', fontsize))
s.configure('normal.TCheckbutton', font=('Helvetica', fontsize))
s.configure('normal.TMenubutton', font=('Helvetica', fontsize))
s.configure('normal.TEntry', font=('Helvetica', fontsize), background='white')
s.configure('pad.TLabel', font=('Helvetica', fontsize), foreground = 'blue', relief = 'flat')
s.configure('select.TLabel', font=('Helvetica', fontsize, 'bold'), foreground = 'white',
background = 'blue', relief = 'flat')
# parent.withdraw()
self.root.title('Padframe Generator and Core Floorplanner')
self.root.option_add('*tearOff', 'FALSE')
self.pack(side = 'top', fill = 'both', expand = 'true')
self.root.protocol("WM_DELETE_WINDOW", self.on_quit)
pane = tkinter.PanedWindow(self, orient = 'vertical', sashrelief = 'groove',
sashwidth = 6)
pane.pack(side = 'top', fill = 'both', expand = 'true')
self.toppane = ttk.Frame(pane)
self.botpane = ttk.Frame(pane)
self.toppane.columnconfigure(0, weight = 1)
self.toppane.rowconfigure(0, weight = 1)
self.botpane.columnconfigure(0, weight = 1)
self.botpane.rowconfigure(0, weight = 1)
# Scrolled frame using canvas widget
self.pframe = tkinter.Frame(self.toppane)
self.pframe.grid(row = 0, column = 0, sticky = 'news')
self.pframe.rowconfigure(0, weight = 1)
self.pframe.columnconfigure(0, weight = 1)
# Add column on the left, listing all groups and the pads they belong to.
# This starts as just a frame to be filled. Use a canvas to create a
# scrolled frame.
# The primary frame holds the canvas
self.canvas = tkinter.Canvas(self.pframe, background = "white")
self.canvas.grid(row = 0, column = 0, sticky = 'news')
# Add Y scrollbar to pad list window
xscrollbar = ttk.Scrollbar(self.pframe, orient = 'horizontal')
xscrollbar.grid(row = 1, column = 0, sticky = 'news')
yscrollbar = ttk.Scrollbar(self.pframe, orient = 'vertical')
yscrollbar.grid(row = 0, column = 1, sticky = 'news')
self.canvas.config(xscrollcommand = xscrollbar.set)
xscrollbar.config(command = self.canvas.xview)
self.canvas.config(yscrollcommand = yscrollbar.set)
yscrollbar.config(command = self.canvas.yview)
self.canvas.bind("<Button-4>", self.on_scrollwheel)
self.canvas.bind("<Button-5>", self.on_scrollwheel)
# Configure callback
self.canvas.bind("<Configure>", self.frame_configure)
# Add a text window to capture output. Redirect print statements to it.
self.console = ttk.Frame(self.botpane)
self.console.grid(column = 0, row = 0, sticky = "news")
self.text_box = ConsoleText(self.console, wrap='word', height = 4)
self.text_box.pack(side='left', fill='both', expand='true')
console_scrollbar = ttk.Scrollbar(self.console)
console_scrollbar.pack(side='right', fill='y')
# Attach console to scrollbar
self.text_box.config(yscrollcommand = console_scrollbar.set)
console_scrollbar.config(command = self.text_box.yview)
# Add the bottom bar with buttons
self.bbar = ttk.Frame(self.botpane)
self.bbar.grid(column = 0, row = 1, sticky = "news")
self.bbar.import_button = ttk.Button(self.bbar, text='Import',
command=self.vlogimport, style='normal.TButton')
self.bbar.import_button.grid(column=0, row=0, padx = 5)
self.bbar.generate_button = ttk.Button(self.bbar, text='Generate',
command=self.generate, style='normal.TButton')
self.bbar.generate_button.grid(column=1, row=0, padx = 5)
self.bbar.save_button = ttk.Button(self.bbar, text='Save',
command=self.save, style='normal.TButton')
self.bbar.save_button.grid(column=2, row=0, padx = 5)
self.bbar.cancel_button = ttk.Button(self.bbar, text='Quit',
command=self.on_quit, style='normal.TButton')
self.bbar.cancel_button.grid(column=3, row=0, padx = 5)
pane.add(self.toppane)
pane.add(self.botpane)
pane.paneconfig(self.toppane, stretch='first')
def init_data(self):
self.vlogpads = []
self.corecells = []
self.Npads = []
self.Spads = []
self.Epads = []
self.Wpads = []
self.NEpad = []
self.NWpad = []
self.SEpad = []
self.SWpad = []
self.coregroup = []
self.celldefs = []
self.coredefs = []
self.selected = []
self.ioleflibs = []
self.llx = 0
self.lly = 0
self.urx = 0
self.ury = 0
self.event_data = {}
self.event_data['x0'] = 0
self.event_data['y0'] = 0
self.event_data['x'] = 0
self.event_data['y'] = 0
self.event_data['tag'] = None
self.scale = 1.0
self.margin = 10
self.pad_rotation = 0
self.init_messages = []
self.stdout = None
self.stderr = None
self.keep_cfg = False
self.ef_format = False
self.use_console = False
def init_padframe(self):
self.set_project()
self.vlogimport()
self.readplacement(precheck=True)
self.resolve()
self.generate()
# Local routines for handling printing to the text console
def print(self, message, file=None, end='\n', flush=True):
if not file:
if not self.use_console:
file = sys.stdout
else:
file = ConsoleText.StdoutRedirector(self.text_box)
if self.stdout:
print(message, file=file, end=end)
if flush:
self.stdout.flush()
self.update_idletasks()
else:
self.init_messages.append(message)
def text_to_console(self):
# Redirect stdout and stderr to the console as the last thing to do. . .
# Otherwise errors in the GUI get sucked into the void.
self.stdout = sys.stdout
self.stderr = sys.stderr
if self.use_console:
sys.stdout = ConsoleText.StdoutRedirector(self.text_box)
sys.stderr = ConsoleText.StderrRedirector(self.text_box)
if len(self.init_messages) > 0:
for message in self.init_messages:
self.print(message)
self.init_messages = []
# Set the project name(s). This is the name of the top-level verilog.
# The standard protocol is that the project directory contains a file
# project.json that defines a name 'ip-name' that is the same as the
# layout name, the verilog module name, etc.
def set_project(self):
# Check pwd
pwdname = self.projectpath if self.projectpath else os.getcwd()
subdir = os.path.split(pwdname)[1]
if subdir == 'mag' or subdir == 'verilog':
projectpath = os.path.split(pwdname)[0]
else:
projectpath = pwdname
# Also check for project below the current working directory
if not os.path.exists(projectpath + '/mag'):
print('No project path, checking subdirectories')
dlist = os.listdir(projectpath)
for dir in dlist:
print('Checking ' + projectpath + '/' + dir)
if os.path.exists(projectpath + '/' + dir + '/mag'):
projectpath = projectpath + '/' + dir
print('Found!')
break
projectroot = os.path.split(projectpath)[0]
projectdirname = os.path.split(projectpath)[1]
# Check for efabless format. This is probably more complicated than
# it deserves to be. Option -ef_format is the best way to specify
# efabless format. However, if it is not specified, then check the
# technology PDK directory and the project directory for the tell-tale
# ".ef-config" (efabless format) directory vs. ".config" (not efabless
# format).
if not self.ef_format:
if os.path.exists(projectpath + '/.ef-config'):
self.ef_format = True
elif self.techpath:
if os.path.exists(self.techpath + '/.ef-config'):
self.ef_format = True
else:
# Do a quick consistency check. Honor the -ef_format option but warn if
# there is an apparent inconsistency.
if os.path.exists(projectpath + '/.config'):
self.print('Warning: -ef_format used in apparently non-efabless setup.')
elif self.techpath:
if os.path.exists(self.techpath + '/.config'):
self.print('Warning: -ef_format used in apparently non-efabless setup.')
# Check for project.json
jsonname = None
if os.path.isfile(projectpath + '/project.json'):
jsonname = projectpath + '/project.json'
elif os.path.isfile(projectroot + '/' + projectdirname + '.json'):
jsonname = projectroot + '/' + projectdirname + '.json'
if os.path.isfile(projectroot + '/project.json'):
# Just in case this was started from some other subdirectory
projectpath = projectroot
jsonname = projectroot + '/project.json'
if jsonname:
self.print('Reading project JSON file ' + jsonname)
with open(jsonname, 'r') as ifile:
topdata = json.load(ifile)
if 'data-sheet' in topdata:
dsheet = topdata['data-sheet']
if 'ip-name' in dsheet:
self.project = dsheet['ip-name']
self.projectpath = projectpath
else:
self.print('No project JSON file; using directory name as the project name.')
self.project = os.path.split(projectpath)[1]
self.projectpath = projectpath
self.print('Project name is ' + self.project + ' (' + self.projectpath + ')')
# Functions for drag-and-drop capability
def add_draggable(self, tag):
self.canvas.tag_bind(tag, '<ButtonPress-1>', self.on_button_press)
self.canvas.tag_bind(tag, '<ButtonRelease-1>', self.on_button_release)
self.canvas.tag_bind(tag, '<B1-Motion>', self.on_button_motion)
self.canvas.tag_bind(tag, '<ButtonPress-2>', self.on_button2_press)
self.canvas.tag_bind(tag, '<ButtonPress-3>', self.on_button3_press)
def on_button_press(self, event):
'''Begining drag of an object'''
# Find the closest item, then record its tag.
locx = event.x + self.canvas.canvasx(0)
locy = event.y + self.canvas.canvasy(0)
item = self.canvas.find_closest(locx, locy)[0]
self.event_data['tag'] = self.canvas.gettags(item)[0]
self.event_data['x0'] = event.x
self.event_data['y0'] = event.y
self.event_data['x'] = event.x
self.event_data['y'] = event.y
def on_button2_press(self, event):
'''Flip an object (excluding corners)'''
locx = event.x + self.canvas.canvasx(0)
locy = event.y + self.canvas.canvasy(0)
item = self.canvas.find_closest(locx, locy)[0]
tag = self.canvas.gettags(item)[0]
try:
corecell = next(item for item in self.coregroup if item['name'] == tag)
except:
try:
pad = next(item for item in self.Npads if item['name'] == tag)
except:
pad = None
if not pad:
try:
pad = next(item for item in self.Epads if item['name'] == tag)
except:
pad = None
if not pad:
try:
pad = next(item for item in self.Spads if item['name'] == tag)
except:
pad = None
if not pad:
try:
pad = next(item for item in self.Wpads if item['name'] == tag)
except:
pad = None
if not pad:
self.print('Error: Object cannot be flipped.')
else:
# Flip the pad (in the only way meaningful for the pad).
orient = pad['o']
if orient == 'N':
pad['o'] = 'FN'
elif orient == 'E':
pad['o'] = 'FW'
elif orient == 'S':
pad['o'] = 'FS'
elif orient == 'W':
pad['o'] = 'FE'
elif orient == 'FN':
pad['o'] = 'N'
elif orient == 'FE':
pad['o'] = 'W'
elif orient == 'FS':
pad['o'] = 'S'
elif orient == 'FW':
pad['o'] = 'E'
else:
# Flip the cell. Use the DEF meaning of flip, which is to
# add or subtract 'F' from the orientation.
orient = corecell['o']
if not 'F' in orient:
corecell['o'] = 'F' + orient
else:
corecell['o'] = orient[1:]
# Redraw
self.populate(0)
def on_button3_press(self, event):
'''Rotate a core object (no pads) '''
locx = event.x + self.canvas.canvasx(0)
locy = event.y + self.canvas.canvasy(0)
item = self.canvas.find_closest(locx, locy)[0]
tag = self.canvas.gettags(item)[0]
try:
corecell = next(item for item in self.coregroup if item['name'] == tag)
except:
self.print('Error: Object cannot be rotated.')
else:
# Modify its orientation
orient = corecell['o']
if orient == 'N':
corecell['o'] = 'E'
elif orient == 'E':
corecell['o'] = 'S'
elif orient == 'S':
corecell['o'] = 'W'
elif orient == 'W':
corecell['o'] = 'N'
elif orient == 'FN':
corecell['o'] = 'FW'
elif orient == 'FW':
corecell['o'] = 'FS'
elif orient == 'FS':
corecell['o'] = 'FE'
elif orient == 'FE':
corecell['o'] = 'FN'
# rewrite the core DEF file
self.write_core_def()
# Redraw
self.populate(0)
def on_button_motion(self, event):
'''Handle dragging of an object'''
# compute how much the mouse has moved
delta_x = event.x - self.event_data['x']
delta_y = event.y - self.event_data['y']
# move the object the appropriate amount
self.canvas.move(self.event_data['tag'], delta_x, delta_y)
# record the new position
self.event_data['x'] = event.x
self.event_data['y'] = event.y
def on_button_release(self, event):
'''End drag of an object'''
# Find the pad associated with the tag and update its position information
tag = self.event_data['tag']
# Collect pads in clockwise order. Note that E and S rows are not clockwise
allpads = []
allpads.extend(self.Npads)
allpads.extend(self.NEpad)
allpads.extend(reversed(self.Epads))
allpads.extend(self.SEpad)
allpads.extend(reversed(self.Spads))
allpads.extend(self.SWpad)
allpads.extend(self.Wpads)
allpads.extend(self.NWpad)
# Create a list of row references (also in clockwise order, but no reversing)
padrows = [self.Npads, self.NEpad, self.Epads, self.SEpad, self.Spads, self.SWpad, self.Wpads, self.NWpad]
# Record the row or corner where this pad was located before the move
for row in padrows:
try:
pad = next(item for item in row if item['name'] == tag)
except:
pass
else:
padrow = row
break
# Currently there is no procedure to move a pad out of the corner
# position; corners are fixed by definition.
if padrow == self.NEpad or padrow == self.SEpad or padrow == self.SWpad or padrow == self.NWpad:
# Easier to run generate() than to put the pad back. . .
self.generate()
return
# Find the original center point of the pad being moved
padllx = pad['x']
padlly = pad['y']
if pad['o'] == 'N' or pad['o'] == 'S':
padurx = padllx + pad['width']
padury = padlly + pad['height']
else:
padurx = padllx + pad['height']
padury = padlly + pad['width']
padcx = (padllx + padurx) / 2
padcy = (padlly + padury) / 2
# Add distance from drag information (note that drag position in y
# is negative relative to the chip dimensions)
padcx += (self.event_data['x'] - self.event_data['x0']) / self.scale
padcy -= (self.event_data['y'] - self.event_data['y0']) / self.scale
# reset the drag information
self.event_data['tag'] = None
self.event_data['x'] = 0
self.event_data['y'] = 0
self.event_data['x0'] = 0
self.event_data['y0'] = 0
# Find the distance from the pad to all other pads, and get the two
# closest entries.
wwidth = self.urx - self.llx
dist0 = wwidth
dist1 = wwidth
pad0 = None
pad1 = None
for npad in allpads:
if npad == pad:
continue
npadllx = npad['x']
npadlly = npad['y']
if npad['o'] == 'N' or npad['o'] == 'S':
npadurx = npadllx + npad['width']
npadury = npadlly + npad['height']
else:
npadurx = npadllx + npad['height']
npadury = npadlly + npad['width']
npadcx = (npadllx + npadurx) / 2
npadcy = (npadlly + npadury) / 2
deltx = npadcx - padcx
delty = npadcy - padcy
pdist = math.sqrt(deltx * deltx + delty * delty)
if pdist < dist0:
dist1 = dist0
pad1 = pad0
dist0 = pdist
pad0 = npad
elif pdist < dist1:
dist1 = pdist
pad1 = npad
# Diagnostic
# self.print('Two closest pads to pad ' + pad['name'] + ' (' + pad['cell'] + '): ')
# self.print(pad0['name'] + ' (' + pad0['cell'] + ') dist = ' + str(dist0))
# self.print(pad1['name'] + ' (' + pad1['cell'] + ') dist = ' + str(dist1))
# Record the row or corner where these pads are
for row in padrows:
try:
testpad = next(item for item in row if item['name'] == pad0['name'])
except:
pass
else:
padrow0 = row
break
for row in padrows:
try:
testpad = next(item for item in row if item['name'] == pad1['name'])
except:
pass
else:
padrow1 = row
break
# Remove pad from its own row
padrow.remove(pad)
# Insert pad into new row. Watch for wraparound from the last entry to the first
padidx0 = allpads.index(pad0)
padidx1 = allpads.index(pad1)
if padidx0 == 0 and padidx1 > 2:
padidx1 = -1
if padidx1 > padidx0:
padafter = pad1
rowafter = padrow1
padbefore = pad0
rowbefore = padrow0
else:
padafter = pad0
rowafter = padrow0
padbefore = pad1
rowbefore = padrow1
# Do not replace corner positions (? may be necessary ?)
if rowafter == self.NWpad:
self.Wpads.append(pad)
elif rowafter == self.NWpad:
self.Npads.append(pad)
elif rowafter == self.SEpad:
self.Epads.insert(0, pad)
elif rowafter == self.SWpad:
self.Spads.insert(0, pad)
elif rowafter == self.Wpads or rowafter == self.Npads:
idx = rowafter.index(padafter)
rowafter.insert(idx, pad)
elif rowbefore == self.NEpad:
self.Epads.append(pad)
elif rowbefore == self.SEpad:
self.Spads.append(pad)
else:
# rows E and S are ordered counterclockwise
idx = rowbefore.index(padbefore)
rowbefore.insert(idx, pad)
# Re-run padring
self.generate()
def on_scrollwheel(self, event):
if event.num == 4:
zoomval = 1.1;
elif event.num == 5:
zoomval = 0.9;
else:
zoomval = 1.0;
self.scale *= zoomval
self.canvas.scale('all', -15 * zoomval, -15 * zoomval, zoomval, zoomval)
self.event_data['x'] *= zoomval
self.event_data['y'] *= zoomval
self.event_data['x0'] *= zoomval
self.event_data['y0'] *= zoomval
self.frame_configure(event)
# Callback functions similar to the pad event callbacks above, but for
# core cells. Unlike pad cells, core cells can be rotated and flipped
# arbitrarily, and they do not force a recomputation of the padframe
# unless their position forces the padframe to expand
def add_core_draggable(self, tag):
self.canvas.tag_bind(tag, '<ButtonPress-1>', self.on_button_press)
self.canvas.tag_bind(tag, '<ButtonRelease-1>', self.core_on_button_release)
self.canvas.tag_bind(tag, '<B1-Motion>', self.on_button_motion)
self.canvas.tag_bind(tag, '<ButtonPress-2>', self.on_button2_press)
self.canvas.tag_bind(tag, '<ButtonPress-3>', self.on_button3_press)
def core_on_button_release(self, event):
'''End drag of a core cell'''
# Find the pad associated with the tag and update its position information
tag = self.event_data['tag']
try:
corecell = next(item for item in self.coregroup if item['name'] == tag)
except:
self.print('Error: cell ' + item['name'] + ' is not in coregroup!')
else:
# Modify its position values
corex = corecell['x']
corey = corecell['y']
# Add distance from drag information (note that drag position in y
# is negative relative to the chip dimensions)
deltax = (self.event_data['x'] - self.event_data['x0']) / self.scale
deltay = (self.event_data['y'] - self.event_data['y0']) / self.scale
corecell['x'] = corex + deltax
corecell['y'] = corey - deltay
# rewrite the core DEF file
self.write_core_def()
# reset the drag information
self.event_data['tag'] = None
self.event_data['x'] = 0
self.event_data['y'] = 0
self.event_data['x0'] = 0
self.event_data['y0'] = 0
# Critically needed or else frame does not resize to scrollbars!
def grid_configure(self, padx, pady):
pass
# Redraw the chip frame view in response to changes in the pad list
def redraw_frame(self):
self.canvas.coords('boundary', self.llx, self.urx, self.lly, self.ury)
# Update the canvas scrollregion to incorporate all the interior windows
def frame_configure(self, event):
if self.do_gui == False:
return
self.update_idletasks()
bbox = self.canvas.bbox("all")
try:
newbbox = (-15, -15, bbox[2] + 15, bbox[3] + 15)
except:
pass
else:
self.canvas.configure(scrollregion = newbbox)
# Fill the GUI entries with resident data
def populate(self, level):
if self.do_gui == False:
return
if level > 1:
self.print('Recursion error: Returning now.')
return
self.print('Populating floorplan view.')
# Remove all entries from the canvas
self.canvas.delete('all')
allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad
notfoundlist = []
for pad in allpads:
if 'x' not in pad:
self.print('Error: Pad ' + pad['name'] + ' has no placement information.')
continue
llx = int(pad['x'])
lly = int(pad['y'])
pado = pad['o']
try:
padcell = next(item for item in self.celldefs if item['name'] == pad['cell'])
except:
# This should not happen (failsafe)
if pad['cell'] not in notfoundlist:
self.print('Warning: there is no cell named ' + pad['cell'] + ' in the libraries.')
notfoundlist.append(pad['cell'])
continue
padw = padcell['width']
padh = padcell['height']
if 'N' in pado or 'S' in pado:
urx = int(llx + padw)
ury = int(lly + padh)
else:
urx = int(llx + padh)
ury = int(lly + padw)
pad['llx'] = llx
pad['lly'] = lly
pad['urx'] = urx
pad['ury'] = ury
# Note that the DEF coordinate system is reversed in Y from the canvas. . .
height = self.ury - self.lly
for pad in allpads:
llx = pad['llx']
lly = height - pad['lly']
urx = pad['urx']
ury = height - pad['ury']
tag_id = pad['name']
if 'subclass' in pad:
if pad['subclass'] == 'POWER':
pad_color = 'orange2'
elif pad['subclass'] == 'INOUT':
pad_color = 'yellow'
elif pad['subclass'] == 'OUTPUT':
pad_color = 'powder blue'
elif pad['subclass'] == 'INPUT':
pad_color = 'goldenrod1'
elif pad['subclass'] == 'SPACER':
pad_color = 'green yellow'
elif pad['class'] == 'ENDCAP':
pad_color = 'green yellow'
elif pad['subclass'] == '' or pad['class'] == ';':
pad_color = 'khaki1'
else:
self.print('Unhandled pad class ' + pad['class'])
pad_color = 'gray'
else:
pad_color = 'gray'
sllx = self.scale * llx
slly = self.scale * lly
surx = self.scale * urx
sury = self.scale * ury
self.canvas.create_rectangle((sllx, slly), (surx, sury), fill=pad_color, tags=[tag_id])
cx = (sllx + surx) / 2
cy = (slly + sury) / 2
s = 10 if pad['width'] >= 10 else pad['width']
if pad['height'] < s:
s = pad['height']
# Create an indicator line at the bottom left corner of the cell
if pad['o'] == 'N':
allx = sllx
ally = slly - s
aurx = sllx + s
aury = slly
elif pad['o'] == 'E':
allx = sllx
ally = sury + s
aurx = sllx + s
aury = sury
elif pad['o'] == 'S':
allx = surx
ally = sury + s
aurx = surx - s
aury = sury
elif pad['o'] == 'W':
allx = surx
ally = slly - s
aurx = surx - s
aury = slly
elif pad['o'] == 'FN':
allx = surx
ally = slly - s
aurx = surx - s
aury = slly
elif pad['o'] == 'FE':
allx = surx
ally = sury + s
aurx = surx - s
aury = sury
elif pad['o'] == 'FS':
allx = sllx
ally = sury + s
aurx = sllx + s
aury = sury
elif pad['o'] == 'FW':
allx = sllx
ally = slly - s
aurx = sllx + s
aury = slly
self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id])
# Rotate text on top and bottom rows if the tkinter version allows it.
if tkinter.TclVersion >= 8.6:
if pad['o'] == 'N' or pad['o'] == 'S':
angle = 90
else:
angle = 0
self.canvas.create_text((cx, cy), text=pad['name'], angle=angle, tags=[tag_id])
else:
self.canvas.create_text((cx, cy), text=pad['name'], tags=[tag_id])
# Make the pad draggable
self.add_draggable(tag_id)
# Now add the core cells
for cell in self.coregroup:
if 'x' not in cell:
self.print('Error: Core cell ' + cell['name'] + ' has no placement information.')
continue
# else:
# self.print('Diagnostic: Creating object for core cell ' + cell['name'])
llx = int(cell['x'])
lly = int(cell['y'])
cello = cell['o']
try:
corecell = next(item for item in self.coredefs if item['name'] == cell['cell'])
except:
# This should not happen (failsafe)
if cell['cell'] not in notfoundlist:
self.print('Warning: there is no cell named ' + cell['cell'] + ' in the libraries.')
notfoundlist.append(cell['cell'])
continue
cellw = corecell['width']
cellh = corecell['height']
if 'N' in cello or 'S' in cello:
urx = int(llx + cellw)
ury = int(lly + cellh)
else:
urx = int(llx + cellh)
ury = int(lly + cellw)
print('NOTE: cell ' + corecell['name'] + ' is rotated, w = ' + str(urx - llx) + '; h = ' + str(ury - lly))
cell['llx'] = llx
cell['lly'] = lly
cell['urx'] = urx
cell['ury'] = ury
# Watch for out-of-window position in core cells.
corellx = self.llx
corelly = self.lly
coreurx = self.urx
coreury = self.ury
for cell in self.coregroup:
if 'llx' not in cell:
# Error message for this was handled above
continue
llx = cell['llx']
lly = height - cell['lly']
urx = cell['urx']
ury = height - cell['ury']
# Check for out-of-window cell
if llx < corellx:
corellx = llx
if lly < corelly:
corelly = lly
if urx > coreurx:
coreurx = urx
if ury > coreury:
coreury = ury
tag_id = cell['name']
cell_color = 'gray40'
sllx = self.scale * llx
slly = self.scale * lly
surx = self.scale * urx
sury = self.scale * ury
self.canvas.create_rectangle((sllx, slly), (surx, sury), fill=cell_color, tags=[tag_id])
cx = (sllx + surx) / 2
cy = (slly + sury) / 2
s = 10 if cell['width'] >= 10 else cell['width']
if cell['height'] < s:
s = cell['height']
# Create an indicator line at the bottom left corner of the cell
if cell['o'] == 'N':
allx = sllx
ally = slly - s
aurx = sllx + s
aury = slly
elif cell['o'] == 'E':
allx = sllx
ally = sury + s
aurx = sllx + s
aury = sury
elif cell['o'] == 'S':
allx = surx
ally = sury + s
aurx = surx - s
aury = sury
elif cell['o'] == 'W':
allx = surx
ally = slly - s
aurx = surx - s
aury = slly
elif cell['o'] == 'FN':
allx = surx
ally = slly - s
aurx = surx - s
aury = slly
elif cell['o'] == 'FE':
allx = surx
ally = sury + s
aurx = surx - s
aury = sury
elif cell['o'] == 'FS':
allx = sllx
ally = sury + s
aurx = sllx + s
aury = sury
elif cell['o'] == 'FW':
allx = sllx
ally = slly - s
aurx = sllx + s
aury = slly
self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id])
# self.print('Created entry for cell ' + cell['name'] + ' at {0:g}, {1:g}'.format(cx, cy))
# Rotate text on top and bottom rows if the tkinter version allows it.
if tkinter.TclVersion >= 8.6:
if 'N' in cell['o'] or 'S' in cell['o']:
angle = 90
else:
angle = 0
self.canvas.create_text((cx, cy), text=cell['name'], angle=angle, tags=[tag_id])
else:
self.canvas.create_text((cx, cy), text=cell['name'], tags=[tag_id])
# Make the core cell draggable
self.add_core_draggable(tag_id)
# Is there a boundary size defined?
if self.urx > self.llx and self.ury > self.lly:
self.create_boundary()
# Did the core extend into negative X or Y? If so, adjust all canvas
# coordinates to fit in the window, or else objects cannot be reached
# even by zooming out (since zooming is pinned on the top corner).
offsetx = 0
offsety = 0
# NOTE: Probably want to check if the core exceeds the inner
# dimension of the pad ring, not the outer (to check and to do).
if corellx < self.llx:
offsetx = self.llx - corellx
if corelly < self.lly:
offsety = self.lly - corelly
if offsetx > 0 or offsety > 0:
self.canvas.move("all", offsetx, offsety)
# An offset implies that the chip is core limited, and the
# padframe requires additional space. This can be accomplished
# simply by running "Generate". NOTE: Since generate() calls
# populate(), be VERY SURE that this does not infinitely recurse!
self.generate(level)
# Generate a DEF file of the core area
def write_core_def(self):
self.print('Writing core placementment information in DEF file "core.def".')
mag_path = self.projectpath + '/mag'
# The core cells must always clear the I/O pads on the left and
# bottom (with the ad-hoc margin of self.margin). If core cells have
# been moved to the left or down past the padframe edge, then the
# entire core needs to be repositioned.
# To be done: draw a boundary around the core, let the edges of that
# boundary be draggable, and let the difference between the boundary
# and the core area define the margin.
if self.SWpad != []:
corellx = self.SWpad[0]['x'] + self.SWpad[0]['width'] + self.margin
corelly = self.SWpad[0]['y'] + self.SWpad[0]['height'] + self.margin
else:
corellx = self.Wpads[0]['x'] + self.Wpads[0]['height'] + self.margin
corelly = self.Spads[0]['x'] + self.Spads[0]['height'] + self.margin
offsetx = 0
offsety = 0
for corecell in self.coregroup:
if corecell['x'] < corellx:
if corellx - corecell['x'] > offsetx:
offsetx = corellx - corecell['x']
if corecell['y'] < corelly:
if corelly - corecell['y'] > offsety:
offsety = corelly - corecell['y']
if offsetx > 0 or offsety > 0:
for corecell in self.coregroup:
corecell['x'] += offsetx
corecell['y'] += offsety
# Now write the core DEF file
with open(mag_path + '/core.def', 'w') as ofile:
print('DESIGN CORE ;', file=ofile)
print('UNITS DISTANCE MICRONS 1000 ;', file=ofile)
print('COMPONENTS {0:d} ;'.format(len(self.coregroup)), file=ofile)
for corecell in self.coregroup:
print(' - ' + corecell['name'] + ' ' + corecell['cell'], file=ofile)
print(' + PLACED ( {0:d} {1:d} ) {2:s} ;'.format(int(corecell['x'] * 1000), int(corecell['y'] * 1000), corecell['o']), file=ofile)
print ('END COMPONENTS', file=ofile)
print ('END DESIGN', file=ofile)
# Create the chip boundary area
def create_boundary(self):
scale = self.scale
llx = (self.llx - 10) * scale
lly = (self.lly - 10) * scale
urx = (self.urx + 10) * scale
ury = (self.ury + 10) * scale
pad_color = 'plum1'
tag_id = 'boundary'
self.canvas.create_rectangle((llx, lly), (urx, ury), outline=pad_color, width=2, tags=[tag_id])
# Add text to the middle representing the chip and core areas
cx = ((self.llx + self.urx) / 2) * scale
cy = ((self.lly + self.ury) / 2) * scale
width = self.urx - self.llx
height = self.ury - self.lly
areatext = 'Chip dimensions (um): {0:g} x {1:g}'.format(width, height)
tag_id = 'chiparea'
self.canvas.create_text((cx, cy), text=areatext, tags=[tag_id])
# Rotate orientation according to self.pad_rotation.
def rotate_orientation(self, orient_in):
orient_v = ['N', 'E', 'S', 'W', 'N', 'E', 'S', 'W']
idxadd = int(self.pad_rotation / 90)
idx = orient_v.index(orient_in)
return orient_v[idx + idxadd]
# Read a list of cell macros (name, size, class) from a LEF library
def read_lef_macros(self, libpath, libname = None, libtype = 'iolib'):
if libtype == 'iolib':
libtext = 'I/O '
elif libtype == 'celllib':
libtext = 'core '
else:
libtext = ''
macros = []
if libname:
if os.path.splitext(libname)[1] == '':
libname += '.lef'
leffiles = glob.glob(libpath + '/' + libname)
else:
leffiles = glob.glob(libpath + '/*.lef')
if leffiles == []:
if libname:
self.print('WARNING: No file ' + libpath + '/' + libname + '.lef')
else:
self.print('WARNING: No files ' + libpath + '/*.lef')
for leffile in leffiles:
libpath = os.path.split(leffile)[0]
libname = os.path.split(libpath)[1]
self.print('Reading LEF ' + libtext + 'library ' + leffile)
with open(leffile, 'r') as ifile:
ilines = ifile.read().splitlines()
in_macro = False
for iline in ilines:
iparse = iline.split()
if iparse == []:
continue
elif iparse[0] == 'MACRO':
in_macro = True
newmacro = {}
newmacro['name'] = iparse[1]
newmacro[libtype] = leffile
macros.append(newmacro)
elif in_macro:
if iparse[0] == 'END':
if len(iparse) > 1 and iparse[1] == newmacro['name']:
in_macro = False
elif iparse[0] == 'CLASS':
newmacro['class'] = iparse[1]
if len(iparse) > 2:
newmacro['subclass'] = iparse[2]
# Use the 'ENDCAP' class to identify pad rotations
# other than BOTTOMLEFT. This is somewhat ad-hoc
# depending on the foundry; may not be generally
# applicable.
if newmacro['class'] == 'ENDCAP':
if newmacro['subclass'] == 'TOPLEFT':
self.pad_rotation = 90
elif newmacro['subclass'] == 'TOPRIGHT':
self.pad_rotation = 180
elif newmacro['subclass'] == 'BOTTOMRIGHT':
self.pad_rotation = 270
else:
newmacro['subclass'] = None
elif iparse[0] == 'SIZE':
newmacro['width'] = float(iparse[1])
newmacro['height'] = float(iparse[3])
elif iparse[0] == 'ORIGIN':
newmacro['x'] = float(iparse[1])
newmacro['y'] = float(iparse[2])
return macros
# Read a list of cell names from a verilog file
# If filename is relative, then check in the same directory as the verilog
# top-level netlist (vlogpath) and in the subdirectory 'source/' of the top-
# level directory. Also check in the ~/design/ip/ directory. These are
# common include paths for the simulation.
def read_verilog_lib(self, incpath, vlogpath):
iocells = []
if not os.path.isfile(incpath) and incpath[0] != '/':
locincpath = vlogpath + '/' + incpath
if not os.path.isfile(locincpath):
locincpath = vlogpath + '/source/' + incpath
if not os.path.isfile(locincpath):
projectpath = os.path.split(vlogpath)[0]
designpath = os.path.split(projectpath)[0]
locincpath = designpath + '/ip/' + incpath
else:
locincpath = incpath
if not os.path.isfile(locincpath):
self.print('File ' + incpath + ' not found (at ' + locincpath + ')!')
else:
self.print('Reading verilog library ' + locincpath)
with open(locincpath, 'r') as ifile:
ilines = ifile.read().splitlines()
for iline in ilines:
iparse = re.split('[\t ()]', iline)
while '' in iparse:
iparse.remove('')
if iparse == []:
continue
elif iparse[0] == 'module':
iocells.append(iparse[1])
return iocells
# Generate a LEF abstract view from a magic layout. If "outpath" is not
# "None", then write output to outputpath (this is required if the input
# file is in a read-only directory).
def write_lef_file(self, magfile, outpath=None):
mag_path = os.path.split(magfile)[0]
magfullname = os.path.split(magfile)[1]
module = os.path.splitext(magfullname)[0]
if outpath:
write_path = outpath
else:
write_path = mag_path
self.print('Generating LEF view from layout for module ' + module)
with open(write_path + '/pfg_write_lef.tcl', 'w') as ofile:
print('drc off', file=ofile)
print('box 0 0 0 0', file=ofile)
# NOTE: Using "-force" option in case an IP with a different but
# compatible tech is used (e.g., EFHX035A IP inside EFXH035C). This
# is not checked for legality!
if outpath:
print('load ' + magfile + ' -force', file=ofile)
else:
print('load ' + module + ' -force', file=ofile)
print('select top cell', file=ofile)
print('lef write -hide', file=ofile)
print('quit', file=ofile)
magicexec = self.magic_path if self.magic_path else 'magic'
mproc = subprocess.Popen([magicexec, '-dnull', '-noconsole',
'pfg_write_lef.tcl'],
stdin = subprocess.PIPE, stdout = subprocess.PIPE,
stderr = subprocess.PIPE, cwd = write_path, universal_newlines = True)
self.watch(mproc)
os.remove(write_path + '/pfg_write_lef.tcl')
# Watch a running process, polling for output and updating the GUI message
# window as output arrives. Return only when the process has exited.
# Note that this process cannot handle stdin(), so any input to the process
# must be passed from a file.
def watch(self, process):
if process == None:
return
while True:
status = process.poll()
if status != None:
try:
outputpair = process.communicate(timeout=1)
except ValueError:
self.print("Process forced stop, status " + str(status))
else:
for line in outputpair[0].splitlines():
self.print(line)
for line in outputpair[1].splitlines():
self.print(line, file=sys.stderr)
break
else:
sresult = select.select([process.stdout, process.stderr], [], [], 0)[0]
if process.stdout in sresult:
outputline = process.stdout.readline().strip()
self.print(outputline)
elif process.stderr in sresult:
outputline = process.stderr.readline().strip()
self.print(outputline, file=sys.stderr)
else:
self.update_idletasks()
# Reimport the pad list by reading the top-level verilog netlist. Determine
# what pads are listed in the file, and check against the existing pad list.
# The verilog/ directory should have a .v file containing a module of the
# same name as self.project (ip-name). The .v filename should have the
# same name as well (but not necessarily). To do: Handle import of
# projects having a top-level schematic instead of a verilog netlist.
def vlogimport(self):
if self.ef_format:
config_dir = '/.ef-config'
else:
config_dir = '/.config'
# First find the process PDK name for this project. Read the nodeinfo.json
# file and find the list of I/O cell libraries.
if self.techpath:
pdkpath = self.techpath
elif os.path.islink(self.projectpath + config_dir + '/techdir'):
pdkpath = os.path.realpath(self.projectpath + config_dir + '/techdir')
else:
self.print('Error: Cannot determine path to PDK. Try using option -tech-path=')
return
self.print('Importing verilog sources.')
nodeinfopath = pdkpath + config_dir + '/nodeinfo.json'
ioleflist = []
if os.path.exists(nodeinfopath):
self.print('Reading known I/O cell libraries from ' + nodeinfopath)
with open(nodeinfopath, 'r') as ifile:
itop = json.load(ifile)
if 'iocells' in itop:
ioleflist = []
for iolib in itop['iocells']:
if '/' in iolib:
# Entries <lib>/<cell> refer to specific files
if self.ef_format:
iolibpath = pdkpath + '/libs.ref/lef/' + iolib
else:
iolibpath = pdkpath + '/libs.ref/' + iolib
if os.path.splitext(iolib)[1] == '':
if not os.path.exists(iolibpath):
iolibpath = iolibpath + '.lib'
if not os.path.exists(iolibpath):
self.print('Warning: nodeinfo.json bad I/O library path ' + iolibpath)
ioleflist.append(iolibpath)
else:
# All other entries refer to everything in the directory.
if self.ef_format:
iolibpath = pdkpath + '/libs.ref/lef/' + iolib
else:
iolibpath = pdkpath + '/libs.ref/' + iolib + '/lef/'
iolibfiles = glob.glob(iolibpath + '/*.lef')
if len(iolibfiles) == 0:
self.print('Warning: nodeinfo.json bad I/O library path ' + iolibpath)
ioleflist.extend(iolibfiles)
else:
# Diagnostic
self.print('Cannot read PDK information file ' + nodeinfopath)
# Fallback behavior: List everything in libs.ref/lef/ beginning with "IO"
if len(ioleflist) == 0:
if self.ef_format:
ioleflist = glob.glob(pdkpath + '/libs.ref/lef/IO*/*.lef')
else:
ioleflist = glob.glob(pdkpath + '/libs.ref/IO*/lef/*.lef')
if len(ioleflist) == 0:
self.print('Cannot find any I/O cell libraries for this technology')
return
# Read the LEF libraries to get a list of all available cells. Keep
# this list of cells in "celldefs".
celldefs = []
ioliblist = []
ioleflibs = []
for iolib in ioleflist:
iolibpath = os.path.split(iolib)[0]
iolibfile = os.path.split(iolib)[1]
ioliblist.append(os.path.split(iolibpath)[1])
celldefs.extend(self.read_lef_macros(iolibpath, iolibfile, 'iolib'))
verilogcells = []
newpadlist = []
coredefs = []
corecells = []
corecelllist = []
lefprocessed = []
busrex = re.compile('.*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\]')
vlogpath = self.projectpath + '/verilog'
vlogfile = vlogpath + '/' + self.project + '.v'
# Verilog netlists are too difficult to parse from a simple script.
# Use qflow tools to convert to SPICE, if they are available. Parse
# the verilog only for "include" statements to find the origin of
# the various IP blocks, and then parse the SPICE file to get the
# full list of instances.
#
# (to be done)
if os.path.isfile(vlogfile):
with open(vlogfile, 'r') as ifile:
vloglines = ifile.read().splitlines()
for vlogline in vloglines:
vlogparse = re.split('[\t ()]', vlogline)
while '' in vlogparse:
vlogparse.remove('')
if vlogparse == []:
continue
elif vlogparse[0] == '//':
continue
elif vlogparse[0] == '`include':
incpath = vlogparse[1].strip('"')
libpath = os.path.split(incpath)[0]
libname = os.path.split(libpath)[1]
libfile = os.path.split(incpath)[1]
# Read the verilog library for module names to match
# against macro names in celldefs.
modulelist = self.read_verilog_lib(incpath, vlogpath)
matching = list(item for item in celldefs if item['name'] in modulelist)
for imatch in matching:
verilogcells.append(imatch['name'])
leffile = imatch['iolib']
if leffile not in ioleflibs:
ioleflibs.append(leffile)
# Read a corresponding LEF file entry for non-I/O macros, if one
# can be found (this handles files in the PDK).
if len(matching) == 0:
if libname != '':
# (NOTE: Assumes full path starting with '/')
lefpath = libpath.replace('verilog', 'lef')
lefname = libfile.replace('.v', '.lef')
if not os.path.exists(lefpath + '/' + lefname):
leffiles = glob.glob(lefpath + '/*.lef')
else:
leffiles = [lefpath + '/' + lefname]
for leffile in leffiles:
if leffile in ioleflibs:
continue
elif leffile in lefprocessed:
continue
else:
lefprocessed.append(leffile)
lefname = os.path.split(leffile)[1]
newcoredefs = self.read_lef_macros(lefpath, lefname, 'celllib')
coredefs.extend(newcoredefs)
corecells.extend(list(item['name'] for item in newcoredefs))
if leffiles == []:
maglefname = libfile.replace('.v', '.mag')
# Handle PDK files with a maglef/ view but no LEF file.
maglefpath = libpath.replace('verilog', 'maglef')
if not os.path.exists(maglefpath + '/' + maglefname):
magleffiles = glob.glob(maglefpath + '/*.mag')
else:
magleffiles = [maglefpath + '/' + maglefname]
if magleffiles == []:
# Handle user ip/ files with a maglef/ view but
# no LEF file.
maglefpath = libpath.replace('verilog', 'maglef')
designpath = os.path.split(self.projectpath)[0]
maglefpath = designpath + '/ip/' + maglefpath
if not os.path.exists(maglefpath + '/' + maglefname):
magleffiles = glob.glob(maglefpath + '/*.mag')
else:
magleffiles = [maglefpath + '/' + maglefname]
for magleffile in magleffiles:
# Generate LEF file. Since PDK and ip/ entries
# are not writeable, write into the project mag/
# directory.
magpath = self.projectpath + '/mag'
magname = os.path.split(magleffile)[1]
magroot = os.path.splitext(magname)[0]
leffile = magpath + '/' + magroot + '.lef'
if not os.path.isfile(leffile):
self.write_lef_file(magleffile, magpath)
if leffile in ioleflibs:
continue
elif leffile in lefprocessed:
continue
else:
lefprocessed.append(leffile)
lefname = os.path.split(leffile)[1]
newcoredefs = self.read_lef_macros(magpath, lefname, 'celllib')
coredefs.extend(newcoredefs)
corecells.extend(list(item['name'] for item in newcoredefs))
# LEF files generated on-the-fly are not needed
# after they have been parsed.
# os.remove(leffile)
# Check if all modules in modulelist are represented by
# corresponding LEF macros. If not, then go looking for a LEF
# file in the mag/ or maglef/ directory. Then, go looking for
# a .mag file in the mag/ or maglef/ directory, and build a
# LEF macro from it.
matching = list(item['name'] for item in coredefs if item['name'] in modulelist)
for module in modulelist:
if module not in matching:
lefpath = self.projectpath + '/lef'
magpath = self.projectpath + '/mag'
maglefpath = self.projectpath + '/mag'
lefname = libfile.replace('.v', '.lef')
# If the verilog file root name is not the same as
# the module name, then make a quick check for a
# LEF file with the same root name as the verilog.
# That indicates that the module does not exist in
# the LEF file, probably because it is a primary
# module that does not correspond to any layout.
leffile = lefpath + '/' + lefname
if os.path.exists(leffile):
self.print('Diagnostic: module ' + module + ' is not in ' + leffile + ' (probably a primary module)')
continue
leffile = magpath + '/' + lefname
istemp = False
if not os.path.exists(leffile):
magname = libfile.replace('.v', '.mag')
magfile = magpath + '/' + magname
if os.path.exists(magfile):
self.print('Diagnostic: Found a .mag file for ' + module + ' in ' + magfile)
self.write_lef_file(magfile)
istemp = True
else:
magleffile = maglefpath + '/' + lefname
if not os.path.exists(magleffile):
self.print('Diagnostic: (module ' + module + ') has no LEF file ' + leffile + ' or ' + magleffile)
magleffile = maglefpath + '/' + magname
if os.path.exists(magleffile):
self.print('Diagnostic: Found a .mag file for ' + module + ' in ' + magleffile)
if os.access(maglefpath, os.W_OK):
self.write_lef_file(magleffile)
leffile = magleffile
istemp = True
else:
self.write_lef_file(magleffile, magpath)
else:
self.print('Did not find a file ' + magfile)
# self.print('Warning: module ' + module + ' has no LEF or .mag views')
pass
else:
self.print('Diagnostic: Found a LEF file for ' + module + ' in ' + magleffile)
leffile = magleffile
else:
self.print('Diagnostic: Found a LEF file for ' + module + ' in ' + leffile)
if os.path.exists(leffile):
if leffile in lefprocessed:
continue
else:
lefprocessed.append(leffile)
newcoredefs = self.read_lef_macros(magpath, lefname, 'celllib')
# The LEF file generated on-the-fly is not needed
# any more after parsing the macro(s).
# if istemp:
# os.remove(leffile)
coredefs.extend(newcoredefs)
corecells.extend(list(item['name'] for item in newcoredefs))
else:
# self.print('Failed to find a LEF view for module ' + module)
pass
elif vlogparse[0] in verilogcells:
# Check for array of pads
bushigh = buslow = -1
if len(vlogparse) >= 3:
bmatch = busrex.match(vlogline)
if bmatch:
bushigh = int(bmatch.group(1))
buslow = int(bmatch.group(2))
for i in range(buslow, bushigh + 1):
newpad = {}
if i >= 0:
newpad['name'] = vlogparse[1] + '[' + str(i) + ']'
else:
newpad['name'] = vlogparse[1]
newpad['cell'] = vlogparse[0]
padcell = next(item for item in celldefs if item['name'] == vlogparse[0])
newpad['iolib'] = padcell['iolib']
newpad['class'] = padcell['class']
newpad['subclass'] = padcell['subclass']
newpad['width'] = padcell['width']
newpad['height'] = padcell['height']
newpadlist.append(newpad)
elif vlogparse[0] in corecells:
# Check for array of cells
bushigh = buslow = -1
if len(vlogparse) >= 3:
bmatch = busrex.match(vlogline)
if bmatch:
bushigh = int(bmatch.group(1))
buslow = int(bmatch.group(2))
for i in range(buslow, bushigh + 1):
newcorecell = {}
if i >= 0:
newcorecell['name'] = vlogparse[1] + '[' + str(i) + ']'
else:
newcorecell['name'] = vlogparse[1]
newcorecell['cell'] = vlogparse[0]
corecell = next(item for item in coredefs if item['name'] == vlogparse[0])
newcorecell['celllib'] = corecell['celllib']
newcorecell['class'] = corecell['class']
newcorecell['subclass'] = corecell['subclass']
newcorecell['width'] = corecell['width']
newcorecell['height'] = corecell['height']
corecelllist.append(newcorecell)
self.print('')
self.print('Source file information:')
self.print('Source filename: ' + vlogfile)
self.print('Number of I/O libraries is ' + str(len(ioleflibs)))
self.print('Number of library cells in I/O libraries used: ' + str(len(verilogcells)))
self.print('Number of core celldefs is ' + str(len(coredefs)))
self.print('')
self.print('Number of I/O cells in design: ' + str(len(newpadlist)))
self.print('Number of core cells in design: ' + str(len(corecelllist)))
self.print('')
# Save the results
self.celldefs = celldefs
self.coredefs = coredefs
self.vlogpads = newpadlist
self.corecells = corecelllist
self.ioleflibs = ioleflibs
# Check self.vlogpads, which was created during import (above) against
# self.(N,S,W,E)pads, which was read from the DEF file (if there was one)
# Also check self.corecells, which was created during import against
# self.coregroup, which was read from the DEF file.
def resolve(self):
self.print('Resolve differences in verilog and LEF views.')
samepads = []
addedpads = []
removedpads = []
# (1) Create list of entries that are in both self.vlogpads and self.()pads
# (2) Create list of entries that are in self.vlogpads but not in self.()pads
allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad
for pad in self.vlogpads:
newpadname = pad['name']
try:
lpad = next(item for item in allpads if item['name'] == newpadname)
except:
addedpads.append(pad)
else:
samepads.append(lpad)
# (3) Create list of entries that are in allpads but not in self.vlogpads
for pad in allpads:
newpadname = pad['name']
try:
lpad = next(item for item in self.vlogpads if item['name'] == newpadname)
except:
removedpads.append(pad)
# Print results
if len(addedpads) > 0:
self.print('Added pads:')
for pad in addedpads:
self.print(pad['name'] + ' (' + pad['cell'] + ')')
if len(removedpads) > 0:
plist = []
nspacers = 0
for pad in removedpads:
if 'subclass' in pad:
if pad['subclass'] != 'SPACER':
plist.append(pad)
else:
nspacers += 1
if nspacers > 0:
self.print(str(nspacers) + ' spacer cells ignored.')
if len(plist) > 0:
self.print('Removed pads:')
for pad in removedpads:
self.print(pad['name'] + ' (' + pad['cell'] + ')')
if len(addedpads) + len(removedpads) == 0:
self.print('Pad list has not changed.')
# Remove all cells from the "removed" list, with comment
allpads = [self.Npads, self.NEpad, self.Epads, self.SEpad, self.Spads, self.SWpad, self.Wpads, self.NWpad]
for pad in removedpads:
rname = pad['name']
for row in allpads:
try:
rpad = next(item for item in row if item['name'] == rname)
except:
rpad = None
else:
row.remove(rpad)
# Now the verilog file has no placement information, so the old padlist
# entries (if they exist) are preferred. Add to these the new padlist
# entries
# First pass for unassigned pads: Use of "CLASS ENDCAP" is preferred
# for identifying corner pads. Otherwise, if 'CORNER' or 'corner' is
# in the pad name, then make sure there is one per row in the first
# position. This is not foolproof and depends on the cell library
# using the text 'corner' in the name of the corner cell. However,
# if the ad hoc methods fail, the user can still manually move the
# corner cells to the right place (to be done: Identify if library
# uses ENDCAP designation for corner cells up front; don't go
# looking for 'corner' text if the cells are easily identifiable by
# LEF class).
for pad in addedpads[:]:
iscorner = False
if 'class' in pad and pad['class'] == 'ENDCAP':
iscorner = True
elif 'CORNER' in pad['cell'].upper():
iscorner = True
if iscorner:
if self.NWpad == []:
self.NWpad.append(pad)
pad['o'] = 'E'
addedpads.remove(pad)
elif self.NEpad == []:
self.NEpad.append(pad)
pad['o'] = 'S'
addedpads.remove(pad)
elif self.SEpad == []:
self.SEpad.append(pad)
pad['o'] = 'W'
addedpads.remove(pad)
elif self.SWpad == []:
self.SWpad.append(pad)
pad['o'] = 'N'
addedpads.remove(pad)
numN = len(self.Npads)
numS = len(self.Spads)
numE = len(self.Epads)
numW = len(self.Wpads)
minnum = min(numN, numS, numE, numW)
minnum = max(minnum, int(len(addedpads) / 4))
# Add pads in clockwise order. Note that S and E pads are defined counterclockwise
for pad in addedpads:
if numN < minnum:
self.Npads.append(pad)
numN += 1
pad['o'] = 'S'
self.print("Adding pad " + pad['name'] + " to Npads")
elif numE < minnum:
self.Epads.insert(0, pad)
numE += 1
pad['o'] = 'W'
self.print("Adding pad " + pad['name'] + " to Epads")
elif numS < minnum:
self.Spads.insert(0, pad)
numS += 1
pad['o'] = 'N'
self.print("Adding pad " + pad['name'] + " to Spads")
# elif numW < minnum:
else:
self.Wpads.append(pad)
numW += 1
pad['o'] = 'E'
self.print("Adding pad " + pad['name'] + " to Wpads")
minnum = min(numN, numS, numE, numW)
minnum = max(minnum, int(len(addedpads) / 4))
# Make sure all pads have included information from the cell definition
allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad
for pad in allpads:
if 'width' not in pad:
try:
celldef = next(item for item in celldefs if item['name'] == pad['cell'])
except:
self.print('Cell ' + pad['cell'] + ' not found!')
else:
pad['width'] = celldef['width']
pad['height'] = celldef['height']
pad['class'] = celldef['class']
pad['subclass'] = celldef['subclass']
# Now treat the core cells in the same way (resolve list parsed from verilog
# against the list parsed from DEF)
# self.print('Diagnostic: ')
# self.print('self.corecells = ' + str(self.corecells))
# self.print('self.coregroup = ' + str(self.coregroup))
samecore = []
addedcore = []
removedcore = []
# (1) Create list of entries that are in both self.corecells and self.coregroup
# (2) Create list of entries that are in self.corecells but not in self.coregroup
for cell in self.corecells:
newcellname = cell['name']
try:
lcore = next(item for item in self.coregroup if item['name'] == newcellname)
except:
addedcore.append(cell)
else:
samecore.append(lcore)
# (3) Create list of entries that are in self.coregroup but not in self.corecells
for cell in self.coregroup:
newcellname = cell['name']
try:
lcore = next(item for item in self.corecells if item['name'] == newcellname)
except:
removedcore.append(cell)
# Print results
if len(addedcore) > 0:
self.print('Added core cells:')
for cell in addedcore:
self.print(cell['name'] + ' (' + cell['cell'] + ')')
if len(removedcore) > 0:
clist = []
for cell in removedcore:
clist.append(cell)
if len(clist) > 0:
self.print('Removed core cells:')
for cell in removedcore:
self.print(cell['name'] + ' (' + cell['cell'] + ')')
if len(addedcore) + len(removedcore) == 0:
self.print('Core cell list has not changed.')
# Remove all cells from the "removed" list
coregroup = self.coregroup
for cell in removedcore:
rname = cell['name']
try:
rcell = next(item for item in coregroup if item['name'] == rname)
except:
rcell = None
else:
coregroup.remove(rcell)
# Add all cells from the "added" list to coregroup
for cell in addedcore:
rname = cell['name']
try:
rcell = next(item for item in coregroup if item['name'] == rname)
except:
coregroup.append(cell)
if not 'o' in cell:
cell['o'] = 'N'
if not 'x' in cell:
if len(self.Wpads) > 0:
pad = self.Wpads[0]
padx = pad['x'] if 'x' in pad else 0
cell['x'] = padx + pad['height'] + self.margin
else:
cell['x'] = self.margin
if not 'y' in cell:
if len(self.Spads) > 0:
pad = self.Spads[0]
pady = pad['y'] if 'y' in pad else 0
cell['y'] = pady + pad['height'] + self.margin
else:
cell['y'] = self.margin
else:
rcell = None
# Make sure all core cells have included information from the cell definition
for cell in coregroup:
if 'width' not in cell:
try:
coredef = next(item for item in coredefs if item['name'] == cell['cell'])
except:
self.print('Cell ' + cell['cell'] + ' not found!')
else:
cell['width'] = coredef['width']
cell['height'] = coredef['height']
cell['class'] = coredef['class']
cell['subclass'] = coredef['subclass']
# Generate a new padframe by writing the configuration file, running
# padring, reading back the DEF file, and (re)poplulating the workspace
def generate(self, level=0):
self.print('Generate legal padframe using padring')
# Write out the configuration file
self.writeconfig()
# Run the padring app
self.runpadring()
# Rotate pads in the output if pad orientations are different from
# padring's expectations
self.rotate_pads_in_def()
# Read the placement information back from the generated DEF file
self.readplacement()
# Resolve differences (e.g., remove spacers)
self.resolve()
# Recreate and draw the padframe view on the canvas
self.populate(level + 1)
self.frame_configure(None)
# Write a new configuration file
def writeconfig(self):
mag_path = self.projectpath + '/mag'
if not os.path.exists(mag_path):
self.print('Error: No project path /mag directory exists. Cannot write config file.')
return
self.print('Writing padring configuration file.')
# Determine cell width and height from pad sizes.
# NOTE: This compresses the chip to the minimum dimensions
# allowed by the arrangement of pads. Use a "core" block to
# force the area larger than minimum (not yet implemented)
topwidth = 0
for pad in self.Npads:
if 'width' not in pad:
self.print('No width: pad = ' + str(pad))
topwidth += pad['width']
# Add in the corner cells
if self.NWpad != []:
topwidth += self.NWpad[0]['height']
if self.NEpad != []:
topwidth += self.NEpad[0]['width']
botwidth = 0
for pad in self.Spads:
botwidth += pad['width']
# Add in the corner cells
if self.SWpad != []:
botwidth += self.SWpad[0]['width']
if self.SEpad != []:
botwidth += self.SEpad[0]['height']
width = max(botwidth, topwidth)
# if width < self.urx - self.llx:
# width = self.urx - self.llx
leftheight = 0
for pad in self.Wpads:
leftheight += pad['width']
# Add in the corner cells
if self.NWpad != []:
leftheight += self.NWpad[0]['height']
if self.SWpad != []:
leftheight += self.SWpad[0]['width']
rightheight = 0
for pad in self.Epads:
rightheight += pad['width']
# Add in the corner cells
if self.NEpad != []:
rightheight += self.NEpad[0]['width']
if self.SEpad != []:
rightheight += self.SEpad[0]['height']
height = max(leftheight, rightheight)
# Check the dimensions of the core cells. If they exceed the available
# padframe area, then expand the padframe to accomodate the core.
corellx = coreurx = (self.llx + self.urx) / 2
corelly = coreury = (self.lly + self.ury) / 2
for corecell in self.coregroup:
corient = corecell['o']
if 'S' in corient or 'N' in corient:
cwidth = corecell['width']
cheight = corecell['height']
else:
cwidth = corecell['height']
cheight = corecell['width']
if corecell['x'] < corellx:
corellx = corecell['x']
if corecell['x'] + cwidth > coreurx:
coreurx = corecell['x'] + cwidth
if corecell['y'] < corelly:
corelly = corecell['y']
if corecell['y'] + cheight > coreury:
coreury = corecell['y'] + cheight
coreheight = coreury - corelly
corewidth = coreurx - corellx
# Ignoring the possibility of overlaps with nonstandard-sized pads,
# assuming that the user has visually separated them. Only check
# the core bounds against the standard padframe inside edge.
if self.SWpad != [] and self.SEpad != []:
if corewidth > width - self.SWpad[0]['width'] - self.SEpad[0]['width']:
width = corewidth + self.SWpad[0]['width'] + self.SEpad[0]['width']
if self.NWpad != [] and self.SWpad != []:
if coreheight > height - self.NWpad[0]['height'] - self.SWpad[0]['height']:
height = coreheight + self.NWpad[0]['height'] + self.SWpad[0]['height']
# Core cells are given a margin of self.margin from the pad inside edge, so the
# core area passed to the padring app is 2 * self.margin larger than the
# measured size of the core area.
width += 2 * self.margin
height += 2 * self.margin
if self.keep_cfg == False or not os.path.exists(mag_path + '/padframe.cfg'):
if os.path.exists(mag_path + '/padframe.cfg'):
# Copy the previous padframe.cfg file to a backup. In case something
# goes badly wrong, this should be the only file overwritten, and can
# be recovered from the backup.
shutil.copy(mag_path + '/padframe.cfg', mag_path + '/padframe.cfg.bak')
with open(mag_path + '/padframe.cfg', 'w') as ofile:
print('AREA ' + str(int(width)) + ' ' + str(int(height)) + ' ;',
file=ofile)
print('', file=ofile)
for pad in self.NEpad:
print('CORNER ' + pad['name'] + ' SW ' + pad['cell'] + ' ;',
file=ofile)
for pad in self.SEpad:
print('CORNER ' + pad['name'] + ' NW ' + pad['cell'] + ' ;',
file=ofile)
for pad in self.SWpad:
print('CORNER ' + pad['name'] + ' NE ' + pad['cell'] + ' ;',
file=ofile)
for pad in self.NWpad:
print('CORNER ' + pad['name'] + ' SE ' + pad['cell'] + ' ;',
file=ofile)
for pad in self.Npads:
flip = 'F ' if 'F' in pad['o'] else ''
print('PAD ' + pad['name'] + ' N ' + flip + pad['cell'] + ' ;',
file=ofile)
for pad in self.Epads:
flip = 'F ' if 'F' in pad['o'] else ''
print('PAD ' + pad['name'] + ' E ' + flip + pad['cell'] + ' ;',
file=ofile)
for pad in self.Spads:
flip = 'F ' if 'F' in pad['o'] else ''
print('PAD ' + pad['name'] + ' S ' + flip + pad['cell'] + ' ;',
file=ofile)
for pad in self.Wpads:
flip = 'F ' if 'F' in pad['o'] else ''
print('PAD ' + pad['name'] + ' W ' + flip + pad['cell'] + ' ;',
file=ofile)
# Run the padring app.
def runpadring(self):
mag_path = self.projectpath + '/mag'
if not os.path.exists(mag_path):
self.print('No path /mag exists in project space; cannot run padring.')
return
self.print('Running padring')
if self.padring_path:
padringopts = [self.padring_path]
else:
padringopts = ['padring']
# Diagnostic
# self.print('Used libraries (self.ioleflibs) = ' + str(self.ioleflibs))
for iolib in self.ioleflibs:
padringopts.append('-L')
padringopts.append(iolib)
padringopts.append('--def')
padringopts.append('padframe.def')
padringopts.append('padframe.cfg')
self.print('Running ' + str(padringopts))
p = subprocess.Popen(padringopts, stdout = subprocess.PIPE,
stderr = subprocess.PIPE, cwd = mag_path)
self.watch(p)
# Read placement information from the DEF file generated by padring.
def readplacement(self, precheck=False):
self.print('Reading placement information from DEF file')
mag_path = self.projectpath + '/mag'
if not os.path.isfile(mag_path + '/padframe.def'):
if not precheck:
self.print('No file padframe.def: pad frame was not generated.')
return False
# Very simple DEF file parsing. The placement DEF only contains a
# COMPONENTS section. Certain assumptions are made about the syntax
# that depends on the way 'padring' writes its output. This is not
# a rigorous DEF parser!
units = 1000
in_components = False
Npadlist = []
Spadlist = []
Epadlist = []
Wpadlist = []
NEpad = []
NWpad = []
SEpad = []
SWpad = []
coregroup = []
# Reset bounds
self.llx = self.lly = self.urx = self.ury = 0
corners = 0
with open(mag_path + '/padframe.def', 'r') as ifile:
deflines = ifile.read().splitlines()
for line in deflines:
if 'UNITS DISTANCE MICRONS' in line:
units = line.split()[3]
elif in_components:
lparse = line.split()
if lparse[0] == '-':
instname = lparse[1]
cellname = lparse[2]
elif lparse[0] == '+':
if lparse[1] == 'PLACED':
placex = lparse[3]
placey = lparse[4]
placeo = lparse[6]
newpad = {}
newpad['name'] = instname
newpad['cell'] = cellname
try:
celldef = next(item for item in self.celldefs if item['name'] == cellname)
except:
celldef = None
else:
newpad['iolib'] = celldef['iolib']
newpad['width'] = celldef['width']
newpad['height'] = celldef['height']
newpad['class'] = celldef['class']
newpad['subclass'] = celldef['subclass']
newpad['x'] = float(placex) / float(units)
newpad['y'] = float(placey) / float(units)
newpad['o'] = placeo
# Adjust bounds
if celldef:
if newpad['x'] < self.llx:
self.llx = newpad['x']
if newpad['y'] < self.lly:
self.lly = newpad['y']
if newpad['o'] == 'N' or newpad['o'] == 'S':
padurx = newpad['x'] + celldef['width']
padury = newpad['y'] + celldef['height']
else:
padurx = newpad['x'] + celldef['height']
padury = newpad['y'] + celldef['width']
if padurx > self.urx:
self.urx = padurx
if padury > self.ury:
self.ury = padury
# First four entries in the DEF file are corners
# padring puts the lower left corner at zero, so
# use the zero coordinates to determine which pads
# are which. Note that padring assumes the corner
# pad is drawn in the SW corner position!
if corners < 4:
if newpad['x'] == 0 and newpad['y'] == 0:
SWpad.append(newpad)
elif newpad['x'] == 0:
NWpad.append(newpad)
elif newpad['y'] == 0:
SEpad.append(newpad)
else:
NEpad.append(newpad)
corners += 1
else:
# Place according to orientation. If orientation
# is not standard, be sure to make it standard!
placeo = self.rotate_orientation(placeo)
if placeo == 'N':
Spadlist.append(newpad)
elif placeo == 'E':
Wpadlist.append(newpad)
elif placeo == 'S':
Npadlist.append(newpad)
else:
Epadlist.append(newpad)
elif 'END COMPONENTS' in line:
in_components = False
elif 'COMPONENTS' in line:
in_components = True
self.Npads = Npadlist
self.Wpads = Wpadlist
self.Spads = Spadlist
self.Epads = Epadlist
self.NWpad = NWpad
self.NEpad = NEpad
self.SWpad = SWpad
self.SEpad = SEpad
# The padframe has its own DEF file from the padring app, but the core
# does not. The core needs to be floorplanned in a very similar manner.
# This will be done by searching for a DEF file of the project top-level
# layout. If none exists, it is created by generating it from the layout.
# If the top-level layout does not exist, then all core cells are placed
# at the origin, and the origin placed at the padframe inside corner.
mag_path = self.projectpath + '/mag'
if not os.path.isfile(mag_path + '/' + self.project + '.def'):
if os.path.isfile(mag_path + '/' + self.project + '.mag'):
# Create a DEF file from the layout
with open(mag_path + '/pfg_write_def.tcl', 'w') as ofile:
print('drc off', file=ofile)
print('box 0 0 0 0', file=ofile)
print('load ' + self.project, file=ofile)
print('def write', file=ofile)
print('quit', file=ofile)
magicexec = self.magic_path if self.magic_path else 'magic'
mproc = subprocess.Popen([magicexec, '-dnull', '-noconsole',
'pfg_write_def.tcl'],
stdin = subprocess.PIPE, stdout = subprocess.PIPE,
stderr = subprocess.PIPE, cwd = mag_path, universal_newlines = True)
self.watch(mproc)
os.remove(mag_path + '/pfg_write_def.tcl')
elif not os.path.isfile(mag_path + '/core.def'):
# With no other information available, copy the corecells
# (from the verilog file) into the coregroup list.
# Position all core cells starting at the padframe top left
# inside corner, and arranging in rows without overlapping.
# Note that no attempt is made to organize the cells or
# otherwise produce an efficient layout. Any dimension larger
# than the current padframe overruns to the right or bottom.
if self.SWpad != []:
corellx = SWpad[0]['x'] + SWpad[0]['width'] + self.margin
corelly = SWpad[0]['y'] + SWpad[0]['height'] + self.margin
else:
corellx = Wpadlist[0]['x'] + Wpadlist[0]['height'] + self.margin
corelly = Spadlist[0]['x'] + Spadlist[0]['height'] + self.margin
if self.NEpad != []:
coreurx = NEpad[0]['x'] - self.margin
coreury = NEpad[0]['y'] - self.margin
else:
coreurx = Epadlist[0]['x'] - self.margin
coreury = Npadlist[0]['x'] - self.margin
locllx = corellx
testllx = corellx
loclly = corelly
testlly = corelly
nextlly = corelly
for cell in self.corecells:
testllx = locllx + cell['width']
if testllx > coreurx:
locllx = corellx
corelly = nextlly
loclly = nextlly
newcore = cell
newcore['x'] = locllx
newcore['y'] = loclly
newcore['o'] = 'N'
locllx += cell['width'] + self.margin
testlly = corelly + cell['height'] + self.margin
if testlly > nextlly:
nextlly = testlly
coregroup.append(newcore)
self.coregroup = coregroup
if os.path.isfile(mag_path + '/' + self.project + '.def'):
# Read the top-level DEF, and use it to position the core cells.
self.print('Reading the top-level cell DEF for core cell placement.')
units = 1000
in_components = False
with open(mag_path + '/' + self.project + '.def', 'r') as ifile:
deflines = ifile.read().splitlines()
for line in deflines:
if 'UNITS DISTANCE MICRONS' in line:
units = line.split()[3]
elif in_components:
lparse = line.split()
if lparse[0] == '-':
instname = lparse[1]
# NOTE: Magic should not drop the entire path to the
# cell for the cellname; this needs to be fixed! To
# work around it, remove any path components.
cellpath = lparse[2]
cellname = os.path.split(cellpath)[1]
elif lparse[0] == '+':
if lparse[1] == 'PLACED':
placex = lparse[3]
placey = lparse[4]
placeo = lparse[6]
newcore = {}
newcore['name'] = instname
newcore['cell'] = cellname
try:
celldef = next(item for item in self.coredefs if item['name'] == cellname)
except:
celldef = None
else:
newcore['celllib'] = celldef['celllib']
newcore['width'] = celldef['width']
newcore['height'] = celldef['height']
newcore['class'] = celldef['class']
newcore['subclass'] = celldef['subclass']
newcore['x'] = float(placex) / float(units)
newcore['y'] = float(placey) / float(units)
newcore['o'] = placeo
coregroup.append(newcore)
elif 'END COMPONENTS' in line:
in_components = False
elif 'COMPONENTS' in line:
in_components = True
self.coregroup = coregroup
elif os.path.isfile(mag_path + '/core.def'):
# No DEF or .mag file, so fallback position is the last core.def
# file generated by this script.
self.read_core_def(precheck=precheck)