Modified og_gui_manager.py to make it accessible on devices not on the efabless platform. Changed the create project script to make the proper config directories so that the editors can be used. Modified profile.py to make the settings properly reflect the user preferences.
diff --git a/common/cace_datasheet_upload.py b/common/cace_datasheet_upload.py
new file mode 100755
index 0000000..95469b1
--- /dev/null
+++ b/common/cace_datasheet_upload.py
@@ -0,0 +1,193 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3 -B
+#
+# cace_datasheet_upload.py
+#
+# Send newly-created challenge datasheet and associated
+# design files (testbench schematics and netlists) to
+# the marketplace server for storage.
+#
+
+import os
+import json
+import re
+import sys
+import requests
+import subprocess
+
+import file_compressor
+import file_request_hash
+
+import og_config
+
+"""
+ Open Galaxy standalone script.
+ Makes rest calls to marketplace REST server to save datasheet
+ and associated file(s). Request hash is generated so the two
+ requests can be associated on the server side. This action
+ has no other side effects.
+"""
+
+mktp_server_url = og_config.mktp_server_url
+
+# Make request to server sending json passed in.
+def send_doc(doc):
+ result = requests.post(mktp_server_url + '/cace/save_datasheet', json=doc)
+ print('send_doc', result.status_code)
+
+# Pure HTTP post here. Add the file to files object and the hash/filename
+# to the data params.
+def send_file(hash, file, file_name):
+ files = {'file': file.getvalue()}
+ data = {'request-hash': hash, 'file-name': file_name}
+ result = requests.post(mktp_server_url + '/cace/save_files', files=files, data=data)
+ print('send_file', result.status_code)
+
+
+if __name__ == '__main__':
+
+ # Divide up command line into options and arguments
+ options = []
+ arguments = []
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ # There should be two arguments passed to the script. One is
+ # the path and filename of the datasheet JSON file, and the
+ # other a path to the location of testbenches (netlists and/or
+ # schematics). If there is only one argument, then datasheet_filepath
+ # is assumed to be in the same path as netlist_filepath.
+
+ datasheet_filepath = []
+ netlist_filepath = []
+
+ for argval in arguments:
+ if os.path.isfile(argval):
+ datasheet_filepath = argval
+ elif os.path.isdir(argval):
+ netlist_filepath = argval
+ elif os.path.splitext(argval)[1] == '':
+ argname = argval + '.json'
+ if os.path.isfile(argval):
+ datasheet_filepath = argname
+
+ if not datasheet_filepath:
+ # Check for JSON file 'project.json' in the netlist filepath directory
+ # or the directory above it.
+ if netlist_filepath:
+ argtry = netlist_filepath + '/project.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+ else:
+ argtry = os.path.split(netlist_filepath)[0] + '/project.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+
+ # Legacy behavior support
+ if not os.path.isfile(datasheet_filepath):
+ # Check for JSON file with same name as netlist filepath,
+ # but with a .json extension, in the netlist filepath directory
+ # or the directory above it.
+ if netlist_filepath:
+ argtry = netlist_filepath + '/' + os.path.basename(netlist_filepath) + '.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+ else:
+ argtry = os.path.split(netlist_filepath)[0] + '/' + os.path.basename(netlist_filepath) + '.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+
+ if not datasheet_filepath:
+ print('Error: No datasheet JSON file specified.\n')
+ sys.exit(1)
+
+ if not os.path.isfile(datasheet_filepath):
+ print('Error: No datasheet JSON file ' + datasheet_filepath + ' found.\n')
+ sys.exit(1)
+
+ # Technically okay to have null netlist_filepath, but unlikely,
+ # so flag a warning.
+
+ if not netlist_filepath:
+ print('Warning: No netlist filepath given. No files will be '
+ + 'transmitted with the datasheet.\n')
+
+ dsheet = {}
+ with open(datasheet_filepath, 'r') as user_doc_file:
+ docinfo = json.load(user_doc_file)
+ dsheet = docinfo['data-sheet']
+ try:
+ name = dsheet['ip-name']
+ except KeyError:
+ datasheet_file = os.path.split(datasheet_filepath)[1]
+ name = os.path.splitext(datasheet_file)[0]
+ dsheet['ip-name'] = name
+
+ # Behavior starting 4/27/2017: the UID is required to be a
+ # numeric value, but the datasheet upload is generally being
+ # done as user admin from the remote CACE host, and admin has
+ # no official UID number. So always attach ID 9999 to datasheet
+ # uploads.
+
+ if 'UID' in docinfo:
+ uid = docinfo['UID']
+ else:
+ uid = 9999
+ docinfo['UID'] = uid
+
+ # Get a request hash and add it to the JSON document
+ rhash, timestamp = file_request_hash.get_hash(name)
+ docinfo['request-hash'] = rhash
+
+ # Put the current git system state into the target directory
+ # prior to tarballing
+ if os.path.isfile('/ef/.ef-version'):
+ with open('/ef/.ef-version', 'r') as f:
+ ef_version = f.read().rstrip()
+ docinfo['ef-version'] = ef_version
+
+ # Now send the datasheet
+ if '-test' in options:
+ print("Test: running send_doc( <docinfo> )\n")
+ print(" with docinfo['UID'] = " + uid + "\n")
+ else:
+ send_doc(docinfo)
+
+ # Send the merged JSON file and the tarballed design file directory
+ # to the marketplace server for storage.
+
+ if netlist_filepath:
+ # Use the version below to ignore the 'spi' directory. However, it may
+ # be the intention of the challenge creator to seed the challenge with
+ # an example. This is normally not the case. So use '-include' option
+ # to avoid excluding the 'spi' folder contents.
+ if '-includeall' in options:
+ print('Including netlist/schematic and simulation files in project folder.')
+ tar = file_compressor.tar_directory_contents(netlist_filepath,
+ exclude=['elec/\.java', 'elec/electric\.log', name + '\.log',
+ '.*\.raw', 'ngspice/run/\.allwaves'])
+ elif '-include' in options:
+ print('Including netlist/schematic files in project folder.')
+ tar = file_compressor.tar_directory_contents(netlist_filepath,
+ exclude=['ngspice', 'elec/\.java', 'elec/electric\.log',
+ name + '\.log'])
+ else:
+ print('Excluding netlist/schematic and simulation files in project folder.')
+ tar = file_compressor.tar_directory_contents(netlist_filepath,
+ exclude=['spi', 'ngspice', 'elec/\.java', 'mag', 'elec/electric\.log',
+ 'elec/' + name + '\.delib/' + name + '\.sch', name + '\.log'])
+ tarballname = name + '.tar.gz'
+
+ # Now send the netlist file tarball
+ if '-test' in options:
+ print('Test: running send_file(' + rhash + ' <tarball> ' + tarballname + ')')
+ print('Saving tarball locally as ' + tarballname)
+ file_compressor.tar_directory_contents_to_file(netlist_filepath,
+ tarballname, exclude=['spi', 'ngspice', 'elec/\.java', 'mag',
+ 'elec/electric\.log', 'elec/' + name + '\.delib/' + name + '\.sch',
+ name + '\.log'])
+ else:
+ send_file(rhash, tar, tarballname)
+
diff --git a/common/cace_design_upload.py b/common/cace_design_upload.py
new file mode 100755
index 0000000..08bdfa2
--- /dev/null
+++ b/common/cace_design_upload.py
@@ -0,0 +1,258 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+# cace_design_upload.py
+#
+# The purpose of this script is to package up the user
+# design schematic and associated files and send them to
+# the remote marketplace server, precipitating a launch
+# of CACE to officially characterize the design.
+#
+
+import os
+import json
+import re
+import sys
+import requests
+import subprocess
+
+import file_compressor
+import file_request_hash
+import local_uid_services
+
+import og_config
+
+"""
+ Open Galaxy standalone script.
+ Makes rest calls to marketplace REST server to save datasheet
+ and associated file(s). Request hash is generated so the two
+ requests can be associated on the server side. This action
+ causes the marketplace to run the official characterization
+ on the CACE server.
+"""
+
+mktp_server_url = og_config.mktp_server_url
+cace_server_url = og_config.cace_server_url
+
+# Make request to server sending json passed in.
+def send_doc(doc):
+ result = requests.post(mktp_server_url + '/cace/simulate_request', json=doc)
+ print('send_doc', result.status_code)
+
+# Cancel simulation (sent directly to CACE)
+def send_cancel_doc(doc):
+ result = requests.post(cace_server_url + '/cace/cancel_sims', json=doc)
+ print('send_cancel_doc', result.status_code)
+
+# Pure HTTP post here. Add the file to files object and the hash/filename
+# to the data params.
+def send_file(hash, file, file_name):
+ files = {'file': file.getvalue()}
+ data = {'request-hash': hash, 'file-name': file_name}
+ result = requests.post(mktp_server_url + '/cace/simulate_request_files', files=files, data=data)
+ print('send_file', result.status_code)
+
+if __name__ == '__main__':
+
+ # Divide up command line into options and arguments
+ options = []
+ arguments = []
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ # There should be two arguments passed to the script. One is
+ # the path and filename of the datasheet JSON file, and the
+ # other a path to the location of the design (netlist and/or
+ # schematic).
+
+ datasheet_filepath = []
+ design_filepath = []
+
+ for argval in arguments:
+ if os.path.isfile(argval):
+ datasheet_filepath = argval
+ elif os.path.isdir(argval):
+ design_filepath = argval
+ elif os.path.splitext(argval)[1] == '':
+ argname = argval + '.json'
+ if os.path.isfile(argval):
+ datasheet_filepath = argname
+
+ if not datasheet_filepath:
+ # Check for JSON file 'project.json' in the current or parent directory
+ if design_filepath:
+ argtry = design_filepath + '/project.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+ else:
+ argtry = os.path.split(design_filepath)[0] + '/project.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+
+ if not os.path.isfile(datasheet_filepath):
+ # Legacy behavior support:
+ # Check for JSON file with same name as netlist filepath,
+ # but with a .json extension, in the netlist filepath directory
+ # or the directory above it.
+ if design_filepath:
+ argtry = design_filepath + '/' + os.path.basename(design_filepath) + '.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+ else:
+ argtry = os.path.split(design_filepath)[0] + '/' + os.path.basename(design_filepath) + '.json'
+ if os.path.isfile(argtry):
+ datasheet_filepath = argtry
+
+ if not datasheet_filepath:
+ print('Error: No datasheet JSON file specified\n')
+ sys.exit(1)
+
+ if not os.path.isfile(datasheet_filepath):
+ print('Error: No datasheet JSON file ' + datasheet_filepath + ' found\n')
+ sys.exit(1)
+
+ # Read the datasheet now. Get the expected design name
+
+ dsheet = {}
+ print('Reading JSON datasheet ' + datasheet_filepath)
+ with open(datasheet_filepath, 'r') as user_doc_file:
+ docinfo = json.load(user_doc_file)
+ dsheet = docinfo['data-sheet']
+ name = dsheet['ip-name']
+
+ # Get JSON file of settings if it exists. It should be in the same
+ # location as the JSON datasheet file (generated by og_gui_characterize.py)
+ testmode = False
+ force = False
+ settings_filepath = os.path.split(datasheet_filepath)[0] + '/settings.json'
+ if os.path.exists(settings_filepath):
+ with open(settings_filepath, 'r') as user_settings_file:
+ settings = json.load(user_settings_file)
+ docinfo['settings'] = settings
+ if 'submit-as-schematic' in settings:
+ if settings['submit-as-schematic'] == True:
+ force = True
+ if 'submit-test-mode' in settings:
+ if settings['submit-test-mode'] == True:
+ testmode = True
+
+ # Use of "-force" in the options overrides any settings from the JSON file.
+ if '-force' in options:
+ force = True
+
+ if '-test' in options:
+ testmode = True
+
+ # Diagnostic
+ if 'identifiers' in docinfo:
+ print('Identifiers: ' + str(docinfo['identifiers']))
+
+ if not design_filepath:
+ print('Error: No schematic or netlist directory given\n')
+ sys.exit(1)
+ else:
+ # If design_filepath has a subdirectory "design", add that to
+ # the path name.
+ if os.path.isdir(design_filepath + '/spi'):
+ spice_filepath = design_filepath + '/spi'
+ filelist = os.listdir(spice_filepath)
+ if os.path.isdir(design_filepath + '/elec'):
+ if os.path.isdir(design_filepath + '/elec/' + name + '.delib'):
+ schem_filepath = design_filepath + '/elec/' + name + '.delib'
+ filelist.extend(os.listdir(schem_filepath))
+
+ # To be valid, the filepath must contain either a .spi file with
+ # the name of ip-name, or a .sch file with the name of ip-name.
+ netlistname = name + '.spi'
+ schemname = name + '.sch'
+ if netlistname not in filelist and schemname not in filelist:
+ print('Error: Path ' + design_filepath + ' has no schematic '
+ + 'or netlist for design ' + name + '\n')
+ sys.exit(1)
+
+ # Add key 'project-folder' to the document, containing the path to the
+ # JSON file. This is used by the CACE to ensure that progress information
+ # is passed to the correct folder, not relying on hard-coded home paths,
+ # and allowing for copies of projects in different paths.
+
+ foldername = os.path.split(datasheet_filepath)[0]
+ docinfo['project-folder'] = foldername
+
+ # Current expectation is to use UID (username). If it is not in the
+ # document, then add it here.
+
+ if testmode:
+ uid = {}
+ else:
+ if 'UID' not in docinfo:
+ uid = local_uid_services.get_uid(os.environ['USER'])
+ else:
+ uid = docinfo['UID']
+
+ if not uid or uid == 'null':
+ uid = os.environ['USER']
+ docinfo['UID'] = uid
+
+ # Handle cancel requests
+ if '-cancel' in options:
+ # Read last message . . .
+ if os.path.exists(design_filepath + '/ngspice/char/remote_status.json'):
+ with open(design_filepath + '/ngspice/char/remote_status.json', 'r') as f:
+ status = json.load(f)
+ if 'hash' in status:
+ docinfo['request-hash'] = status['hash']
+ send_cancel_doc(docinfo)
+ else:
+ print('No hash value in status file, cannot cancel.')
+ else:
+ print('No status file found, cannot cancel.')
+ sys.exit(0)
+
+ # If settings specify that the submission should be forced to be schematic-only,
+ # pass the setting to CACE as 'netlist-source' in the data-sheet record.
+ if force:
+ dsheet['netlist-source'] = 'schematic'
+
+ # Put the current git system state into the target directory
+ # prior to tarballing
+ if os.path.isfile('/ef/.ef-version'):
+ with open('/ef/.ef-version', 'r') as f:
+ ef_version = f.read().rstrip()
+ docinfo['ef-version'] = ef_version
+
+ rhash, timestamp = file_request_hash.get_hash(name)
+ docinfo['request-hash'] = rhash
+ print('request hash = ' + rhash + '\n')
+
+ # Now send the document
+ if testmode:
+ print('Test: running send_doc(docinfo)\n')
+ else:
+ send_doc(docinfo)
+
+ # Send the tarballed design file directory to the marketplace server for storage.
+ # Ignore the log file, which is meant for in-system diagnostics, not for storage.
+ exclusions = [name + '\.log', '.*\.raw',
+ 'elec/\.java',
+ 'ngspice/run/\.allwaves']
+
+ # If settings specify that the submission should be forced to be schematic-only,
+ # then don't tarball the layout database files.
+ if force:
+ exclusions.append('mag/.*\.mag')
+ exclusions.append('mag/.*\.ext')
+
+ # Now send the netlist file tarball
+ tarballname = name + '.tar.gz'
+ if testmode:
+ file_compressor.tar_directory_contents_to_file(design_filepath,
+ tarballname, exclude=exclusions)
+ os.rename(design_filepath + '/' + tarballname, tarballname)
+ print('Test: running send_file(' + rhash + ', <tarball>, ' + tarballname + ')\n')
+ else:
+ tar = file_compressor.tar_directory_contents(design_filepath,
+ exclude=exclusions)
+ send_file(rhash, tar, tarballname)
+
diff --git a/common/cace_gensim.py b/common/cace_gensim.py
new file mode 100755
index 0000000..76afb4b
--- /dev/null
+++ b/common/cace_gensim.py
@@ -0,0 +1,2196 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+"""
+cace_gensim.py
+This is the main part of the automatic characterization engine. It takes
+a JSON simulation template file as input and parses it for information on
+how to construct files for the characterization simulations. Output is
+a number of simulation files (for now, at least, in ng-spice format).
+
+Usage:
+
+cace_gensim.py [<root_path>] [<option> ...]
+
+ <root_path> is the root of all the other path names, if the other
+ path names are not full paths. If the other pathnames are all
+ full paths, then <root_path> may be omitted.
+
+options:
+
+ -simdir <path>
+ is the location where simulation files and data should be placed.
+ -datasheetdir <path>
+ is the location of the JSON file describing the characterization
+ -testbenchdir <path>
+ is the location of the netlists for the characterization methods
+ -designdir <path>
+ is the location of the netlist for the device-under-test
+ -layoutdir <path>
+ is the location of the layout netlist for the device-under-test
+ -datasheet <name>
+ is the name of the datasheet JSON file
+ -method <name>, ...
+ is a list of one or more names of methods to simulate. If omitted,
+ all methods are run for a complete characterization.
+ -local
+ indicates that cace_gensim is being run locally, not on the CACE
+ server, simulation conditions should be output along with results;
+ 'local' mode implies that results are not posted to the marketplace
+ after simulation, and result files are kept.
+ -bypass
+ acts like remote CACE by running all simulations in one batch and
+ posting to the marketplace. Does not generate status reports.
+ -keep
+ test mode: keep all files after simulation
+ -plot
+ test mode: generate plot (.png) files locally
+ -nopost
+ test mode: do not post results to the marketplace
+ -nosim
+ test mode: set up all files for simulation but do not simulate
+
+Quick local run---Use:
+
+ cace_gensim.py <root_dir> -local -method=<method_name>
+
+e.g.,
+
+ cace_gensim.py ~/design/XBG_1V23LC_V01 -local -method=DCVOLTAGE_VBG.1
+"""
+
+import os
+import sys
+import json
+import re
+import time
+import shutil
+import signal
+import datetime
+import subprocess
+import faulthandler
+from functools import reduce
+from spiceunits import spice_unit_convert
+from fix_libdirs import fix_libdirs
+
+import og_config
+
+# Values obtained from og_config:
+#
+apps_path = og_config.apps_path
+launchproc = []
+
+def construct_dut_from_path(pname, pathname, pinlist, foundry, node):
+ # Read the indicated file, find the .subckt line, and copy out the
+ # pin names and DUT name. Complain if pin names don't match pin names
+ # in the datasheet.
+ # NOTE: There may be more than one subcircuit in the netlist, so
+ # insist upon the actual DUT (pname)
+
+ subrex = re.compile('^[^\*]*[ \t]*.subckt[ \t]+(.*)$', re.IGNORECASE)
+ noderex = re.compile('\*\*\* Layout tech:[ \t]+([^ \t,]+),[ \t]+foundry[ \t]+([^ \t]+)', re.IGNORECASE)
+ outline = ""
+ dutname = ""
+ if not os.path.isfile(pathname):
+ print('Error: No design netlist file ' + pathname + ' found.')
+ return outline
+
+ # First pull in all lines of the file and concatenate all continuation
+ # lines.
+ with open(pathname, 'r') as ifile:
+ duttext = ifile.read()
+
+ dutlines = duttext.replace('\n+', ' ').splitlines()
+ found = 0
+ for line in dutlines:
+ lmatch = noderex.match(line)
+ if lmatch:
+ nlnode = lmatch.group(1)
+ nlfoundry = lmatch.group(2)
+ if nlfoundry != foundry:
+ print('Error: Foundry is ' + foundry + ' in spec sheet, ' + nlfoundry + ' in netlist.')
+ # Not yet fixed in Electric
+ ## return ""
+ if nlnode != node:
+ # Hack for legacy node name
+ if nlnode == 'XH035A' and node == 'XH035':
+ pass
+ else:
+ print('Error: Node is ' + node + ' in spec sheet, ' + nlnode + ' in netlist.')
+ # Not yet fixed in Electric
+ ## return ""
+ lmatch = subrex.match(line)
+ if lmatch:
+ rest = lmatch.group(1)
+ tokens = rest.split()
+ dutname = tokens[0]
+ if dutname == pname:
+ outline = outline + 'X' + dutname + ' '
+ for pin in tokens[1:]:
+ upin = pin.upper()
+ try:
+ pinmatch = next(item for item in pinlist if item['name'].upper() == upin)
+ except StopIteration:
+ # Maybe this is not the DUT?
+ found = 0
+ # Try the next line
+ break
+ else:
+ outline = outline + pin + ' '
+ found += 1
+
+ if found == 0 and dutname == "":
+ print('File ' + pathname + ' does not contain any subcircuits!')
+ raise SyntaxError('File ' + pathname + ' does not contain any subcircuits!')
+ elif found == 0:
+ if dutname != pname:
+ print('File ' + pathname + ' does not have a subcircuit named ' + pname + '!')
+ raise SyntaxError('File ' + pathname + ' does not have a subcircuit named ' + pname + '!')
+ else:
+ print('Pins in schematic: ' + str(tokens[1:]))
+ print('Pins in datasheet: ', end='')
+ for pin in pinlist:
+ print(pin['name'] + ' ', end='')
+ print('')
+ print('File ' + pathname + ' subcircuit ' + pname + ' does not have expected pins!')
+ raise SyntaxError('File ' + pathname + ' subcircuit ' + pname + ' does not have expected pins!')
+ elif found != len(pinlist):
+ print('File ' + pathname + ' does not contain the project DUT ' + pname)
+ print('or not all pins of the DUT were found.')
+ print('Pinlist is : ', end='')
+ for pinrec in pinlist:
+ print(pinrec['name'] + ' ', end='')
+ print('')
+
+ print('Length of pinlist is ' + str(len(pinlist)))
+ print('Number of pins found in subcircuit call is ' + str(found))
+ raise SyntaxError('File ' + pathname + ' does not contain the project DUT!')
+ else:
+ outline = outline + dutname + '\n'
+ return outline
+
+conditiontypes = {
+ "VOLTAGE": 1,
+ "DIGITAL": 2,
+ "CURRENT": 3,
+ "RISETIME": 4,
+ "FALLTIME": 5,
+ "RESISTANCE": 6,
+ "CAPACITANCE": 7,
+ "TEMPERATURE": 8,
+ "FREQUENCY": 9,
+ "CORNER": 10,
+ "SIGMA": 11,
+ "ITERATIONS": 12,
+ "TIME": 13
+}
+
+# floating-point numeric sequence generators, to be used with condition generator
+
+def linseq(condition, unit, start, stop, step):
+ a = float(start)
+ e = float(stop)
+ s = float(step)
+ while (a < e + s):
+ if (a > e):
+ yield (condition, unit, stop)
+ else:
+ yield (condition, unit, str(a))
+ a = a + s
+
+def logseq(condition, unit, start, stop, step):
+ a = float(start)
+ e = float(stop)
+ s = float(step)
+ while (a < e * s):
+ if (a > e):
+ yield (condition, unit, stop)
+ else:
+ yield (condition, unit, str(a))
+ a = a * s
+
+# binary (integer) numeric sequence generators, to be used with condition generator
+
+def bindigits(n, bits):
+ s = bin(n & int("1" * bits, 2))[2:]
+ return ("{0:0>%s}" % (bits)).format(s)
+
+def twos_comp(val, bits):
+ """compute the 2's compliment of int value val"""
+ if (val & (1 << (bits - 1))) != 0: # if sign bit is set e.g., 8bit: 128-255
+ val = val - (1 << bits) # compute negative value
+ return val # return positive value as is
+
+def bcount(condition, unit, start, stop, step):
+ blen = len(start)
+ a = eval('0b' + start)
+ e = eval('0b' + stop)
+ if a > e:
+ a = twos_comp(a, blen)
+ e = twos_comp(e, blen)
+ s = int(step)
+ while (a < e + s):
+ if (a > e):
+ bstr = bindigits(e, blen)
+ else:
+ bstr = bindigits(a, blen)
+ yield (condition, unit, bstr)
+ a = a + s
+
+def bshift(condition, unit, start, stop, step):
+ a = eval('0b' + start)
+ e = eval('0b' + stop)
+ if a > e:
+ a = twos_comp(a, blen)
+ e = twos_comp(e, blen)
+ s = int(step)
+ while (a < e * s):
+ if (a > e):
+ bstr = bindigits(e, blen)
+ else:
+ bstr = bindigits(a, blen)
+ yield (condition, unit, bstr)
+ a = a * s
+
+# define a generator for conditions. Given a condition (dictionary),
+# return (as a yield) each specified condition as a
+# 3-tuple (condition_type, value, unit)
+
+def condition_gen(cond):
+ lcond = cond['condition']
+ if "unit" in cond:
+ unit = cond['unit']
+ else:
+ unit = ''
+
+ if "enum" in cond:
+ for i in cond["enum"]:
+ yield(lcond, unit, i)
+ elif "min" in cond and "max" in cond and "linstep" in cond:
+ if unit == "'b" or lcond.split(':', 1)[0] == 'DIGITAL':
+ yield from bcount(lcond, unit, cond["min"], cond["max"], cond["linstep"])
+ else:
+ yield from linseq(lcond, unit, cond["min"], cond["max"], cond["linstep"])
+ elif "min" in cond and "max" in cond and "logstep" in cond:
+ if unit == "'b" or lcond.split(':', 1)[0] == 'DIGITAL':
+ yield from bshift(lcond, unit, cond["min"], cond["max"], cond["logstep"])
+ else:
+ yield from logseq(lcond, unit, cond["min"], cond["max"], cond["logstep"])
+ elif "min" in cond and "max" in cond and "typ" in cond:
+ yield(lcond, unit, cond["min"])
+ yield(lcond, unit, cond["typ"])
+ yield(lcond, unit, cond["max"])
+ elif "min" in cond and "max" in cond:
+ yield(lcond, unit, cond["min"])
+ yield(lcond, unit, cond["max"])
+ elif "min" in cond and "typ" in cond:
+ yield(lcond, unit, cond["min"])
+ yield(lcond, unit, cond["typ"])
+ elif "max" in cond and "typ" in cond:
+ yield(lcond, unit, cond["typ"])
+ yield(lcond, unit, cond["max"])
+ elif "min" in cond:
+ yield(lcond, unit, cond["min"])
+ elif "max" in cond:
+ yield(lcond, unit, cond["max"])
+ elif "typ" in cond:
+ yield(lcond, unit, cond["typ"])
+
+# Find the maximum time to run a simulation. This is the maximum of:
+# (1) maximum value, if method is RISETIME or FALLTIME, and (2) maximum
+# RISETIME or FALLTIME of any condition.
+#
+# "lcondlist" is the list of local conditions extended by the list of
+# all global conditions that are not overridden by local values.
+#
+# NOTE: This list is limited to rise and fall time values, as they are
+# the only time constraints known to cace_gensim at this time. This list
+# will be extended as more simulation methods are added.
+
+def findmaxtime(param, lcondlist):
+ maxtime = 0.0
+ try:
+ simunit = param['unit']
+ except KeyError:
+ # Plots has no min/max/typ so doesn't require units.
+ if 'plot' in param:
+ return maxtime
+
+ maxval = 0.0
+ found = False
+ if 'max' in param:
+ prec = param['max']
+ if 'target' in prec:
+ pmax = prec['target']
+ try:
+ maxval = float(spice_unit_convert([simunit, pmax], 'time'))
+ found = True
+ except:
+ pass
+ if not found and 'typ' in param:
+ prec = param['typ']
+ if 'target' in prec:
+ ptyp = prec['target']
+ try:
+ maxval = float(spice_unit_convert([simunit, ptyp], 'time'))
+ found = True
+ except:
+ pass
+ if not found and 'min' in param:
+ prec = param['min']
+ if 'target' in prec:
+ pmin = prec['target']
+ try:
+ maxval = float(spice_unit_convert([simunit, pmin], 'time'))
+ found = True
+ except:
+ pass
+ if maxval > maxtime:
+ maxtime = maxval
+ for cond in lcondlist:
+ condtype = cond['condition'].split(':', 1)[0]
+ # print ('condtype ' + condtype)
+ if condtype == 'RISETIME' or condtype == 'FALLTIME':
+ condunit = cond['unit']
+ maxval = 0.0
+ if 'max' in cond:
+ maxval = float(spice_unit_convert([condunit, cond['max']], 'time'))
+ elif 'enum' in cond:
+ maxval = float(spice_unit_convert([condunit, cond['enum'][-1]], 'time'))
+ elif 'typ' in cond:
+ maxval = float(spice_unit_convert([condunit, cond['typ']], 'time'))
+ elif 'min' in cond:
+ maxval = float(spice_unit_convert([condunit, cond['min']], 'time'))
+ if maxval > maxtime:
+ maxtime = maxval
+
+ return maxtime
+
+# Picked up from StackOverflow: Procedure to remove non-unique entries
+# in a list of lists (as always, thanks StackOverflow!).
+
+def uniquify(seq):
+ seen = set()
+ return [x for x in seq if str(x) not in seen and not seen.add(str(x))]
+
+# Insert hints that have been selected in the characterization tool for
+# aid in getting stubborn simulations to converge, or to avoid failures
+# due to floating nodes, etc. The hints are somewhat open-ended and can
+# be extended as needed. NOTE: Hint "method" selects the parameter
+# method and is handled outside this routine, which only adds lines to
+# the simulation netlist.
+
+def insert_hints(param, ofile):
+ if 'hints' in param:
+ phints = param['hints']
+ if 'reltol' in phints:
+ value = phints['reltol']
+ ofile.write('.options reltol = ' + value + '\n')
+ if 'rshunt' in phints:
+ value = phints['rshunt']
+ ofile.write('.options rshunt = ' + value + '\n')
+ if 'itl1' in phints:
+ value = phints['itl1']
+ ofile.write('.options itl1 = ' + value + '\n')
+ if 'nodeset' in phints:
+ value = phints['nodeset']
+ # replace '/' in nodeset with '|' to match character replacement done
+ # on the output of magic.
+ ofile.write('.nodeset ' + value.replace('/', '|') + '\n')
+ if 'include' in phints:
+ value = phints['include']
+ ofile.write('.include ' + value + '\n')
+
+# Replace the substitution token ${INCLUDE_DUT} with the contents of the DUT subcircuit
+# netlist file. "functional" is a list of IP block names that are to be searched for in
+# .include lines in the netlist and replaced with functional view equivalents (if such
+# exist).
+
+def inline_dut(filename, functional, rootpath, ofile):
+ comtrex = re.compile(r'^\*') # SPICE comment
+ inclrex = re.compile(r'[ \t]*\.include[ \t]+["\']?([^"\' \t]+)["\']?', re.IGNORECASE) # SPICE include statement
+ braktrex = re.compile(r'([^ \t]+)\[([^ \t])\]', re.IGNORECASE) # Node name with brackets
+ subcrex = re.compile(r'[ \t]*x([^ \t]+)[ \t]+(.*)$', re.IGNORECASE) # SPICE subcircuit line
+ librex = re.compile(r'(.*)__(.*)', re.IGNORECASE)
+ endrex = re.compile(r'[ \t]*\.end[ \t]*', re.IGNORECASE)
+ endsrex = re.compile(r'[ \t]*\.ends[ \t]*', re.IGNORECASE)
+ # IP names in the ridiculously complicated form
+ # <user_path>/design/ip/<proj_name>/<version>/<spi-type>/<proj_name>/<proj_netlist>
+ ippathrex = re.compile(r'(.+)/design/ip/([^/]+)/([^/]+)/([^/]+)/([^/]+)/([^/ \t]+)')
+ locpathrex = re.compile(r'(.+)/design/([^/]+)/spi/([^/]+)/([^/ \t]+)')
+ # This form does not appear on servers but is used if an IP block is being prepared locally.
+ altpathrex = re.compile(r'(.+)/design/([^/]+)/([^/]+)/([^/]+)/([^/ \t]+)')
+ # Local IP names in the form
+ # <user_path>/design/<project>/spi/<spi-type>/<proj_netlist>
+
+ # To be completed
+ with open(filename, 'r') as ifile:
+ nettext = ifile.read()
+
+ netlines = nettext.replace('\n+', ' ').splitlines()
+ for line in netlines:
+ subsline = line
+ cmatch = comtrex.match(line)
+ if cmatch:
+ print(line, file=ofile)
+ continue
+ # Check for ".end" which should be removed (but not ".ends", which must remain)
+ ematch = endrex.match(line)
+ if ematch:
+ smatch = endsrex.match(line)
+ if not smatch:
+ continue
+ imatch = inclrex.match(line)
+ if imatch:
+ incpath = imatch.group(1)
+ # Substitution behavior is complicated due to the difference between netlist
+ # files from schematic capture vs. layout and read-only vs. read-write IP.
+ incroot = os.path.split(incpath)[1]
+ incname = os.path.splitext(incroot)[0]
+ lmatch = librex.match(incname)
+ if lmatch:
+ ipname = lmatch.group(2)
+ else:
+ ipname = incname
+ if ipname.upper() in functional:
+ # Search for functional view (depends on if this is a read-only IP or
+ # read-write local subcircuit)
+ funcpath = None
+ ippath = ippathrex.match(incpath)
+ if ippath:
+ userpath = ippath.group(1)
+ ipname2 = ippath.group(2)
+ ipversion = ippath.group(3)
+ spitype = ippath.group(4)
+ ipname3 = ippath.group(5)
+ ipnetlist = ippath.group(6)
+ funcpath = userpath + '/design/ip/' + ipname2 + '/' + ipversion + '/spi-func/' + ipname + '.spi'
+ else:
+ locpath = locpathrex.match(incpath)
+ if locpath:
+ userpath = locpath.group(1)
+ ipname2 = locpath.group(2)
+ spitype = locpath.group(3)
+ ipnetlist = locpath.group(4)
+ funcpath = userpath + '/design/' + ipname2 + '/spi/func/' + ipname + '.spi'
+ else:
+ altpath = altpathrex.match(incpath)
+ if altpath:
+ userpath = altpath.group(1)
+ ipname2 = altpath.group(2)
+ spitype = altpath.group(3)
+ ipname3 = altpath.group(4)
+ ipnetlist = altpath.group(5)
+ funcpath = userpath + '/design/' + ipname2 + '/spi/func/' + ipname + '.spi'
+
+ funcpath = os.path.expanduser(funcpath)
+ if funcpath and os.path.exists(funcpath):
+ print('Subsituting functional view for IP block ' + ipname)
+ print('Original netlist is ' + incpath)
+ print('Functional netlist is ' + funcpath)
+ subsline = '.include ' + funcpath
+ elif funcpath:
+ print('Original netlist is ' + incpath)
+ print('Functional view specified but no functional view found.')
+ print('Tried looking for ' + funcpath)
+ print('Retaining original view.')
+ else:
+ print('Original netlist is ' + incpath)
+ print('Cannot make sense of netlist path to find functional view.')
+
+ # If include file name is in <lib>__<cell> format (from electric) and the
+ # functional view is not, then find the subcircuit call and replace the
+ # subcircuit name. At least at the moment, the vice versa case does not
+ # happen.
+ smatch = subcrex.match(line)
+ if smatch:
+ subinst = smatch.group(1)
+ tokens = smatch.group(2).split()
+ # Need to test for parameters passed to subcircuit. The actual subcircuit
+ # name occurs before any parameters.
+ params = []
+ pins = []
+ for token in tokens:
+ if '=' in token:
+ params.append(token)
+ else:
+ pins.append(token)
+
+ subname = pins[-1]
+ pins = pins[0:-1]
+ lmatch = librex.match(subname)
+ if lmatch:
+ testname = lmatch.group(1)
+ if testname.upper() in functional:
+ subsline = 'X' + subinst + ' ' + ' '.join(pins) + ' ' + testname + ' ' + ' '.join(params)
+
+ # Remove any array brackets from node names in the top-level subcircuit, because they
+ # interfere with the array notation used by XSPICE which may be present in functional
+ # views (replace bracket characters with underscores).
+ # subsline = subsline.replace('[', '_').replace(']', '_')
+ #
+ # Do this *only* when there are no spaces inside the brackets, or else any XSPICE
+ # primitives in the netlist containing arrays will get messed up.
+ subsline = braktrex.sub(r'\1_\2_', subsline)
+
+ ofile.write(subsline + '\n')
+
+ ofile.write('\n')
+
+# Define how to write a simulation file by making substitutions into a
+# template schematic.
+
+def substitute(filename, fileinfo, template, simvals, maxtime, schemline,
+ localmode, param):
+ """Simulation derived by substitution into template schematic"""
+
+ # Regular expressions
+ varex = re.compile(r'(\$\{[^ \}\t]+\})') # variable name ${name}
+ defaultex = re.compile(r'\$\{([^=]+)=([^=\}]+)\}') # name in ${name=default} format
+ condpinex = re.compile(r'\$\{([^:]+):([^:\}]+)\}') # name in ${cond:pin} format
+ condex = re.compile(r'\$\{([^\}]+)\}') # name in ${cond} format
+ sweepex = re.compile(r'\$\{([^\}]+):SWEEP([^\}]+)\}') # name in ${cond:[pin:]sweep} format
+ pinex = re.compile(r'PIN:([^:]+):([^:]+)') # name in ${PIN:pin_name:net_name} format
+ funcrex = re.compile(r'FUNCTIONAL:([^:]+)') # name in ${FUNCTIONAL:ip_name} format
+ colonsepex = re.compile(r'^([^:]+):([^:]+)$') # a:b (colon-separated values)
+ vectrex = re.compile(r'([^\[]+)\[([0-9]+)\]') # pin name is a vector signal
+ vect2rex = re.compile(r'([^<]+)<([0-9]+)>') # pin name is a vector signal (alternate style)
+ libdirrex = re.compile(r'.lib[ \t]+(.*)[ \t]+') # pick up library name from .lib
+ vinclrex = re.compile(r'[ \t]*`include[ \t]+"([^"]+)"') # verilog include statement
+
+ # Information about the DUT
+ simfilepath = fileinfo['simulation-path']
+ schempath = fileinfo['design-netlist-path']
+ schemname = fileinfo['design-netlist-name']
+ testbenchpath = fileinfo['testbench-netlist-path']
+ rootpath = fileinfo['root-path']
+ schempins = schemline.upper().split()[1:-1]
+ simpins = [None] * len(schempins)
+
+ suffix = os.path.splitext(template)[1]
+ functional = []
+
+ # Read ifile into a list
+ # Concatenate any continuation lines
+ with open(template, 'r') as ifile:
+ simtext = ifile.read()
+
+ simlines = simtext.replace('\n+', ' ').splitlines()
+
+ # Make initial pass over contents of template file, looking for SWEEP
+ # entries, and collapse simvals accordingly.
+
+ sweeps = []
+ for line in simlines:
+ sublist = sweepex.findall(line)
+ for pattern in sublist:
+ condition = pattern[0]
+ try:
+ entry = next(item for item in sweeps if item['condition'] == condition)
+ except (StopIteration, KeyError):
+ print("Did not find condition " + condition + " in sweeps.")
+ print("Pattern = " + str(pattern))
+ print("Sublist = " + str(sublist))
+ print("Sweeps = " + str(sweeps))
+ entry = {'condition':condition}
+ sweeps.append(entry)
+
+ # Find each entry in simvals with the same condition.
+ # Record the minimum, maximum, and step for substitution, at the same
+ # time removing that item from the entry.
+ lvals = []
+ units = ''
+ for simval in simvals:
+ try:
+ simrec = next(item for item in simval if item[0] == condition)
+ except StopIteration:
+ print('No condition = ' + condition + ' in record:\n')
+ ptext = str(simval) + '\n'
+ sys.stdout.buffer.write(ptext.encode('utf-8'))
+ else:
+ units = simrec[1]
+ lvals.append(float(simrec[2]))
+ simval.remove(simrec)
+
+ # Remove non-unique entries from lvals
+ lvals = list(set(lvals))
+
+ # Now parse lvals for minimum/maximum
+ entry['unit'] = units
+ minval = min(lvals)
+ maxval = max(lvals)
+ entry['START'] = str(minval)
+ entry['END'] = str(maxval)
+ numvals = len(lvals)
+ if numvals > 1:
+ entry['STEPS'] = str(numvals)
+ entry['STEP'] = str((maxval - minval) / (numvals - 1))
+ else:
+ entry['STEPS'] = "1"
+ entry['STEP'] = str(minval)
+
+ # Remove non-unique entries from simvals
+ simvals = uniquify(simvals)
+
+ simnum = 0
+ testbenches = []
+ for simval in simvals:
+ # Create the file
+ simnum += 1
+ simfilename = simfilepath + '/' + filename + '_' + str(simnum) + suffix
+ controlblock = False
+ with open(simfilename, 'w') as ofile:
+ for line in simlines:
+
+ # Check if the parser is in the ngspice control block section
+ if '.control' in line:
+ controlblock = True
+ elif '.endc' in line:
+ controlblock = False
+ elif controlblock == True:
+ ofile.write('set sqrnoise\n')
+ # This will need to be more nuanced if controlblock is used
+ # to do more than just insert the noise sim hack.
+ controlblock = False
+
+ # This will be replaced
+ subsline = line
+
+ # Find all variables to substitute
+ for patmatch in varex.finditer(line):
+ pattern = patmatch.group(1)
+ # If variable is in ${x=y} format, it declares a default value
+ # Remove the =y default part and keep it for later if needed.
+ defmatch = defaultex.match(pattern)
+ if defmatch:
+ default = defmatch.group(2)
+ vpattern = '${' + defmatch.group(1) + '}'
+ else:
+ default = []
+ vpattern = pattern
+
+ repl = []
+ no_repl_ok = False
+ sweeprec = sweepex.match(vpattern)
+ if sweeprec:
+ sweeptype = sweeprec.group(2)
+ condition = sweeprec.group(1)
+
+ entry = next(item for item in sweeps if item['condition'] == condition)
+ uval = spice_unit_convert((entry['unit'], entry[sweeptype]))
+ repl = str(uval)
+ else:
+ cond = condex.match(vpattern)
+ if cond:
+ condition = cond.group(1)
+
+ # Check if the condition contains a pin vector
+ lmatch = vectrex.match(condition)
+ if lmatch:
+ pinidx = int(lmatch.group(2))
+ vcondition = lmatch.group(1)
+ else:
+ lmatch = vect2rex.match(condition)
+ if lmatch:
+ pinidx = int(lmatch.group(2))
+ vcondition = lmatch.group(1)
+
+ try:
+ entry = next((item for item in simval if item[0] == condition))
+ except (StopIteration, KeyError):
+ # check against known names (to-do: change if block to array of procs)
+ if condition == 'N':
+ repl = str(simnum)
+ elif condition == 'MAXTIME':
+ repl = str(maxtime)
+ elif condition == 'STEPTIME':
+ repl = str(maxtime / 100)
+ elif condition == 'DUT_PATH':
+ repl = schempath + '/' + schemname + '\n'
+ # DUT_PATH is required and is a good spot to
+ # insert hints (but deprecated in fafor of INCLUDE_DUT)
+ insert_hints(param, ofile)
+ elif condition == 'INCLUDE_DUT':
+ if len(functional) == 0:
+ repl = '.include ' + schempath + '/' + schemname + '\n'
+ else:
+ inline_dut(schempath + '/' + schemname, functional, rootpath, ofile)
+ repl = '** End of in-line DUT subcircuit'
+ insert_hints(param, ofile)
+ elif condition == 'DUT_CALL':
+ repl = schemline
+ elif condition == 'DUT_NAME':
+ # This verifies pin list of schematic vs. the netlist.
+ repl = schemline.split()[-1]
+ elif condition == 'FILENAME':
+ repl = filename
+ elif condition == 'RANDOM':
+ repl = str(int(time.time() * 1000) & 0x7fffffff)
+ # Stack math operators. Perform specified math
+ # operation on the last two values and replace.
+ #
+ # Note that ngspice is finicky about space around "=" so
+ # handle this in a way that keeps ngspice happy.
+ elif condition == '+':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(float(ltok[-2]) + float(ltok[-1])))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition == '-':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(float(ltok[-2]) - float(ltok[-1])))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition == '*':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(float(ltok[-2]) * float(ltok[-1])))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition == '/':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(float(ltok[-2]) / float(ltok[-1])))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition == 'MAX':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(max(float(ltok[-2]), float(ltok[-1]))))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition == 'MIN':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-2]
+ ntok.append(str(min(float(ltok[-2]), float(ltok[-1]))))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ # 'NEG' acts on only the previous value in the string.
+ elif condition == 'NEG':
+ smatch = varex.search(subsline)
+ watchend = smatch.start()
+ ltok = subsline[0:watchend].replace('=', ' = ').split()
+ ntok = ltok[:-1]
+ ntok.append(str(-float(ltok[-1])))
+ subsline = ' '.join(ntok).replace(' = ', '=') + line[patmatch.end():]
+ repl = ''
+ no_repl_ok = True
+ elif condition.find('PIN:') == 0:
+ # Parse for ${PIN:<pin_name>:<net_name>}
+ # Replace <pin_name> with index of pin from DUT subcircuit
+ pinrec = pinex.match(condition)
+ pinname = pinrec.group(1).upper()
+ netname = pinrec.group(2).upper()
+ try:
+ idx = schempins.index(pinname)
+ except ValueError:
+ repl = netname
+ else:
+ repl = '${PIN}'
+ simpins[idx] = netname
+ elif condition.find('FUNCTIONAL:') == 0:
+ # Parse for ${FUNCTIONAL:<ip_name>}
+ # Add <ip_name> to "functional" array.
+ # 'FUNCTIONAL' declarations must come before 'INCLUDE_DUT' or else
+ # substitution will not be made. 'INCLUDE_DUT' must be used in place
+ # of 'DUT_PATH' to get the correct behavior.
+ funcrec = funcrex.match(condition)
+ ipname = funcrec.group(1)
+ functional.append(ipname.upper())
+ repl = '** Using functional view for ' + ipname
+ else:
+ if lmatch:
+ try:
+ entry = next((item for item in simval if item[0].split('[')[0].split('<')[0] == vcondition))
+ except:
+ # if no match, subsline remains as-is.
+ pass
+ else:
+ # Handle as vector bit slice (see below)
+ vlen = len(entry[2])
+ uval = entry[2][(vlen - 1) - pinidx]
+ repl = str(uval)
+ # else if no match, subsline remains as-is.
+
+ else:
+ if lmatch:
+ # pull signal at pinidx out of the vector.
+ # Note: DIGITAL assumes binary value. May want to
+ # allow general case of real-valued vectors, which would
+ # require a spice unit conversion routine without indexing.
+ vlen = len(entry[2])
+ uval = entry[2][(vlen - 1) - pinidx]
+ else:
+ uval = spice_unit_convert(entry[1:])
+ repl = str(uval)
+
+ if not repl and default:
+ # Use default if no match was found and default was specified
+ repl = default
+
+ if repl:
+ # Make the variable substitution
+ subsline = subsline.replace(pattern, repl)
+ elif not no_repl_ok:
+ print('Warning: Variable ' + pattern + ' had no substitution')
+
+ # Check if ${PIN} are in line. If so, order by index and
+ # rewrite pins in order
+ for i in range(len(simpins)):
+ if '${PIN}' in subsline:
+ if simpins[i]:
+ subsline = subsline.replace('${PIN}', simpins[i], 1)
+ else:
+ print("Error: simpins is " + str(simpins) + '\n')
+ print(" subsline is " + subsline + '\n')
+ print(" i is " + str(i) + '\n')
+
+ # Check for a verilog include file, and if any is found, copy it
+ # to the target simulation directory. Replace any leading path
+ # with the local current working directory '.'.
+ vmatch = vinclrex.match(subsline)
+ if vmatch:
+ incfile = vmatch.group(1)
+ incroot = os.path.split(incfile)[1]
+ curpath = os.path.split(template)[0]
+ incpath = os.path.abspath(os.path.join(curpath, incfile))
+ shutil.copy(incpath, simfilepath + '/' + incroot)
+ subsline = ' `include "./' + incroot + '"'
+
+ # Write the modified output line (with variable substitutions)
+ ofile.write(subsline + '\n')
+
+ # Add information about testbench file and conditions to datasheet JSON,
+ # which can be parsed by cace_launch.py.
+ testbench = {}
+ testbench['filename'] = simfilename
+ testbench['prefix'] = filename
+ testbench['conditions'] = simval
+ testbenches.append(testbench)
+
+ return testbenches
+
+# Define how to write simulation devices
+
+def generate_simfiles(datatop, fileinfo, arguments, methods, localmode):
+
+ # pull out the relevant part, which is "data-sheet"
+ dsheet = datatop['data-sheet']
+
+ # grab values held in 'fileinfo'
+ testbenchpath = fileinfo['testbench-netlist-path']
+
+ # electrical parameter list comes from "methods" if non-NULL.
+ # Otherwise, each entry in 'methods' is checked against the
+ # electrical parameters.
+
+ if 'electrical-params' in dsheet:
+ eparamlist = dsheet['electrical-params']
+ else:
+ eparamlist = []
+ if 'physical-params' in dsheet:
+ pparamlist = dsheet['physical-params']
+ else:
+ pparamlist = []
+
+ # If specific methods are called out for simulation using option "-method=", then
+ # generate the list of electrical parameters for those methods only.
+
+ if methods:
+ neweparamlist = []
+ newpparamlist = []
+ for method in methods:
+ # If method is <methodname>.<index>, simulate only the <index>th instance of
+ # the method.
+ if '.' in method:
+ (method, index) = method.split('.')
+ else:
+ index = []
+
+ if method == 'physical':
+ usedmethods = list(item for item in pparamlist if item['condition'] == index)
+ if not usedmethods:
+ print('Unknown parameter ' + index + ' requested in options. Ignoring.\n')
+ for used in usedmethods:
+ newpparamlist.append(used)
+
+ else:
+ usedmethods = list(item for item in eparamlist if item['method'] == method)
+ if not usedmethods:
+ print('Unknown method ' + method + ' requested in options. Ignoring.\n')
+ if index:
+ neweparamlist.append(usedmethods[int(index)])
+ else:
+ for used in usedmethods:
+ neweparamlist.append(used)
+
+ if not neweparamlist and not newpparamlist:
+ print('Warning: No valid methods given as options, so no simulations will be done.\n')
+ if neweparamlist:
+ for param in neweparamlist:
+ if 'display' in param:
+ ptext = 'Simulating parameter: ' + param['display'] + ' (' + param['method'] + ')\n'
+ else:
+ ptext = 'Simulating method: ' + param['method'] + '\n'
+ sys.stdout.buffer.write(ptext.encode('utf-8'))
+ eparamlist = neweparamlist
+ if newpparamlist:
+ for param in newpparamlist:
+ if 'display' in param:
+ ptext = 'Checking parameter: ' + param['display'] + ' (' + param['condition'] + ')\n'
+ else:
+ ptext = 'Checking parameter: ' + param['condition'] + '\n'
+ sys.stdout.buffer.write(ptext.encode('utf-8'))
+ pparamlist = newpparamlist
+
+ # Diagnostic
+ # print('pparamlist:')
+ # for param in pparamlist:
+ # ptext = param['condition'] + '\n'
+ # sys.stdout.buffer.write(ptext.encode('utf-8'))
+ # print('eparamlist:')
+ # for param in eparamlist:
+ # ptext = param['method'] + '\n'
+ # sys.stdout.buffer.write(ptext.encode('utf-8'))
+
+ # major subcategories of "data-sheet"
+ gcondlist = dsheet['global-conditions']
+
+ # Make a copy of the pin list in the datasheet, and expand any vectors.
+ pinlist = []
+ vectrex = re.compile(r"([^\[]+)\[([0-9]+):([0-9]+)\]")
+ vect2rex = re.compile(r"([^<]+)\<([0-9]+):([0-9]+)\>")
+ for pinrec in dsheet['pins']:
+ vmatch = vectrex.match(pinrec['name'])
+ if vmatch:
+ pinname = vmatch.group(1)
+ pinmin = vmatch.group(2)
+ pinmax = vmatch.group(3)
+ if int(pinmin) > int(pinmax):
+ pinmin = vmatch.group(3)
+ pinmax = vmatch.group(2)
+ for i in range(int(pinmin), int(pinmax) + 1):
+ newpinrec = pinrec.copy()
+ pinlist.append(newpinrec)
+ newpinrec['name'] = pinname + '[' + str(i) + ']'
+ else:
+ vmatch = vect2rex.match(pinrec['name'])
+ if vmatch:
+ pinname = vmatch.group(1)
+ pinmin = vmatch.group(2)
+ pinmax = vmatch.group(3)
+ if int(pinmin) > int(pinmax):
+ pinmin = vmatch.group(3)
+ pinmax = vmatch.group(2)
+ for i in range(int(pinmin), int(pinmax) + 1):
+ newpinrec = pinrec.copy()
+ pinlist.append(newpinrec)
+ newpinrec['name'] = pinname + '<' + str(i) + '>'
+ else:
+ pinlist.append(pinrec)
+
+ # Make sure all local conditions define a pin. Those that are not
+ # associated with a pin will have a null string for the pin name.
+
+ for cond in gcondlist:
+ # Convert old style (separate condition, pin) to new style
+ if 'pin' in cond and cond['pin'] != '':
+ if ':' not in cond['condition']:
+ cond['condition'] += ':' + cond['pin']
+ cond.pop('pin', 0)
+ if 'order' not in cond:
+ try:
+ cond['order'] = conditiontypes[cond['condition']]
+ except:
+ cond['order'] = 0
+
+ # Find DUT netlist file and capture the subcircuit call line
+ schempath = fileinfo['design-netlist-path']
+ schemname = fileinfo['design-netlist-name']
+ pname = fileinfo['project-name']
+ dutpath = schempath + '/' + schemname
+ foundry = dsheet['foundry']
+ node = dsheet['node']
+ try:
+ schemline = construct_dut_from_path(pname, dutpath, pinlist, foundry, node)
+ except SyntaxError:
+ print("Failure to construct a DUT subcircuit. Does the design have ports?")
+ schemline = ''
+
+ if schemline == '':
+ # Error finding DUT file. If only physical parameters are requested, this may
+ # not be a failure (e.g., chip top level)
+ if len(eparamlist) == 0:
+ prescore = 'unknown'
+ else:
+ prescore = 'fail'
+ else:
+ prescore = 'pass'
+
+ methodsfound = {}
+
+ # electrical parameter types determine the simulation type. Simulation
+ # types will be broken into individual routines (to be done)
+
+ for param in eparamlist:
+
+ # Break out name, method, and conditions as variables
+ simtype = param['method']
+
+ # For methods with ":", the filename is the part before the colon.
+ testbench = simtype.split(":")[0]
+
+ # If hint 'method' is applied, append the value to the method name.
+ # If no such method exists, flag a warning and revert to the original.
+
+ testbench_orig = None
+ if 'hints' in param:
+ phints = param['hints']
+ if 'method' in phints:
+ testbench_orig = testbench
+ testbench += phints['method']
+
+ if testbench == simtype:
+ if arguments:
+ if simtype not in arguments:
+ continue
+
+ if simtype in methodsfound:
+ fnum = methodsfound[simtype]
+ fsuffix = '_' + str(fnum)
+ methodsfound[simtype] = fnum + 1
+ else:
+ fsuffix = '_0'
+ methodsfound[simtype] = 1
+ else:
+ if arguments:
+ if testbench not in arguments:
+ continue
+
+ if testbench in methodsfound:
+ fnum = methodsfound[testbench]
+ fsuffix = '_' + str(fnum)
+ methodsfound[testbench] = fnum + 1
+ else:
+ fsuffix = '_0'
+ methodsfound[testbench] = 1
+
+ lcondlist = param['conditions']
+
+ # Make sure all local conditions which define a pin are in condition:pin form
+
+ for cond in lcondlist:
+ if 'pin' in cond and cond['pin'] != '':
+ if not ':' in cond['condition']:
+ cond['condition'] += ':' + cond['pin']
+ cond.pop('pin', 0)
+ if "order" not in cond:
+ if cond["condition"].split(':', 1)[0] in conditiontypes:
+ cond["order"] = conditiontypes[cond["condition"].split(':', 1)[0]]
+ else:
+ cond["order"] = 14
+
+ # Append to lcondlist any global conditions that aren't overridden by
+ # local values for the electrical parameter's set of conditions.
+
+ grec = []
+ for cond in gcondlist:
+ try:
+ test = next((item for item in lcondlist if item["condition"] == cond["condition"]))
+ except StopIteration:
+ grec.append(cond)
+
+ lcondlist.extend(grec) # Note this will permanently alter lcondlist
+
+ # Find the maximum simulation time required by this method
+ # Simulations are ordered so that "risetime" and "falltime" simulations
+ # on a pin will set the simulation time of any simulation of any other
+ # electrical parameter on that same pin.
+
+ maxtime = findmaxtime(param, lcondlist)
+ print("maxtime is " + str(maxtime))
+
+ # Sort the list for output conditions, ordering according to 'conditiontypes'.
+
+ list.sort(lcondlist, key=lambda k: k['order'])
+
+ # Find the length of each generator
+ cgenlen = []
+ for cond in lcondlist:
+ cgenlen.append(len(list(condition_gen(cond))))
+
+ # The lengths of all generators multiplied together is the number of
+ # simulations to be run
+ numsims = reduce(lambda x, y: x * y, cgenlen)
+ rlen = [x for x in cgenlen] # note floor division operator
+
+ # This code repeats each condition as necessary such that the final list
+ # (transposed) is a complete set of unique condition combinations.
+ cgensim = []
+ for i in range(len(rlen)):
+ mpre = reduce(lambda x, y: x * y, rlen[0:i], 1)
+ mpost = reduce(lambda x, y: x * y, rlen[i + 1:], 1)
+ clist = list(condition_gen(lcondlist[i]))
+ duplist = [item for item in list(condition_gen(lcondlist[i])) for j in range(mpre)]
+ cgensim.append(duplist * mpost)
+
+ # Transpose this list
+ simvals = list(map(list, zip(*cgensim)))
+
+ # Generate filename prefix for this electrical parameter
+ filename = testbench + fsuffix
+
+ # If methodtype is the name of a schematic netlist, then use
+ # it and make substitutions
+ # NOTE: Schematic methods are bundled with the DUT schematic
+
+ template = testbenchpath + '/' + testbench.lower() + '.spi'
+
+ if testbench_orig and not os.path.isfile(template):
+ print('Warning: Alternate testbench ' + testbench + ' cannot be found.')
+ print('Reverting to original testbench ' + testbench_orig)
+ testbench = testbench_orig
+ filename = testbench + fsuffix
+ template = testbenchpath + '/' + testbench.lower() + '.spi'
+
+ if os.path.isfile(template):
+ param['testbenches'] = substitute(filename, fileinfo, template,
+ simvals, maxtime, schemline, localmode, param)
+
+ # For cosimulations, if there is a '.tv' file corresponding to the '.spi' file,
+ # then make substitutions as for the .spi file, and place in characterization
+ # directory.
+
+ vtemplate = testbenchpath + '/' + testbench.lower() + '.tv'
+ if os.path.isfile(vtemplate):
+ substitute(filename, fileinfo, vtemplate,
+ simvals, maxtime, schemline, localmode, param)
+
+ else:
+ print('Error: No testbench file ' + template + '.')
+
+ for param in pparamlist:
+ # Break out name, method, and conditions as variables
+ cond = param['condition']
+ simtype = 'physical.' + cond
+
+ if arguments:
+ if simtype not in arguments:
+ continue
+
+ if simtype in methodsfound:
+ fnum = methodsfound[simtype]
+ fsuffix = '_' + str(fnum)
+ methodsfound[simtype] = fnum + 1
+ else:
+ fsuffix = '_0'
+ methodsfound[simtype] = 1
+
+ # Mark parameter as needing checking by cace_launch.
+ param['check'] = 'true'
+
+ # Remove "order" keys
+ for param in eparamlist:
+ lcondlist = param['conditions']
+ for cond in lcondlist:
+ cond.pop('order', 0)
+ gconds = dsheet['global-conditions']
+ for cond in gconds:
+ cond.pop('order', 0)
+
+ return prescore
+
+def check_layout_out_of_date(spipath, layoutpath):
+ # Check if a netlist (spipath) is out-of-date relative to the layouts
+ # (layoutpath). Need to read the netlist and check all of the subcells.
+ need_capture = False
+ if not os.path.isfile(spipath):
+ need_capture = True
+ elif not os.path.isfile(layoutpath):
+ need_capture = True
+ else:
+ spi_statbuf = os.stat(spipath)
+ lay_statbuf = os.stat(layoutpath)
+ if spi_statbuf.st_mtime < lay_statbuf.st_mtime:
+ # netlist exists but is out-of-date
+ need_capture = True
+ else:
+ # only found that the top-level-layout is older than the
+ # netlist. Now need to read the netlist, find all subcircuits,
+ # and check those dates, too.
+ layoutdir = os.path.split(layoutpath)[0]
+ subrex = re.compile('^[^\*]*[ \t]*.subckt[ \t]+([^ \t]+).*$', re.IGNORECASE)
+ with open(spipath, 'r') as ifile:
+ duttext = ifile.read()
+ dutlines = duttext.replace('\n+', ' ').splitlines()
+ for line in dutlines:
+ lmatch = subrex.match(line)
+ if lmatch:
+ subname = lmatch.group(1)
+ sublayout = layoutdir + '/' + subname + '.mag'
+ # subcircuits that cannot be found in the current directory are
+ # assumed to be library components and therefore never out-of-date.
+ if os.path.exists(sublayout):
+ sub_statbuf = os.stat(sublayout)
+ if spi_statbuf.st_mtime < lay_statbuf.st_mtime:
+ # netlist exists but is out-of-date
+ need_capture = True
+ break
+ return need_capture
+
+def check_schematic_out_of_date(spipath, schempath):
+ # Check if a netlist (spipath) is out-of-date relative to the schematics
+ # (schempath). Need to read the netlist and check all of the subcells.
+ need_capture = False
+ if not os.path.isfile(spipath):
+ print('Schematic-captured netlist does not exist. Need to regenerate.')
+ need_capture = True
+ elif not os.path.isfile(schempath):
+ need_capture = True
+ else:
+ spi_statbuf = os.stat(spipath)
+ sch_statbuf = os.stat(schempath)
+ print('DIAGNOSTIC: Comparing ' + spipath + ' to ' + schempath)
+ if spi_statbuf.st_mtime < sch_statbuf.st_mtime:
+ # netlist exists but is out-of-date
+ print('Netlist is older than top-level schematic')
+ need_capture = True
+ else:
+ print('Netlist is newer than top-level schematic, but must check subcircuits')
+ # only found that the top-level-schematic is older than the
+ # netlist. Now need to read the netlist, find all subcircuits,
+ # and check those dates, too.
+ schemdir = os.path.split(schempath)[0]
+ subrex = re.compile('^[^\*]*[ \t]*.subckt[ \t]+([^ \t]+).*$', re.IGNORECASE)
+ with open(spipath, 'r') as ifile:
+ duttext = ifile.read()
+
+ dutlines = duttext.replace('\n+', ' ').splitlines()
+ for line in dutlines:
+ lmatch = subrex.match(line)
+ if lmatch:
+ subname = lmatch.group(1)
+ # NOTE: Electric uses library:cell internally to track libraries,
+ # and maps the ":" to "__" in the netlist. Not entirely certain that
+ # the double-underscore uniquely identifies the library:cell. . .
+ librex = re.compile('(.*)__(.*)', re.IGNORECASE)
+ lmatch = librex.match(subname)
+ if lmatch:
+ elecpath = os.path.split(os.path.split(schempath)[0])[0]
+ libname = lmatch.group(1)
+ subschem = elecpath + '/' + libname + '.delib/' + lmatch.group(2) + '.sch'
+ else:
+ libname = {}
+ subschem = schemdir + '/' + subname + '.sch'
+ # subcircuits that cannot be found in the current directory are
+ # assumed to be library components or read-only IP components and
+ # therefore never out-of-date.
+ if os.path.exists(subschem):
+ sub_statbuf = os.stat(subschem)
+ if spi_statbuf.st_mtime < sch_statbuf.st_mtime:
+ # netlist exists but is out-of-date
+ print('Netlist is older than subcircuit schematic ' + subname)
+ need_capture = True
+ break
+ # mapping of characters to what's allowed in SPICE makes finding
+ # the associated schematic file a bit difficult. Requires wild-card
+ # searching.
+ elif libname:
+ restr = lmatch.group(2) + '.sch'
+ restr = restr.replace('.', '\.')
+ restr = restr.replace('_', '.')
+ schrex = re.compile(restr, re.IGNORECASE)
+ try:
+ liblist = os.listdir(elecpath + '/' + libname + '.delib')
+ except FileNotFoundError:
+ # Potentially could look through the paths in LIBDIR. . .
+ pass
+ else:
+ for file in liblist:
+ lmatch = schrex.match(file)
+ if lmatch:
+ subschem = elecpath + '/' + libname + '.delib/' + file
+ sub_statbuf = os.stat(subschem)
+ if spi_statbuf.st_mtime < sch_statbuf.st_mtime:
+ # netlist exists but is out-of-date
+ need_capture = True
+ print('Netlist is older than subcircuit schematic ' + file)
+ print('In library ' + libname)
+ break
+ return need_capture
+
+def printwarn(output):
+ # Check output for warning or error
+ if not output:
+ return 0
+
+ warnrex = re.compile('.*warning', re.IGNORECASE)
+ errrex = re.compile('.*error', re.IGNORECASE)
+
+ errors = 0
+ outlines = output.splitlines()
+ for line in outlines:
+ try:
+ wmatch = warnrex.match(line)
+ except TypeError:
+ line = line.decode('utf-8')
+ wmatch = warnrex.match(line)
+ ematch = errrex.match(line)
+ if ematch:
+ errors += 1
+ if ematch or wmatch:
+ print(line)
+ return errors
+
+def layout_netlist_includes(pexnetlist, dspath):
+ # Magic does not generate netlist output for LEF-like views unless
+ # the option "blackbox on" is passed to ext2spice, in which case it
+ # generates stub entries. When generating a PEX view for simulation,
+ # these entries need to be generated then replaced with the correct
+ # include statement to the ip/ directory.
+
+ comtrex = re.compile(r'^\*') # SPICE comment
+ subcrex = re.compile(r'^[ \t]*x([^ \t]+)[ \t]+(.*)$', re.IGNORECASE) # SPICE subcircuit line
+ subrex = re.compile(r'^[ \t]*.subckt[ \t]+([^ \t]+)[ \t]*([^ \t]+.*)', re.IGNORECASE)
+ endsrex = re.compile(r'^[ \t]*\.ends[ \t]*', re.IGNORECASE)
+
+ # Also convert commas from [X,Y] arrays to vertical bars as something
+ # that can be converted back as necessary. ngspice treats commas as
+ # special characters for some reason. ngspice also does not correctly
+ # handle slash characters in node names (okay as part of the netlist but
+ # fails if used in, say, ".nodeset"). Should be okay to replace all '/'
+ # because the layout extracted netlist won't have .include or other
+ # entries with filename paths.
+
+ # Find project tech path
+ if os.path.exists(dspath + '/.ef-config/techdir'):
+ techdir = os.path.realpath(dspath + '/.ef-config/techdir')
+ maglefdir = techdir + '/libs.ref/maglef'
+ else:
+ print('Warning: Project ' + dspath + ' does not define a target process!')
+ techdir = None
+ maglefdir = None
+
+ with open(pexnetlist, 'r') as ifile:
+ spitext = ifile.read()
+
+ # Find project info file (introduced with FFS, 2/2019. Does not exist in earlier
+ # projects)
+
+ depends = {}
+ ipname = ''
+ if os.path.exists(dspath + '/.ef-config/info'):
+ with open(dspath + '/.ef-config/info', 'r') as ifile:
+ infolines = ifile.read().splitlines
+ deprec = False
+ for line in infolines:
+ if 'dependencies:' in line:
+ deprec = True
+ if deprec:
+ if 'version' in line:
+ version = line.split()[1].strip("'")
+ if ipname != '':
+ depends[ipname] = version
+ ipname = ''
+ else:
+ print('Error: Badly formed info file in .ef-config', file=sys.stderr)
+ else:
+ ipname = line.strip(':')
+
+ spilines = spitext.replace('\n+', ' ').replace(',', '|').replace('/','|').splitlines()
+
+ newspilines = []
+ extended_names = []
+ pinsorts = {}
+ inbox = False
+ for line in spilines:
+ cmatch = comtrex.match(line)
+ smatch = subrex.match(line)
+ xmatch = subcrex.match(line)
+ if 'Black-box' in line:
+ inbox = True
+ elif not inbox:
+ if xmatch:
+ # Pull subcircuit name from an 'X' component and see if it matches any of the
+ # names that were rewritten in Electric <library>__<cell> style. If so, replace
+ # the subcircuit name with the modified name while preserving the rest of the
+ # component line.
+ rest = xmatch.group(2).split()
+ r1 = list(i for i in rest if '=' not in i)
+ r2 = list(i for i in rest if '=' in i)
+ subname = r1[-1]
+ r1 = r1[0:-1]
+
+ # Re-sort the pins if needed
+ if subname in pinsorts:
+ r1 = [r1[i] for i in pinsorts[subname]]
+
+ if subname.upper() in extended_names:
+ newsubname = subname + '__' + subname
+ newspilines.append('X' + xmatch.group(1) + ' ' + ' '.join(r1) + ' ' + newsubname + ' ' + ' '.join(r2))
+ else:
+ newspilines.append(line)
+ else:
+ newspilines.append(line)
+ elif cmatch:
+ newspilines.append(line)
+ elif smatch:
+ subname = smatch.group(1)
+ pinlist = smatch.group(2).split()
+ print("Parsing black-box subcircuit " + subname)
+ ippath = '~/design/ip/' + subname
+ ipfullpath = os.path.expanduser(ippath)
+ if os.path.exists(ipfullpath):
+ # Version control: Use the versions specified in the .ef-config/info
+ # version list. If it does not exist (legacy behavior), then use the
+ # method outlined below (finds highest version number available).
+ if subname in depends:
+ useversion = str(depends[subname])
+ else:
+ versions = os.listdir(ipfullpath)
+ vf = list(float(i) for i in versions)
+ vi = vf.index(max(vf))
+ useversion = versions[vi]
+
+ versionpath = ipfullpath + '/' + useversion
+
+ # First to do: Check for /spi-stub entry (which is readable), and
+ # check if pin order is correct. Flag a warning if it is not, and
+ # save the pin order in a record so that all X records can be pin
+ # sorted correctly.
+
+ if os.path.exists(versionpath + '/spi-stub'):
+ stubpath = versionpath + '/spi-stub/' + subname + '/' + subname + '__' + subname + '.spi'
+ # More spice file reading! This should be quick, as these files have
+ # only a single empty subcircuit in them.
+ found = False
+ with open(stubpath, 'r') as sfile:
+ stubtext = sfile.read()
+ stublines = stubtext.replace('\n+', ' ').replace(',', '|').splitlines()
+ for line in stublines:
+ smatch = subrex.match(line)
+ if smatch:
+ found = True
+ stubname = smatch.group(1)
+ stublist = smatch.group(2).split()
+ if stubname != subname + '__' + subname:
+ print('Error: Looking for subcircuit ' + subname + '__' + subname + ' in file ' + stubpath + ' but found subcircuit ' + stubname + ' instead!')
+ print("This simulation probably isn't going to go well.")
+ else:
+ needsort = False
+ for stubpin, subpin in zip(stublist, pinlist):
+ if stubpin.upper() != subpin.upper():
+ print('Warning: pin mismatch between layout and schematic stub header on subcircuit ' + subname)
+ print('Will sort layout netlist to match.')
+ print('Correct pin order is: ' + smatch.group(2))
+ needsort = True
+ break
+ if needsort:
+ pinorder = [i[0] for i in sorted(enumerate(pinlist), key = lambda x:stublist.index(x[1]))]
+ pinsorts[subname] = pinorder
+ break
+ if not found:
+ print('Error: Cannot find subcircuit in IP spi-stub entry.')
+ else:
+ print('Warning: IP has no spi-stub entry, cannot verify pin order.')
+
+ if os.path.exists(versionpath + '/spi-rcx'):
+ # This path is restricted and can only be seen by ngspice, which is privileged
+ # to read it. So we can only assume that it matches the spi-stub entry.
+ # NOTE (10/16/2018): Use unexpanded tilde expression in file.
+ # rcxpath = versionpath + '/spi-rcx/' + subname + '/' + subname + '__' + subname + '.spi'
+ rcxpath = ippath + '/' + useversion + '/spi-rcx/' + subname + '/' + subname + '__' + subname + '.spi'
+ newspilines.append('* Black-box entry replaced by path to RCX netlist')
+ newspilines.append('.include ' + rcxpath)
+ extended_names.append(subname.upper())
+ elif os.path.exists(ipfullpath + '/' + useversion + '/spi'):
+ # In a pinch, if there is no spi-rcx, try plain spi
+ # NOTE (10/16/2018): Use unexpanded tilde expression in file.
+ # spipath = versionpath + '/spi/' + subname + '.spi'
+ spipath = ippath + '/' + useversion + '/spi/' + subname + '.spi'
+ newspilines.append('* Black-box entry replaced by path to schematic netlist')
+ newspilines.append('.include ' + spipath)
+ else:
+ # Leave as is, and let it force an error
+ newspilines.append(line)
+ inbox = False
+ elif maglefdir:
+ # Check tech file paths
+ found = False
+ maglefsubdirs = os.listdir(maglefdir)
+ for techsubdir in maglefsubdirs:
+ if not os.path.isdir(maglefdir + '/' + techsubdir):
+ continue
+ # print('Diagnostic: looking in ' + str(maglefdir) + ' ' + str(techsubdir))
+ maglefcells = os.listdir(maglefdir + '/' + techsubdir)
+ if subname + '.mag' in maglefcells:
+ # print("Diagnostic: Parsing black-box subcircuit " + subname)
+ # print('from tech path ' + maglefdir + '/' + techsubdir)
+
+ # Like the IP directory, can't read spi/ so have to assume it's there.
+ # Problem---there is no consistency across PDKs for the naming of
+ # files in spi/!
+
+ newspilines.append('* Need include to schematic netlist for ' + subname)
+ # However, the CDL stub file can be used to check pin order
+ stubpath = techdir + '/libs.ref/cdlStub/' + techsubdir + '/stub.cdl'
+ if os.path.exists(stubpath):
+ # More spice file reading! This should be quick, as these files have
+ # only a empty subcircuits in them.
+ with open(stubpath, 'r') as sfile:
+ stubtext = sfile.read()
+ stublines = stubtext.replace('\n+', ' ').replace(',', '|').splitlines()
+ for line in spilines:
+ smatch = subrex.match(line)
+ if smatch:
+ stubname = smatch.group(1)
+ stublist = smatch.group(2).split()
+ if stubname == subname:
+ found = True
+ needsort = False
+ for stubpin, subpin in zip(stublist, pinlist):
+ if stubpin.upper() != subpin.upper():
+ print('Warning: pin mismatch between layout and schematic stub header on subcircuit ' + subname)
+ print('Will sort layout netlist to match.')
+ print('Correct pin order is: ' + smatch.group(2))
+ needsort = True
+ break
+ if needsort:
+ pinorder = [i[0] for i in sorted(enumerate(pinlist), key = lambda x:stublist.index(x[1]))]
+ pinsorts[subname] = pinorder
+ if found:
+ break
+
+ else:
+ print('No file ' + stubpath + ' found.')
+ print('Failure to find stub netlist for checking pin order. Good luck.')
+ break
+
+ if not found:
+ print('Error: Subcell ' + subname + ' not found in IP or tech paths.')
+ print('This netlist is not going to simulate correctly.')
+ newspilines.append('* Unknown black-box entry ' + subname)
+ newspilines.append(line)
+ elif endsrex.match(line):
+ inbox = False
+
+ with open(pexnetlist, 'w') as ofile:
+ for line in newspilines:
+ print(line, file=ofile)
+
+def regenerate_netlists(localmode, dspath, dsheet):
+ # When running locally, 'netlist-source' determines whether to use the
+ # layout extracted netlist or the schematic captured netlist. Also for
+ # local running only, regenerate the netlist only if it is out of date,
+ # or if the user has selected forced regeneration in the settings.
+
+ dname = dsheet['ip-name']
+ magpath = dspath + '/mag/'
+
+ spipath = dspath + '/spi/' # Schematic netlist for sim
+ stubpath = dspath + '/spi/stub/' # Schematic netlist for LVS
+ pexpath = dspath + '/spi/pex/' # Layout netlist for sim
+ lvspath = dspath + '/spi/lvs/' # Layout netlist for LVS
+ vlogpath = dspath + '/verilog/' # Verilog netlist for sim and LVS
+
+ netlistname = dname + '.spi'
+ schnetlist = spipath + netlistname
+ stubnetlist = stubpath + netlistname
+ pexnetlist = pexpath + netlistname
+ laynetlist = lvspath + netlistname
+
+ layoutpath = magpath + dname + '.mag'
+ elecpath = dspath + '/elec/' + dname + '.delib'
+ schempath = elecpath + '/' + dname + '.sch'
+ verilogpath = vlogpath + dname + '.v'
+ pathlast = os.path.split(dspath)[1]
+ verilogaltpath = vlogpath + pathlast + '/' + dname + '.vgl'
+ need_sch_capture = True
+ need_stub_capture = True
+ need_lay_capture = True
+ need_pex_capture = True
+ force_regenerate = False
+
+ # Check if datasheet has been marked for forced netlist regeneration
+ if 'regenerate' in dsheet:
+ if dsheet['regenerate'] == 'force':
+ force_regenerate = True
+
+ # If schempath does not exist, check if the .sch file is in a different
+ # library.
+ if not os.path.exists(schempath):
+ print('No schematic in path ' + schempath)
+ print('Checking for other library paths.')
+ for libname in os.listdir(dspath + '/elec/'):
+ if os.path.splitext(libname)[1] == '.delib':
+ elecpath = dspath + '/elec/' + libname
+ if os.path.exists(elecpath):
+ for schfile in os.listdir(elecpath):
+ if schfile == dname + '.sch':
+ schempath = elecpath + '/' + schfile
+ print('Schematic found in ' + schempath)
+ break
+
+ # Guess the source based on the file or files in the design directory,
+ # with preference given to layout. This may be overridden in local mode.
+
+ if localmode and ('netlist-source' in dsheet) and (not force_regenerate):
+ print("Checking for out-of-date netlists.\n")
+ netlist_source = dsheet['netlist-source']
+ need_sch_capture = check_schematic_out_of_date(schnetlist, schempath)
+ need_stub_capture = check_schematic_out_of_date(stubnetlist, schempath)
+ if netlist_source == 'layout':
+ netlist_path = pexnetlist
+ need_pex_capture = check_layout_out_of_date(pexnetlist, layoutpath)
+ need_lay_capture = check_layout_out_of_date(laynetlist, layoutpath)
+ else:
+ netlist_path = schnetlist
+ need_lay_capture = False
+ need_pex_capture = False
+ else:
+ if not localmode:
+ print("Remote use, ", end='');
+ print("forcing regeneration of all netlists.\n")
+ if 'netlist-source' in dsheet:
+ netlist_source = dsheet['netlist-source']
+ if netlist_source == 'layout':
+ netlist_path = pexnetlist
+ else:
+ netlist_path = schnetlist
+ need_lay_capture = False
+ need_pex_capture = False
+ else:
+ if os.path.exists(layoutpath):
+ netlist_path = pexnetlist
+ dsheet['netlist-source'] = 'layout'
+ elif os.path.exists(schempath):
+ netlist_path = schnetlist
+ dsheet['netlist-source'] = 'schematic'
+ need_lay_capture = False
+ need_pex_capture = False
+ elif os.path.exists(verilogpath):
+ netlist_path = verilogpath
+ dsheet['netlist-source'] = 'verilog'
+ need_lay_capture = False
+ need_pex_capture = False
+ need_sch_capture = False
+ need_stub_capture = False
+ elif os.path.exists(verilogaltpath):
+ netlist_path = verilogaltpath
+ dsheet['netlist-source'] = 'verilog'
+ need_lay_capture = False
+ need_pex_capture = False
+ need_sch_capture = False
+ need_stub_capture = False
+
+ if need_lay_capture or need_pex_capture:
+ # Layout LVS netlist needs regenerating. Check for magic layout.
+ if not os.path.isfile(layoutpath):
+ print('Error: No netlist or layout for project ' + dname + '.')
+ print('(layout master file ' + layoutpath + ' not found.)\n')
+ return False
+
+ # Check for spi/lvs/ directory
+ if not os.path.exists(lvspath):
+ os.makedirs(lvspath)
+
+ # Check for spi/pex/ directory
+ if not os.path.exists(pexpath):
+ os.makedirs(pexpath)
+
+ print("Extracting LVS netlist from layout. . .")
+ mproc = subprocess.Popen(['/ef/apps/bin/magic', '-dnull', '-noconsole',
+ layoutpath], stdin = subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT, cwd = dspath + '/mag',
+ universal_newlines = True)
+ mproc.stdin.write("select top cell\n")
+ mproc.stdin.write("expand true\n")
+ mproc.stdin.write("extract all\n")
+ mproc.stdin.write("ext2spice hierarchy on\n")
+ mproc.stdin.write("ext2spice format ngspice\n")
+ mproc.stdin.write("ext2spice scale off\n")
+ mproc.stdin.write("ext2spice renumber off\n")
+ mproc.stdin.write("ext2spice subcircuit on\n")
+ mproc.stdin.write("ext2spice global off\n")
+ # Don't want black box entries, but create them so that we know which
+ # subcircuits are in the ip path, then replace them.
+ mproc.stdin.write("ext2spice blackbox on\n")
+ if need_lay_capture:
+ mproc.stdin.write("ext2spice cthresh infinite\n")
+ mproc.stdin.write("ext2spice rthresh infinite\n")
+ mproc.stdin.write("ext2spice -o " + laynetlist + "\n")
+ if need_pex_capture:
+ mproc.stdin.write("ext2spice cthresh 0.005\n")
+ mproc.stdin.write("ext2spice rthresh 1\n")
+ mproc.stdin.write("ext2spice -o " + pexnetlist + "\n")
+ mproc.stdin.write("quit -noprompt\n")
+ magout = mproc.communicate()[0]
+ printwarn(magout)
+ if mproc.returncode != 0:
+ print('Magic process returned error code ' + str(mproc.returncode) + '\n')
+
+ if need_lay_capture and not os.path.isfile(laynetlist):
+ print('Error: No LVS netlist extracted from magic.')
+ if need_pex_capture and not os.path.isfile(pexnetlist):
+ print('Error: No parasitic extracted netlist extracted from magic.')
+
+ if (mproc.returncode != 0) or (need_lay_capture and not os.path.isfile(laynetlist)) or (need_pex_capture and not os.path.isfile(pexnetlist)):
+ return False
+
+ if need_pex_capture and os.path.isfile(pexnetlist):
+ print('Generating include statements for read-only IP blocks in layout, if needed')
+ layout_netlist_includes(pexnetlist, dspath)
+
+ if need_sch_capture or need_stub_capture:
+ # Netlist needs regenerating. Check for electric schematic
+ if not os.path.isfile(schempath):
+ if os.path.isfile(verilogpath):
+ print('No schematic for project.')
+ print('Using verilog netlist ' + verilogpath + ' for simulation and LVS.')
+ return verilogpath
+ elif os.path.isfile(verilogaltpath):
+ print('No schematic for project.')
+ print('Using verilog netlist ' + verilogaltpath + ' for simulation and LVS.')
+ return verilogaltpath
+ else:
+ print('Error: No netlist or schematic for project ' + dname + '.')
+ print('(schematic master file ' + schempath + ' not found.)\n')
+ print('Error: No verilog netlist ' + verilogpath + ' or ' + verilogaltpath + ', either.')
+ return False
+
+ # Check if there is a .java directory, if not (e.g., for remote CACE),
+ # then copy it from the defaults.
+ if not os.path.exists(dspath + '/elec/.java'):
+ shutil.copytree('/ef/efabless/deskel/dotjava', dspath + '/elec/.java',
+ symlinks = True)
+
+ # Fix the LIBDIRS file if needed
+ if not os.path.isfile(dspath + '/elec/LIBDIRS'):
+ fix_libdirs(dspath, create = True)
+ elif need_sch_capture or need_stub_capture:
+ fix_libdirs(dspath)
+
+ if need_sch_capture:
+ print("Generating simulation netlist from schematic. . .")
+ # Generate the netlist
+ print('Calling /ef/efabless/bin/elec2spi -o ')
+ libpath = os.path.split(schempath)[0]
+ libname = os.path.split(libpath)[1]
+ print(schnetlist + ' -TS -NTI ' + libname + ' ' + dname + '.sch\n')
+
+ # elec2spi requires that the /spi/ and /spi/stub directory exists
+ if not os.path.exists(spipath):
+ os.makedirs(spipath)
+
+ eproc = subprocess.Popen(['/ef/efabless/bin/elec2spi',
+ '-o', schnetlist, '-TS', '-NTI', libname, dname + '.sch'],
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+ cwd = dspath + '/elec')
+
+ elecout = eproc.communicate()[0]
+ if eproc.returncode != 0:
+ for line in elecout.splitlines():
+ print(line.decode('utf-8'))
+
+ print('Electric process returned error code ' + str(eproc.returncode) + '\n')
+ else:
+ printwarn(elecout)
+
+ if not os.path.isfile(schnetlist):
+ print('Error: No netlist found for the circuit!\n')
+ print('(schematic netlist for simulation ' + schnetlist + ' not found.)\n')
+
+ if need_stub_capture:
+ print("Generating LVS netlist from schematic. . .")
+ # Generate the netlist
+ print('Calling /ef/efabless/bin/elec2spi -o ')
+ libpath = os.path.split(schempath)[0]
+ libname = os.path.split(libpath)[1]
+ print(stubnetlist + ' -LP -TS -NTI ' + libname + ' ' + dname + '.sch\n')
+
+ # elec2spi requires that the /spi/stub directory exists
+ if not os.path.exists(stubpath):
+ os.makedirs(stubpath)
+
+ eproc = subprocess.Popen(['/ef/efabless/bin/elec2spi',
+ '-o', stubnetlist, '-LP', '-TS', '-NTI', libname, dname + '.sch'],
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+ cwd = dspath + '/elec')
+
+ elecout = eproc.communicate()[0]
+ if eproc.returncode != 0:
+ for line in elecout.splitlines():
+ print(line.decode('utf-8'))
+
+ print('Electric process returned error code ' + str(eproc.returncode) + '\n')
+ else:
+ printwarn(elecout)
+
+ if not os.path.isfile(stubnetlist):
+ print('Error: No netlist found for the circuit!\n')
+ print('(schematic netlist for LVS ' + stubnetlist + ' not found.)\n')
+
+ if need_sch_capture or need_stub_capture:
+ if (not os.path.isfile(schnetlist)) or (not os.path.isfile(stubnetlist)):
+ return False
+
+ return netlist_path
+
+def cleanup_exit(signum, frame):
+ global launchproc
+ print("CACE gensim: Received termination signal.")
+ if launchproc:
+ print("CACE gensim: Stopping simulations now.")
+ launchproc.terminate()
+ else:
+ sys.exit(1)
+
+# Main entry point. Read arguments, print usage or load the json file
+# and call generate_simfiles.
+
+if __name__ == '__main__':
+ faulthandler.register(signal.SIGUSR2)
+ signal.signal(signal.SIGINT, cleanup_exit)
+ signal.signal(signal.SIGTERM, cleanup_exit)
+
+ # Divide up command line into options and arguments
+ options = []
+ arguments = []
+ localmode = False
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ # Read the JSON file
+ root_path = []
+ if len(arguments) > 0:
+ root_path = str(sys.argv[1])
+ arguments = arguments[1:]
+ elif len(options) == 0:
+ # Print usage information when arguments don't match
+ print('Usage:\n')
+ print(' ' + str(sys.argv[0]) + ' [root_path] [options ...]')
+ print('Where [options ...] are one or more of the following:')
+ print(' -simdir <path>')
+ print(' is the location where simulation files and data should be placed.')
+ print(' -datasheetdir <path>')
+ print(' is the location of the JSON file describing the characterization.')
+ print(' -testbenchdir <path>')
+ print(' is the location of the netlists for the characterization methods.')
+ print(' -netlist <path>')
+ print(' is the location of the netlist for the device-under-test.')
+ print(' -layoutdir <path>')
+ print(' is the location of the layout netlist for the device-under-test.')
+ print(' -datasheet <name>')
+ print(' is the name of the datasheet JSON file.')
+ print(' -method <name>, ...')
+ print(' is a list of one or more names of methods to simulated. If omitted,')
+ print(' all methods are run for a complete characterization.')
+ print(' -local')
+ print(' indicates that cace_gensim is being run locally, not on the CACE')
+ print(' server, simulation conditions should be output along with results;')
+ print(' "local" mode implies that results are not posted to the marketplace')
+ print(' after simulation, and result files are kept.')
+ print(' -keep')
+ print(' test mode: keep all files after simulation')
+ print(' -plot')
+ print(' test mode: generate plot (.png) files locally')
+ print(' -nopost')
+ print(' test mode: do not post results to the marketplace')
+ print(' -nosim')
+ print(' test mode: set up all files for simulation but do not simulate')
+ sys.exit(0)
+
+ simulation_path = []
+ datasheet_path = []
+ testbench_path = []
+ design_path = []
+ layout_path = []
+ datasheet_name = []
+ methods = []
+ for option in options[:]:
+ result = option.split('=')
+ if result[0] == '-simdir':
+ simulation_path = result[1]
+ options.remove(option)
+ elif result[0] == '-datasheetdir':
+ datasheet_path = result[1]
+ options.remove(option)
+ elif result[0] == '-testbenchdir':
+ testbench_path = result[1]
+ options.remove(option)
+ elif result[0] == '-designdir':
+ design_path = result[1]
+ options.remove(option)
+ elif result[0] == '-layoutdir':
+ layout_path = result[1]
+ options.remove(option)
+ elif result[0] == '-datasheet':
+ datasheet_name = result[1]
+ options.remove(option)
+ elif result[0] == '-method':
+ methods.append(result[1])
+ options.remove(option)
+ elif result[0] == '-bypass':
+ bypassmode = True
+ options.remove(option)
+ elif result[0] == '-local':
+ localmode = True
+
+ # To be valid, must either have a root path or all other options must have been
+ # specified with full paths.
+ if not root_path:
+ err_result = 1
+ if not simulation_path:
+ print('Error: If root_path is not provided, -simdir is required.')
+ elif simulation_path[0] != '/':
+ print('Error: If root_path not provided, -simdir must be a full path.')
+ if not testbench_path:
+ print('Error: If root_path is not provided, -testbenchdir is required.')
+ elif testbench_path[0] != '/':
+ print('Error: If root_path not provided, -testbenchdir must be a full path.')
+ if not design_path:
+ print('Error: If root_path is not provided, -designdir is required.')
+ elif design_path[0] != '/':
+ print('Error: If root_path not provided, -designdir must be a full path.')
+ if not layout_path:
+ print('Error: If root_path is not provided, -layoutdir is required.')
+ elif layout_path[0] != '/':
+ print('Error: If root_path not provided, -layoutdir must be a full path.')
+ if not datasheet_path:
+ print('Error: If root_path is not provided, -datasheetdir is required.')
+ elif datasheet_path[0] != '/':
+ print('Error: If root_path not provided, -datasheetdir must be a full path.')
+ else:
+ err_result = 0
+
+ if err_result:
+ sys.exit(1)
+
+ # Apply defaults where not provided as command-line options
+ else:
+ if not datasheet_path:
+ datasheet_path = root_path
+ elif not os.path.isabs(datasheet_path):
+ datasheet_path = root_path + '/' + datasheet_path
+ if not datasheet_name:
+ datasheet_name = 'datasheet.json'
+ inputfile = datasheet_path + '/' + datasheet_name
+ # 2nd guess: 'project.json'
+ if not os.path.isfile(inputfile):
+ datasheet_name = 'project.json'
+ inputfile = datasheet_path + '/' + datasheet_name
+ # 3rd guess (legacy behavior): project directory name + '.json'
+ if not os.path.isfile(inputfile):
+ datasheet_name = os.path.split(datasheet_path)[1] + '.json'
+ inputfile = datasheet_path + '/' + datasheet_name
+ if not os.path.isfile(inputfile):
+ # Return to original datasheet name; error will be generated.
+ datasheet_name = 'datasheet.json'
+ elif localmode and root_path:
+ # Use normal path to local simulation workspace
+ simulation_path = root_path + '/ngspice/char'
+
+ # Check that datasheet path exists and that the datasheet is there
+ if not os.path.isdir(datasheet_path):
+ print('Error: Path to datasheet ' + datasheet_path + ' does not exist.')
+ sys.exit(1)
+ if len(os.path.splitext(datasheet_name)) != 2:
+ datasheet_name += '.json'
+ inputfile = datasheet_path + '/' + datasheet_name
+ if not os.path.isfile(inputfile):
+ print('Error: No datasheet file ' + inputfile )
+ sys.exit(1)
+
+ with open(inputfile) as ifile:
+ datatop = json.load(ifile)
+
+ # Pick up testbench and design paths from options now, since some of them
+ # depend on the request-hash value in the JSON file.
+
+ if not simulation_path:
+ if 'request-hash' in datatop:
+ hashname = datatop['request-hash']
+ simulation_path = root_path + '/' + hashname
+ elif os.path.isdir(root_path + '/ngspice/char'):
+ simulation_path = root_path + '/ngspice/char'
+ else:
+ simulation_path = root_path
+ elif not os.path.isabs(simulation_path):
+ simulation_path = root_path + '/' + simulation_path
+ if not testbench_path:
+ testbench_path = root_path + '/testbench'
+ elif not os.path.isabs(testbench_path):
+ testbench_path = root_path + '/' + testbench_path
+ if not design_path:
+ design_path = root_path + '/spi'
+ elif not os.path.isabs(design_path):
+ design_path = root_path + '/' + design_path
+ if not layout_path:
+ layout_path = root_path + '/mag'
+ elif not os.path.isabs(layout_path):
+ layout_path = root_path + '/' + layout_path
+
+ # Project name should be 'ip-name' in datatop['data-sheet']
+ try:
+ dsheet = datatop['data-sheet']
+ except KeyError:
+ print('Error: File ' + inputfile + ' is not a datasheet.\n')
+ sys.exit(1)
+ try:
+ name = dsheet['ip-name']
+ except KeyError:
+ print('Error: File ' + inputfile + ' is missing ip-name.\n')
+ sys.exit(1)
+
+ if not os.path.isdir(testbench_path):
+ print('Warning: Path ' + testbench_path + ' does not exist. ' +
+ 'Testbench files are not available.\n')
+
+ if not os.path.isdir(design_path):
+ print('Warning: Path ' + design_path + ' does not exist. ' +
+ 'Netlist files may not be available.\n')
+
+ # Simulation path is where the output is dumped. If it doesn't
+ # exist, then create it.
+ if not os.path.isdir(simulation_path):
+ print('Creating simulation path ' + simulation_path)
+ os.makedirs(simulation_path)
+
+ if not os.path.isdir(layout_path):
+ print('Creating layout path ' + layout_path)
+ os.makedirs(layout_path)
+
+ if not os.path.exists(layout_path + '/.magicrc'):
+ # Make sure correct .magicrc file exists
+ configdir = os.path.split(layout_path)[0]
+ rcpath = configdir + '/.ef-config/techdir/libs.tech/magic/current'
+ pdkname = os.path.split(os.path.realpath(configdir + '/.ef-config/techdir'))[1]
+ rcfile = rcpath + '/' + pdkname + '.magicrc'
+ if os.path.isdir(rcpath):
+ if os.path.exists(rcfile):
+ shutil.copy(rcfile, layout_path + '/.magicrc')
+
+ # Find the electrical parameter list. If it exists, then the
+ # template has been loaded. If not, find the template name,
+ # then load it from known templates. Templates may be local to
+ # the simulation files. Priority is (1) templates known to CACE
+ # (for challenges; cannot be overridden by a user; (2) templates
+ # local to the simulation (user-generated)
+
+ if not 'electrical-params' in dsheet and not 'physical-params' in dsheet:
+ print('Error: Circuit JSON file does not have a valid characterization template!\n')
+ sys.exit(1)
+
+ fullnetlistpath = regenerate_netlists(localmode, root_path, dsheet)
+ if not fullnetlistpath:
+ sys.exit(1)
+
+ netlistpath, netlistname = os.path.split(fullnetlistpath)
+
+ # If there is a 'hints.json' file in the root path, read it and apply to the
+ # electrical parameters. The file contains exactly one hint record per
+ # electrical parameter, although the hint record may be empty.
+ if os.path.exists(root_path + '/hints.json'):
+ with open(root_path + '/hints.json') as hfile:
+ hintlist = json.load(hfile)
+ i = 0
+ for eparam in dsheet['electrical-params']:
+ if not 'hints' in eparam:
+ if hintlist[i]:
+ eparam['hints'] = hintlist[i]
+ i += 1
+
+ # Construct fileinfo dictionary
+ fileinfo = {}
+ fileinfo['project-name'] = name
+ fileinfo['design-netlist-name'] = netlistname
+ fileinfo['design-netlist-path'] = netlistpath
+ fileinfo['testbench-netlist-path'] = testbench_path
+ fileinfo['simulation-path'] = simulation_path
+ fileinfo['root-path'] = root_path
+
+ # Generate the simulation files
+ prescore = generate_simfiles(datatop, fileinfo, arguments, methods, localmode)
+ if prescore == 'fail':
+ # In case of failure
+ options.append('-score=fail')
+
+ # Remove option keys
+ if 'keep' in datatop:
+ options.append('-keep')
+ datatop.pop('keep')
+ if 'plot' in datatop:
+ options.append('-plot')
+ datatop.pop('plot')
+ if 'nopost' in datatop:
+ options.append('-nopost')
+ datatop.pop('nopost')
+ if 'nosim' in datatop:
+ options.append('-nosim')
+ datatop.pop('nosim')
+
+ # Reconstruct the -simdir option for cace_launch
+ options.append('-simdir=' + simulation_path)
+
+ # Reconstruct the -layoutdir option for cace_launch
+ options.append('-layoutdir=' + layout_path)
+
+ # Reconstruct the -netlistdir option for cace_launch
+ options.append('-netlistdir=' + design_path)
+
+ # Reconstruct the -rootdir option for cace_launch
+ if root_path:
+ options.append('-rootdir=' + root_path)
+
+ # Dump the modified JSON file
+ basename = os.path.basename(inputfile)
+ outputfile = simulation_path + '/' + basename
+ with open(outputfile, 'w') as ofile:
+ json.dump(datatop, ofile, indent = 4)
+
+ # Launch simulator as a subprocess and wait for it to finish
+ # Waiting is important, as otherwise child processes get detached and it
+ # becomes very difficult to find them if the simulation needs to be stopped.
+ launchname = apps_path + '/' + 'cace_launch.py'
+
+ # Diagnostic
+ print("Running: " + launchname + ' ' + outputfile)
+ for a in arguments:
+ print(a)
+ for o in options:
+ print(o)
+
+ with subprocess.Popen([launchname, outputfile, *arguments, *options],
+ stdout=subprocess.PIPE, bufsize = 1,
+ universal_newlines=True) as launchproc:
+ for line in launchproc.stdout:
+ print(line, end='')
+ sys.stdout.flush()
+
+ launchproc.stdout.close()
+ return_code = launchproc.wait()
+ if return_code != 0:
+ raise subprocess.CalledProcessError(return_code, launchname)
+
+ sys.exit(0)
diff --git a/common/cace_launch.py b/common/cace_launch.py
new file mode 100755
index 0000000..2867819
--- /dev/null
+++ b/common/cace_launch.py
@@ -0,0 +1,2344 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+"""
+cace_launch.py
+A simple script that pulls in a JSON file and uses the hash key to find the
+directory of spice simulation netlists associated with that file, and runs
+them. The output of all files in a category <SKU>_<METHOD>_<PIN>_* is
+analyzed, and the result written back to the data structure. Then the
+annotated structure is passed back to the marketplace.
+"""
+
+# NOTE: This file is only a local stand-in for the script that launches
+# and manages jobs in parallel and that communicates job status with the
+# front-end. This stand-alone version should not be used for any significant
+# project, as all simulations are run sequentially and will tie up resources.
+
+import os
+import sys
+import shutil
+import tarfile
+import json
+import re
+import math
+import signal
+import datetime
+import requests
+import subprocess
+import faulthandler
+from spiceunits import spice_unit_unconvert
+from spiceunits import spice_unit_convert
+
+import file_compressor
+import cace_makeplot
+
+import og_config
+
+# Values imported from og_config:
+#
+mktp_server_url = og_config.mktp_server_url
+# obs: og_server_url = og_config.og_server_url
+simulation_path = og_config.simulation_path
+
+# Variables needing to be global until this file is properly made into a class
+simfiles_path = []
+layout_path = []
+netlist_path = []
+root_path = []
+hashname = ""
+spiceproc = None
+localmode = False
+bypassmode = False
+statdoc = {}
+
+# Send the simulation status to the remote Open Galaxy host
+def send_status(doc):
+ result = requests.post(og_server_url + '/opengalaxy/send_status_cace', json=doc)
+ print('send_status_cace ' + str(result.status_code))
+
+# Make request to server sending annotated json back
+def send_doc(doc):
+ result = requests.post(mktp_server_url + '/cace/save_result', json=doc)
+ print('send_doc ' + str(result.status_code))
+
+# Pure HTTP post here. Add the file to files object and the hash/filename
+# to the data params.
+def send_file(hash, file, file_name):
+ files = {'file': file.getvalue()}
+ data = {'request-hash': hash, 'file-name': file_name}
+ result = requests.post(mktp_server_url + '/cace/save_result_files', files=files, data=data)
+ print('send_file ' + str(result.status_code))
+
+# Clean up and exit on termination signal
+def cleanup_exit(signum, frame):
+ global root_path
+ global simfiles_path
+ global simulation_path
+ global spiceproc
+ global statdoc
+ global localmode
+ if spiceproc:
+ print("CACE launch: Termination signal received.")
+ spiceproc.terminate()
+ spiceproc.wait()
+
+ # Remove simulation files
+ print("CACE launch: Simulations have been terminated.")
+ if localmode == False:
+ test = os.path.split(root_path)[0]
+ if test != simulation_path:
+ print('Error: Root path is not in the system simulation path. Not deleting.')
+ print('Root path is ' + root_path + '; simulation path is ' + simulation_path)
+ else:
+ subprocess.run(['rm', '-r', root_path])
+ else:
+ # Remove all .spi files, .data files, .raw files and copy of datasheet
+ os.chdir(simfiles_path)
+ if os.path.exists('datasheet.json'):
+ os.remove('datasheet.json')
+ files = os.listdir(simfiles_path)
+ for filename in files:
+ try:
+ fileext = os.path.splitext(filename)[1]
+ except:
+ pass
+ else:
+ if fileext == '.spi' or fileext == '.data' or fileext == '.raw':
+ os.remove(filename)
+ elif fileext == '.tv' or fileext == '.tvo' or fileext == '.lxt' or fileext == '.vcd':
+ os.remove(filename)
+
+ # Post exit status back to Open Galaxy
+ if statdoc and not localmode:
+ status['message'] = 'canceled'
+ send_status(statdoc)
+
+ # Exit
+ sys.exit(0)
+
+# Handling of 2s complement values in calculations (e.g., "1000" is -8, not +8)
+# If a value should be unsigned, then the units for the value should be one bit
+# larger than represented. e.g., if unit = "4'b" and value = "1000" then value
+# is -8, but if unit = "5'b" and value = "1000" then value is +8.
+
+def twos_complement(val, bits):
+ """compute the 2's compliment of int value val"""
+ if (val & (1 << (bits - 1))) != 0: # if sign bit is set e.g., 8bit: 128-255
+ val = val - (1 << bits) # compute negative value
+ return val # return positive value as is
+
+# Calculation of results from collected data for an output record,
+# given the type of calculation to perform in 'calctype'. Known
+# calculations are minimum, maximum, and average (others can be
+# added as needed).
+
+def calculate(record, rawdata, conditions, calcrec, score, units, param):
+ # Calculate result from rawdata based on calctype; place
+ # result in record['value'].
+
+ # "calcrec" is parsed as "calctype"-"limittype", where:
+ # "calctype" is one of: avg, min, max
+ # "limittype" is one of: above, below, exact
+
+ # "min" alone implies "min-above"
+ # "max" alone implies "max-below"
+ # "avg" alone implies "avg-exact"
+
+ # Future development:
+ # Add "minimax", "maximin", and "typ" to calctypes (needs extra record(s))
+ # Add "range" to limittypes (needs extra record or tuple for target)
+
+ binrex = re.compile(r'([0-9]*)\'([bodh])', re.IGNORECASE)
+
+ data = rawdata
+ if 'filter' in record:
+ # Filter data by condition range.
+ filtspec = record['filter'].split('=')
+ if len(filtspec) == 2:
+ condition = filtspec[0].upper()
+ valuerange = filtspec[1].split(':')
+ # Pick data according to filter, which specifies a condition and value, or condition
+ # and range of values in the form "a:b". Syntax is limited and needs to be expanded.
+ if condition in conditions:
+ condvec = conditions[condition]
+ if len(valuerange) == 2:
+ valuemin = int(valuerange[0])
+ valuemax = int(valuerange[1])
+ data = list(i for i, j in zip(rawdata, condvec) if j >= valuemin and j <= valuemax)
+ else:
+ try:
+ valueonly = float(valuerange[0])
+ except ValueError:
+ valueonly = valuerange[0]
+ vtype = type(valueonly)
+ if vtype == type('str') or vtype == type('int'):
+ data = list(i for i, j in zip(rawdata, condvec) if j == valueonly)
+ if not data:
+ print('Error: no data match ' + condition + ' = ' + str(valueonly))
+ data = rawdata
+ else:
+ # Avoid round-off problems from floating-point values
+ d = valueonly * 0.001
+ data = list(i for i, j in zip(rawdata, condvec) if j - d < valueonly and j + d > valueonly)
+ if not data:
+ print('Error: no data match ' + condition + ' ~= ' + str(valueonly))
+ data = rawdata
+
+ # For "filter: typical", limit data to those taken for any condition value
+ # which is marked as typical for that condition.
+
+ elif record['filter'] == 'typ' or record['filter'] == 'typical':
+
+ # Create a boolean vector to track which results are under typical conditions
+ typvec = [True] * len(rawdata)
+ for condition in conditions:
+ # Pull record of the condition (this must exist by definition)
+ condrec = next(item for item in param['conditions'] if item['condition'] == condition)
+ if 'typ' not in condrec:
+ continue
+ try:
+ valueonly = float(condrec['typ'])
+ except ValueError:
+ valueonly = condrec['typ']
+ condvec = conditions[condition]
+ typloc = list(i == valueonly for i in condvec)
+ typvec = list(i and j for i, j in zip(typloc, typvec))
+ # Limit data to marked entries
+ data = list(i for i, j in zip(rawdata, typvec) if j)
+ try:
+ calctype, limittype = calcrec.split('-')
+ except ValueError:
+ calctype = calcrec
+ if calctype == 'min':
+ limittype = 'above'
+ elif calctype == 'max':
+ limittype = 'below'
+ elif calctype == 'avg':
+ limittype = 'exact'
+ elif calctype == 'diffmin':
+ limittype = 'above'
+ elif calctype == 'diffmax':
+ limittype = 'below'
+ else:
+ return 0
+
+ # Quick format sanity check---may need binary or hex conversion
+ # using the new method of letting units be 'b or 'h, etc.
+ # (to be done: signed conversion, see cace_makeplot.py)
+ if type(data[0]) == type('str'):
+ bmatch = binrex.match(units)
+ if (bmatch):
+ digits = bmatch.group(1)
+ if digits == '':
+ digits = len(data[0])
+ else:
+ digits = int(digits)
+ base = bmatch.group(2)
+ if base == 'b':
+ a = list(int(x, 2) for x in data)
+ elif base == 'o':
+ a = list(int(x, 8) for x in data)
+ elif base == 'd':
+ a = list(int(x, 10) for x in data)
+ else:
+ a = list(int(x, 16) for x in data)
+ data = list(twos_complement(x, digits) for x in a)
+ else:
+ print("Warning: result data do not correspond to specified units.")
+ print("Data = " + str(data))
+ return 0
+
+ # The target and result should both match the specified units, so convert
+ # the target if it is a binary, hex, etc., value.
+ if 'target' in record:
+ targval = record['target']
+ bmatch = binrex.match(units)
+ if (bmatch):
+ digits = bmatch.group(1)
+ base = bmatch.group(2)
+ if digits == '':
+ digits = len(targval)
+ else:
+ digits = int(digits)
+ try:
+ if base == 'b':
+ a = int(targval, 2)
+ elif base == 'o':
+ a = int(targval, 8)
+ elif base == 'd':
+ a = int(targval, 10)
+ else:
+ a = int(targval, 16)
+ targval = twos_complement(a, digits)
+ except:
+ print("Warning: target data do not correspond to units; assuming integer.")
+
+ # First run the calculation to get the single result value
+
+ if calctype == 'min':
+ # Result is the minimum of the data
+ value = min(data)
+ elif calctype == 'max':
+ # Result is the maximum of the data
+ value = max(data)
+ elif calctype == 'avg':
+ # Result is the average of the data
+ value = sum(data) / len(data)
+ elif calctype[0:3] == 'std':
+ # Result is the standard deviation of the data
+ mean = sum(data) / len(data)
+ value = pow(sum([((i - mean) * (i - mean)) for i in data]) / len(data), 0.5)
+ # For "stdX", where "X" is an integer, multiply the standard deviation by X
+ if len(calctype) > 3:
+ value *= int(calctype[3])
+
+ if len(calctype) > 4:
+ # For "stdXn", subtract X times the standard deviation from the mean
+ if calctype[4] == 'n':
+ value = mean - value
+ # For "stdXp", add X times the standard deviation to the mean
+ elif calctype[4] == 'p':
+ value = mean + value
+ elif calctype == 'diffmax':
+ value = max(data) - min(data)
+ elif calctype == 'diffmin':
+ value = min(data) - max(data)
+ else:
+ return 0
+
+ try:
+ record['value'] = '{0:.4g}'.format(value)
+ except ValueError:
+ print('Warning: Min/Typ/Max value is not not numeric; value is ' + value)
+ return 0
+
+ # Next calculate the score based on the limit type
+
+ if limittype == 'above':
+ # Score a penalty if value is below the target
+ if 'target' in record:
+ targval = float(targval)
+ dopassfail = False
+ if 'penalty' in record:
+ if record['penalty'] == 'fail':
+ dopassfail = True
+ else:
+ penalty = float(record['penalty'])
+ else:
+ penalty = 0
+ print('min = ' + str(value))
+ # NOTE: 0.0005 value corresponds to formatting above, so the
+ # value is not marked in error unless it would show a different
+ # value in the display.
+ if value < targval - 0.0005:
+ if dopassfail:
+ locscore = 'fail'
+ score = 'fail'
+ print('fail: target = ' + str(record['target']) + '\n')
+ else:
+ locscore = (targval - value) * penalty
+ print('fail: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ if score != 'fail':
+ score += locscore
+ elif math.isnan(value):
+ locscore = 'fail'
+ score = 'fail'
+ else:
+ if dopassfail:
+ locscore = 'pass'
+ else:
+ locscore = 0
+ print('pass')
+ if dopassfail:
+ record['score'] = locscore
+ else:
+ record['score'] = '{0:.4g}'.format(locscore)
+
+ elif limittype == 'below':
+ # Score a penalty if value is above the target
+ if 'target' in record:
+ targval = float(targval)
+ dopassfail = False
+ if 'penalty' in record:
+ if record['penalty'] == 'fail':
+ dopassfail = True
+ else:
+ penalty = float(record['penalty'])
+ else:
+ penalty = 0
+ print('max = ' + str(value))
+ # NOTE: 0.0005 value corresponds to formatting above, so the
+ # value is not marked in error unless it would show a different
+ # value in the display.
+ if value > targval + 0.0005:
+ if dopassfail:
+ locscore = 'fail'
+ score = 'fail'
+ print('fail: target = ' + str(record['target']) + '\n')
+ else:
+ locscore = (value - targval) * penalty
+ print('fail: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ if score != 'fail':
+ score += locscore
+ elif math.isnan(value):
+ locscore = 'fail'
+ score = 'fail'
+ else:
+ if dopassfail:
+ locscore = 'pass'
+ else:
+ locscore = 0
+ print('pass')
+ if dopassfail:
+ record['score'] = locscore
+ else:
+ record['score'] = '{0:.4g}'.format(locscore)
+
+ elif limittype == 'exact':
+ # Score a penalty if value is not equal to the target
+ if 'target' in record:
+ targval = float(targval)
+ dopassfail = False
+ if 'penalty' in record:
+ if record['penalty'] == 'fail':
+ dopassfail = True
+ else:
+ penalty = float(record['penalty'])
+ else:
+ penalty = 0
+
+ if value != targval:
+ if dopassfail:
+ locscore = 'fail'
+ score = 'fail'
+ print('off-target failure')
+ else:
+ locscore = abs(targval - value) * penalty
+ print('off-target: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ if score != 'fail':
+ score += locscore
+ elif math.isnan(value):
+ locscore = 'fail'
+ score = 'fail'
+ else:
+ print('on-target')
+ if dopassfail:
+ locscore = 'pass'
+ else:
+ locscore = 0
+
+ if dopassfail:
+ record['score'] = locscore
+ else:
+ record['score'] = '{0:.4g}'.format(locscore)
+
+ elif limittype == 'legacy':
+ # Score a penalty if the value is not equal to the target, except
+ # that a lack of a minimum record implies no penalty below the
+ # target, and lack of a maximum record implies no penalty above
+ # the target. This is legacy behavior for "typ" records, and is
+ # used if no "calc" key appears in the "typ" record. "legacy" may
+ # also be explicitly stated, although it is considered deprecated
+ # in favor of "avg-max" and "avg-min".
+
+ if 'target' in record:
+ targval = float(targval)
+ if record['penalty'] == 'fail':
+ # "typical" should never be pass-fail
+ penalty = 0
+ else:
+ penalty = float(record['penalty'])
+ print('typ = ' + str(value))
+ if value != targval:
+ if 'max' in param and value > targval:
+ # max specified, so values below 'typ' are not costed
+ # this method deprecated, use 'calc' = 'avg-max' instead.
+ locscore = (value - targval) * penalty
+ print('above-target: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ elif 'min' in param and value < targval:
+ # min specified, so values above 'typ' are not costed
+ # this method deprecated, use 'calc' = 'avg-min' instead.
+ locscore = (targval - value) * penalty
+ print('below-target: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ elif 'max' not in param and 'min' not in param:
+ # Neither min and max specified, so value is costed on
+ # both sides of the target.
+ locscore = abs(targval - value) * penalty
+ print('off-target: target = ' + str(record['target'])
+ + ' penalty = ' + str(locscore))
+ else:
+ locscore = 0
+ if score != 'fail':
+ score += locscore
+ else:
+ locscore = 0
+ print('on-target')
+ record['score'] = '{0:.4g}'.format(locscore)
+
+ # Note: Calctype 'none' performs no calculation. Record is unchanged,
+ # and "score" is returned unchanged.
+
+ return score
+
+def run_and_analyze_lvs(dsheet):
+ ipname = dsheet['ip-name']
+ node = dsheet['node']
+ # Hack---node XH035 should have been specified as EFXH035A; allow
+ # the original one for backwards compatibility.
+ if node == 'XH035':
+ node = 'EFXH035A'
+ mag_path = netlist_path + '/lvs/' + ipname + '.spi'
+ schem_path = netlist_path + '/stub/' + ipname + '.spi'
+
+ if not os.path.exists(schem_path):
+ schem_path = netlist_path + '/' + ipname + '.spi'
+ if not os.path.exists(schem_path):
+ if os.path.exists(root_path + '/verilog'):
+ schem_path = root_path + '/verilog/' + ipname + '.v'
+
+ # Check the netlist to see if the cell to match is a subcircuit. If
+ # not, then assume it is the top level.
+
+ is_subckt = False
+ subrex = re.compile('^[^\*]*[ \t]*.subckt[ \t]+([^ \t]+).*$', re.IGNORECASE)
+ with open(mag_path) as ifile:
+ spitext = ifile.read()
+
+ dutlines = spitext.replace('\n+', ' ').splitlines()
+ for line in dutlines:
+ lmatch = subrex.match(line)
+ if lmatch:
+ subname = lmatch.group(1)
+ if subname.lower() == ipname.lower():
+ is_subckt = True
+ break
+
+ if is_subckt:
+ layout_arg = mag_path + ' ' + ipname
+ else:
+ layout_arg = mag_path
+
+ # Get PDK name for finding the netgen setup file
+ if os.path.exists(root_path + '/.ef-config'):
+ pdkdir = os.path.realpath(root_path + '/.ef-config/techdir')
+ else:
+ foundry = dsheet['foundry']
+ pdkdir = '/ef/tech/' + foundry + '/' + node
+ lvs_setup = pdkdir + '/libs.tech/netgen/' + node + '_setup.tcl'
+
+ # Run LVS as a subprocess and wait for it to finish. Use the -json
+ # switch to get a file that is easy to parse.
+
+ print('cace_launch.py: running /ef/apps/bin/netgen -batch lvs ')
+ print(layout_arg + ' ' + schem_path + ' ' + ipname + ' ' + lvs_setup + ' comp.out -json -blackbox')
+
+ lvsproc = subprocess.run(['/ef/apps/bin/netgen', '-batch', 'lvs',
+ layout_arg, schem_path + ' ' + ipname,
+ lvs_setup, 'comp.out', '-json', '-blackbox'], cwd=layout_path,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0)
+
+ with open(layout_path + '/comp.json', 'r') as cfile:
+ lvsdata = json.load(cfile)
+
+ # Count errors in the JSON file
+ failures = 0
+ ncells = len(lvsdata)
+ for c in range(0, ncells):
+ cellrec = lvsdata[c]
+ if c == ncells - 1:
+ topcell = True
+ else:
+ topcell = False
+
+ # Most errors must only be counted for the top cell, because individual
+ # failing cells are flattened and the matching attempted again on the
+ # flattened netlist.
+
+ if topcell:
+ if 'devices' in cellrec:
+ devices = cellrec['devices']
+ devlist = [val for pair in zip(devices[0], devices[1]) for val in pair]
+ devpair = list(devlist[p:p + 2] for p in range(0, len(devlist), 2))
+ for dev in devpair:
+ c1dev = dev[0]
+ c2dev = dev[1]
+ diffdevs = abs(c1dev[1] - c2dev[1])
+ failures += diffdevs
+
+ if 'nets' in cellrec:
+ nets = cellrec['nets']
+ diffnets = abs(nets[0] - nets[1])
+ failures += diffnets
+
+ if 'badnets' in cellrec:
+ badnets = cellrec['badnets']
+ failures += len(badnets)
+
+ if 'badelements' in cellrec:
+ badelements = cellrec['badelements']
+ failures += len(badelements)
+
+ if 'pins' in cellrec:
+ pins = cellrec['pins']
+ pinlist = [val for pair in zip(pins[0], pins[1]) for val in pair]
+ pinpair = list(pinlist[p:p + 2] for p in range(0, len(pinlist), 2))
+ for pin in pinpair:
+ if pin[0].lower() != pin[1].lower():
+ failures += 1
+
+ # Property errors must be counted for every cell
+ if 'properties' in cellrec:
+ properties = cellrec['properties']
+ failures += len(properties)
+
+ return failures
+
+def apply_measure(varresult, measure, variables):
+ # Apply a measurement (record "measure") using vectors found in
+ # "varresult" and produce new vectors which overwrite the original
+ # ones. Operations may reduce "varresult" vectors to a single value.
+
+ # 'condition' defaults to TIME; but this only applies to transient analysis data!
+ if 'condition' in measure:
+ condition = measure['condition']
+ if condition == 'RESULT':
+ # 'RESULT' can either be a specified name (not recommended), or else it is
+ # taken to be the variable set as the result variable.
+ try:
+ activevar = next(item for item in variables if item['condition'] == condition)
+ except StopIteration:
+ try:
+ activevar = next(item for item in variables if 'result' in item)
+ except StopIteration:
+ print('Error: measurement condition ' + condition + ' does not exist!')
+ return 0
+ else:
+ condition = activevar['condition']
+
+ else:
+ condition = 'TIME'
+
+ # Convert old-style separate condition, pin to new style combined
+ if 'pin' in measure:
+ if ':' not in measure['condition']:
+ measure['condition'] += ':' + measure['pin']
+ measure.pop('pin', 0)
+
+ try:
+ activevar = next(item for item in variables if item['condition'] == condition)
+ except:
+ activeunit = ''
+ else:
+ if 'unit' in activevar:
+ activeunit = activevar['unit']
+ else:
+ activeunit = ''
+
+ try:
+ activetrace = varresult[condition]
+ except KeyError:
+ print("Measurement error: Condition " + condition + " does not exist in results.")
+ # No active trace; cannot continue.
+ return
+
+ rsize = len(activetrace)
+
+ if 'TIME' in varresult:
+ timevector = varresult['TIME']
+ try:
+ timevar = next(item for item in variables if item['condition'] == 'TIME')
+ except:
+ timeunit = 's'
+ else:
+ if 'unit' in timevar:
+ timeunit = timevar['unit']
+ else:
+ timeunit = 's'
+ else:
+ timevector = []
+ timeunit = ''
+
+ calctype = measure['calc']
+ # Diagnostic
+ # print("Measure calctype = " + calctype)
+
+ if calctype == 'RESULT':
+ # Change the 'result' marker to the indicated condition.
+ for var in variables:
+ if 'result' in var:
+ var.pop('result')
+
+ activevar['result'] = True
+
+ elif calctype == 'REMOVE':
+ # Remove the indicated condition vector.
+ varresult.pop(condition)
+
+ elif calctype == 'REBASE':
+ # Rebase specified vector (subtract minimum value from all components)
+ base = min(activetrace)
+ varresult[condition] = [i - base for i in activetrace]
+
+ elif calctype == 'ABS':
+ # Take absolute value of activetrace.
+ varresult[condition] = [abs(i) for i in activetrace]
+
+ elif calctype == 'NEGATE':
+ # Negate the specified vector
+ varresult[condition] = [-i for i in activetrace]
+
+ elif calctype == 'ADD':
+ if 'value' in measure:
+ v = float(measure['value'])
+ varresult[condition] = [i + v for i in activetrace]
+ else:
+ # Add the specified vector to the result and replace the result
+ varresult[condition] = [i + j for i, j in zip(activetrace, paramresult)]
+
+ elif calctype == 'SUBTRACT':
+ if 'value' in measure:
+ v = float(measure['value'])
+ varresult[condition] = [i - v for i in activetrace]
+ else:
+ # Subtract the specified vector from the result
+ varresult[condition] = [j - i for i, j in zip(activetrace, paramresult)]
+
+ elif calctype == 'MULTIPLY':
+ if 'value' in measure:
+ v = float(measure['value'])
+ varresult[condition] = [i * v for i in activetrace]
+ else:
+ # Multiply the specified vector by the result (e.g., to get power)
+ varresult[condition] = [j * i for i, j in zip(activetrace, paramresult)]
+
+ elif calctype == 'CLIP':
+ if timevector == []:
+ return
+ # Clip specified vector to the indicated times
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ toidx += 1
+ except StopIteration:
+ toidx = len(timevector)
+
+ for key in varresult:
+ vector = varresult[key]
+ varresult[key] = vector[fromidx:toidx]
+
+ rsize = toidx - fromidx
+
+ elif calctype == 'MEAN':
+ if timevector == []:
+ return
+
+ # Get the mean value of all traces in the indicated range. Results are
+ # collapsed to the single mean value.
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ toidx += 1
+ except StopIteration:
+ toidx = len(timevector)
+
+ # Correct time average requires weighting according to the size of the
+ # time slice.
+ tsum = timevector[toidx - 1] - timevector[fromidx]
+
+ for key in varresult:
+ vector = varresult[key]
+ try:
+ # Test if condition is a numeric value
+ varresult[key] = vector[fromidx] + 1
+ except TypeError:
+ # Some conditions like 'corner' cannot be averaged, so just take the
+ # first entry (may want to consider different handling)
+ varresult[key] = [vector[fromidx]]
+ else:
+ vtot = 0.0
+ for i in range(fromidx + 1, toidx):
+ # Note: This expression can and should be optimized!
+ vtot += ((vector[i] + vector[i - 1]) / 2) * (timevector[i] - timevector[i - 1])
+ varresult[key] = [vtot / tsum]
+
+ rsize = 1
+
+ elif calctype == 'RISINGEDGE':
+ if timevector == []:
+ return
+
+ # RISINGEDGE finds the time of a signal rising edge.
+ # parameters used are:
+ # 'from': start time of search (default zero)
+ # 'to': end time of search (default end)
+ # 'number': edge number (default first edge, or zero) (to be done)
+ # 'cross': measure time when signal crosses this value
+ # 'keep': determines what part of the vectors to keep
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+ if 'cross' in measure:
+ crossval = float(measure['cross'])
+ else:
+ crossval = (max(activetrace) + min(activetrace)) / 2;
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ toidx += 1
+ except StopIteration:
+ toidx = len(timevector)
+ try:
+ startidx = next(i for i, j in enumerate(activetrace[fromidx:toidx]) if j < crossval)
+ except StopIteration:
+ startidx = 0
+ startidx += fromidx
+ try:
+ riseidx = next(i for i, j in enumerate(activetrace[startidx:toidx]) if j >= crossval)
+ except StopIteration:
+ riseidx = toidx - startidx - 1
+ riseidx += startidx
+
+ # If not specified, 'keep' defaults to 'INSTANT'.
+ if 'keep' in measure:
+ keeptype = measure['keep']
+ if keeptype == 'BEFORE':
+ istart = 0
+ istop = riseidx
+ elif keeptype == 'AFTER':
+ istart = riseidx
+ istop = len(timevector)
+ else:
+ istart = riseidx
+ istop = riseidx + 1
+ else:
+ istart = riseidx
+ istop = riseidx + 1
+
+ for key in varresult:
+ vector = varresult[key]
+ varresult[key] = vector[istart:istop]
+
+ rsize = istop - istart
+
+ elif calctype == 'FALLINGEDGE':
+ if timevector == []:
+ return
+
+ # FALLINGEDGE finds the time of a signal rising edge.
+ # parameters used are:
+ # 'from': start time of search (default zero)
+ # 'to': end time of search (default end)
+ # 'number': edge number (default first edge, or zero) (to be done)
+ # 'cross': measure time when signal crosses this value
+ # 'keep': determines what part of the vectors to keep
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+ if 'cross' in measure:
+ crossval = measure['cross']
+ else:
+ crossval = (max(activetrace) + min(activetrace)) / 2;
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ toidx += 1
+ except StopIteration:
+ toidx = len(timevector)
+ try:
+ startidx = next(i for i, j in enumerate(activetrace[fromidx:toidx]) if j > crossval)
+ except StopIteration:
+ startidx = 0
+ startidx += fromidx
+ try:
+ fallidx = next(i for i, j in enumerate(activetrace[startidx:toidx]) if j <= crossval)
+ except StopIteration:
+ fallidx = toidx - startidx - 1
+ fallidx += startidx
+
+ # If not specified, 'keep' defaults to 'INSTANT'.
+ if 'keep' in measure:
+ keeptype = measure['keep']
+ if keeptype == 'BEFORE':
+ istart = 0
+ istop = fallidx
+ elif keeptype == 'AFTER':
+ istart = fallidx
+ istop = len(timevector)
+ else:
+ istart = fallidx
+ istop = fallidx + 1
+ else:
+ istart = fallidx
+ istop = fallidx + 1
+
+ for key in varresult:
+ vector = varresult[key]
+ varresult[key] = vector[istart:istop]
+
+ rsize = istop - istart
+
+ elif calctype == 'STABLETIME':
+ if timevector == []:
+ return
+
+ # STABLETIME finds the time at which the signal stabilizes
+ # parameters used are:
+ # 'from': start time of search (default zero)
+ # 'to': end time of search (works backwards from here) (default end)
+ # 'slope': measure time when signal rate of change equals this slope
+ # 'keep': determines what part of the vectors to keep
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+ if 'limit' in measure:
+ limit = float(measure['limit'])
+ else:
+ # Default is 5% higher or lower than final value
+ limit = 0.05
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ except StopIteration:
+ toidx = len(timevector) - 1
+ finalval = activetrace[toidx]
+ toidx += 1
+ highval = finalval * (1.0 + limit)
+ lowval = finalval * (1.0 - limit)
+ try:
+ breakidx = next(i for i, j in reversed(list(enumerate(activetrace[fromidx:toidx]))) if j >= highval or j <= lowval)
+ except StopIteration:
+ breakidx = 0
+ breakidx += fromidx
+
+ # If not specified, 'keep' defaults to 'INSTANT'.
+ if 'keep' in measure:
+ keeptype = measure['keep']
+ if keeptype == 'BEFORE':
+ istart = 0
+ istop = breakidx
+ elif keeptype == 'AFTER':
+ istart = breakidx
+ istop = len(timevector)
+ else:
+ istart = breakidx
+ istop = breakidx + 1
+ else:
+ istart = breakidx
+ istop = breakidx + 1
+
+ for key in varresult:
+ vector = varresult[key]
+ varresult[key] = vector[istart:istop]
+
+ rsize = istop - istart
+
+ elif calctype == 'INSIDE':
+ if timevector == []:
+ return
+
+ # INSIDE retains only values which are inside the indicated limits
+ # 'min': minimum value limit to keep results
+ # 'max': maximum value limit to keep results
+ if 'from' in measure:
+ fromtime = float(spice_unit_convert([timeunit, measure['from'], 'time']))
+ else:
+ fromtime = timevector[0]
+ if 'to' in measure:
+ totime = float(spice_unit_convert([timeunit, measure['to'], 'time']))
+ else:
+ totime = timevector[-1]
+ if 'min' in measure:
+ minval = float(spice_unit_convert([activeunit, measure['min']]))
+ else:
+ minval = min(activetrace)
+ if 'max' in measure:
+ maxval = float(spice_unit_convert([activeunit, measure['max']]))
+ else:
+ maxval = max(activetrace)
+
+ try:
+ fromidx = next(i for i, j in enumerate(timevector) if j >= fromtime)
+ except StopIteration:
+ fromidx = len(timevector) - 1
+ try:
+ toidx = next(i for i, j in enumerate(timevector) if j >= totime)
+ toidx += 1
+ except StopIteration:
+ toidx = len(timevector)
+ goodidx = list(i for i, j in enumerate(activetrace[fromidx:toidx]) if j >= minval and j <= maxval)
+ # Diagnostic
+ if goodidx == []:
+ print('All vector components failed bounds test. max = ' + str(max(activetrace[fromidx:toidx])) + '; min = ' + str(min(activetrace[fromidx:toidx])))
+
+ goodidx = [i + fromidx for i in goodidx]
+ for key in varresult:
+ vector = varresult[key]
+ varresult[key] = [vector[i] for i in goodidx]
+
+ rsize = len(goodidx)
+
+ return rsize
+
+def read_ascii_datafile(file, *args):
+ # Read a file of data produced by the 'wrdata' command in ngspice
+ # (simple ASCII data in columnar format)
+ # No unit conversions occur at this time.
+ #
+ # Arguments always include the analysis variable vector. If additional
+ # arguments are present in "args", they are value vectors representing
+ # additional columns in the data file, and should be treated similarly
+ # to the analysis variable. Note, however, that the wrdata format
+ # redundantly puts the analysis variable in every other column.
+
+ if not args:
+ print('Error: testbench does not specify contents of data file!')
+ return
+
+ dmatrix = []
+ filepath = simfiles_path + '/' + file
+ if not os.path.isfile(filepath):
+ # Handle ngspice's stupid handling of file extensions for the argument
+ # passed to the 'wrdata' command, which sometimes adds the .data
+ # extension and sometimes doesn't, regardless of whether the argument
+ # has an extension or not. Method here is to always include the
+ # extension in the argument, then look for possible ".data.data" files.
+ if os.path.isfile(filepath + '.data'):
+ filepath = filepath + '.data'
+ else:
+ return 0
+
+ with open(filepath, 'r') as afile:
+ for line in afile.readlines():
+ ldata = line.split()
+ if ldata:
+ # Note: dependent variable (e.g., TIME) is repeated
+ # every other column, so record this only once, then
+ # read the remainder while skipping every other column.
+ dvec = []
+ dvec.append(float(ldata[0]))
+ dvec.extend(list(map(float, ldata[1::2])))
+ dmatrix.append(dvec)
+
+ # Transpose dmatrix
+ try:
+ dmatrix = list(map(list, zip(*dmatrix)))
+ except TypeError:
+ print("last line data are " + str(ldata))
+ print("dmatrix is " + str(dmatrix))
+
+ for dvalues, dvec in zip(dmatrix, args):
+ dvec.extend(dvalues)
+
+ try:
+ rval = len(ldata[0])
+ except TypeError:
+ rval = 1
+ return rval
+
+if __name__ == '__main__':
+
+ # Exit in response to terminate signal by terminating ngspice processes
+ faulthandler.register(signal.SIGUSR2)
+ signal.signal(signal.SIGINT, cleanup_exit)
+ signal.signal(signal.SIGTERM, cleanup_exit)
+ options = []
+ arguments = []
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ # track the circuit score (for simulation; layout handled separately)
+ # (initial score may be overridden by passing -score=value to cace_launch.py)
+ score = 0.0
+
+ # read the JSON file
+ keepmode = False
+ plotmode = False
+ postmode = True
+ if len(arguments) > 0:
+ inputfile = arguments[0]
+ else:
+ raise SyntaxError('Usage: ' + sys.argv[0] + ' json_file [-options]\n')
+
+ if os.path.splitext(inputfile)[1] != '.json':
+ raise SyntaxError('Usage: ' + sys.argv[0] + ' json_file [-options]\n')
+
+ for item in options:
+ result = item.split('=')
+ if result[0] == '-keep':
+ keepmode = True
+ elif result[0] == '-plot':
+ plotmode = True
+ elif result[0] == '-nosim':
+ # Diagnostic
+ print('No simulations specified. . . cace_launch exiting.\n')
+ sys.exit(0)
+ elif result[0] == '-nopost':
+ postmode = False
+ keepmode = True
+ elif result[0] == '-simdir':
+ simfiles_path = result[1]
+ elif result[0] == '-layoutdir':
+ layout_path = result[1]
+ elif result[0] == '-netlistdir':
+ netlist_path = result[1]
+ elif result[0] == '-rootdir':
+ root_path = result[1]
+ elif result[0] == '-local':
+ localmode = True
+ bypassmode = False
+ postmode = False
+ keepmode = False
+ elif result[0] == '-bypass':
+ bypassmode = True
+ localmode = True
+ postmode = True
+ keepmode = False
+ elif result[0] == '-score':
+ score = result[1]
+ else:
+ raise SyntaxError('Bad option ' + item + ', options are -keep, -nosim, -nopost, -local, and -simdir=\n')
+
+ # Various information could be obtained from the input JSON file
+ # name, but it will be assumed that all information should be
+ # obtained from the contents of the JSON file itself.
+
+ with open(inputfile) as ifile:
+ datatop = json.load(ifile)
+
+ # Option passing through the JSON: use "nopost" or "keep" defined at the top level.
+ if 'nopost' in datatop:
+ postmode = False
+ datatop.pop('nopost')
+ if 'keep' in datatop:
+ keepmode = True
+ datatop.pop('keep')
+ if 'local' in datatop:
+ localmode = True
+ datatop.pop('local')
+
+ if 'request-hash' in datatop:
+ hashname = datatop['request-hash']
+ else:
+ print("Document JSON missing request-hash.")
+ sys.exit(1)
+
+ # Simfiles should be put in path specified by -simdir, or else
+ # put them in the working directory. Normally "-simdir" will
+ # be given on the command line.
+
+ if not simfiles_path:
+ if root_path:
+ simfiles_path = root_path + '/' + hashname
+ else:
+ simfiles_path = og_config.simulation_path + '/' + hashname
+
+ if not os.path.isdir(simfiles_path):
+ print('Error: Simulation folder ' + simfiles_path + ' does not exist.')
+ sys.exit(1)
+
+ if not layout_path:
+ if root_path:
+ layout_path = root_path + '/mag'
+
+ if not netlist_path:
+ if root_path:
+ netlist_path = root_path + '/spi'
+
+ # Change location to the simulation directory
+ os.chdir(simfiles_path)
+
+ # pull out the relevant part of the JSON file, which is "data-sheet"
+ dsheet = datatop['data-sheet']
+
+ # Prepare a dictionary for the status and pass critical values from datatop.
+ try:
+ statdoc['UID'] = datatop['UID']
+ statdoc['request-hash'] = datatop['request-hash']
+ if 'project-folder' in datatop:
+ statdoc['project'] = datatop['project-folder']
+ else:
+ statdoc['project'] = dsheet['ip-name']
+ status = {}
+ status['message'] = 'initializing'
+ status['completed'] = '0'
+ status['total'] = 'unknown'
+ status['hash'] = datatop['request-hash']
+ statdoc['status'] = status
+ if not localmode:
+ send_status(statdoc)
+ except KeyError:
+ if not localmode:
+ print("Failed to generate status record.")
+ else:
+ pass
+
+ # find the eparamlist. If it exists, then the template has been
+ # loaded. If not, find the template name, then load it from known
+ # templates.
+
+ if 'electrical-params' in dsheet:
+ eparamlist = dsheet['electrical-params']
+ else:
+ eparamlist = []
+ if 'physical-params' in dsheet:
+ pparamlist = dsheet['physical-params']
+ else:
+ pparamlist = []
+
+ if eparamlist == [] and pparamlist == []:
+ print('Circuit JSON file does not have a characterization template!')
+ sys.exit(0)
+
+ simulations = 0
+ has_aux_files = False
+
+ # Diagnostic: find and print the number of files to be simulated
+ # Names are methodname, pinname, and simulation number.
+ totalsims = 0
+ filessimmed = []
+ for param in eparamlist:
+ if 'testbenches' in param:
+ totalsims += len(param['testbenches'])
+ print('Total files to simulate: ' + str(totalsims))
+
+ # Status
+ if statdoc and not localmode:
+ status['message'] = 'starting'
+ status['completed'] = '0'
+ status['total'] = str(totalsims)
+ send_status(statdoc)
+
+ for param in eparamlist:
+ # Process only entries in JSON that have 'testbenches' record
+ if 'testbenches' not in param:
+ continue
+
+ # Information needed to construct the filenames
+ simtype = param['method']
+
+ # For methods with ":", the filename is the part before the colon.
+ methodname = simtype.split(":")
+ if len(methodname) > 1:
+ testbench = methodname[0]
+ submethod = ":" + methodname[1]
+ else:
+ testbench = simtype
+ submethod = ""
+
+ # Simple outputs are followed by a single value
+ outrex = re.compile("[ \t]*\"?([^ \t\"]+)\"?(.*)$", re.IGNORECASE)
+ # conditions always follow as key=value pairs
+ dictrex = re.compile("[ \t]*([^ \t=]+)=([^ \t=]+)(.*)$", re.IGNORECASE)
+ # conditions specified as min:step:max match a result vector.
+ steprex = re.compile("[ \t]*([^:]+):([^:]+):([^:]+)$", re.IGNORECASE)
+ # specification of units as a binary, hex, etc., string in verilog format
+ binrex = re.compile(r'([0-9]*)\'([bodh])', re.IGNORECASE)
+
+ paramresult = [] # List of results
+ paramname = 'RESULT' # Name of the result parameter (default 'RESULT')
+ condresult = {} # Dictionary of condition names and values for each result
+ simfailures = 0 # Track simulations that don't generate results
+
+ # Run ngspice on each prepared simulation file
+ # FYI; ngspice generates output directly to the TTY, bypassing stdout
+ # and stdin, so that it can update the simulation time at the bottom
+ # of the screen without scrolling. Subvert this in ngspice, if possible.
+ # It is a bad practice of ngspice to output to the TTY in batch mode. . .
+
+ testbenches = param['testbenches']
+ print('Files to simulate method ' + testbenches[0]['prefix'] + ': ' + str(len(testbenches)))
+
+ for testbench in testbenches:
+ filename = testbench['filename']
+ filessimmed.append(filename)
+ fileprefix = testbench['prefix']
+ # All output lines start with prefix
+ outrexall = re.compile(fileprefix + submethod + "[ \t]+=?[ \t]*(.+)$", re.IGNORECASE)
+ # "measure" statements act on results of individual simulations,
+ # so keep the results separate until after measurements have been made
+ locparamresult = []
+ loccondresult = {}
+ locvarresult = {}
+
+ # Cosimulation: If there is a '.tv' file in the simulation directory
+ # with the same root name as the netlist file, then run iverilog and
+ # vvp. vvp will call ngspice from the verilog.
+ verilog = os.path.splitext(filename)[0] + '.tv'
+ my_env = os.environ.copy()
+ if os.path.exists(verilog):
+ cosim = True
+ simulator = '/ef/apps/bin/vvp'
+ simargs = ['-M.', '-md_hdl_vpi']
+ filename = verilog + 'o'
+ # Copy the d_hdl object file into the simulation directory
+ shutil.copy('/ef/efabless/lib/iverilog/d_hdl_vpi.vpi', simfiles_path)
+ # Generate the output executable (.tvo) file for vvp.
+ subprocess.call(['/ef/apps/bin/iverilog', '-o' + filename, verilog])
+ # Specific version of ngspice must be used for cosimulation
+ # (Deprecated; default version of ngspice now supports cosimulation)
+ # my_env['NGSPICE_VERSION'] = 'cosim1'
+
+ # There must not be a file 'simulator_pipe' in the directory or vvp will fail.
+ if os.path.exists('simulator_pipe'):
+ os.remove('simulator_pipe')
+ else:
+ cosim = False
+ simulator = '/ef/apps/bin/ngspice'
+ simargs = ['-b']
+ # Do not generate LXT files, as CACE does not have any methods to handle
+ # the data in them anyway.
+ my_env['NGSPICE_LXT2NO'] = '1'
+
+ # ngspice writes to both stdout and stderr; capture all
+ # output equally. Print each line in real-time, flush the
+ # output buffer, and then accumulate the lines for processing.
+
+ # Note: bufsize = 1 and universal_newlines = True sets line-buffered output
+
+ print('Running: ' + simulator + ' ' + ' '.join(simargs) + ' ' + filename)
+
+ with subprocess.Popen([simulator, *simargs, filename],
+ stdout=subprocess.PIPE,
+ bufsize=1, universal_newlines=True, env=my_env) as spiceproc:
+ for line in spiceproc.stdout:
+ print(line, end='')
+ sys.stdout.flush()
+
+ # Each netlist can have as many results as there are in
+ # the "measurements" list for the electrical parameter,
+ # grouped according to common testbench netlist file and
+ # common set of conditions.
+
+ matchline = outrexall.match(line)
+ if matchline:
+ # Divide result into tokens. Space-separated values in quotes
+ # become a result vector; all other entries should be in the
+ # form <key>=<value>. Result value becomes "result":[<vector>]
+ # dictionary entry.
+ rest = matchline.group(1)
+
+ # ASCII file format handling: Data are in the indicated
+ # file in pairs of analysis variable (e.g., TIME for transients)
+ # and 'result'. Note that the analysis variable is
+ # always the first and every other column of the data file.
+ # The primary result is implicit. All other columns
+ # must be explicitly called out on the echo line.
+ if '.data' in rest:
+ print('Reading data from ASCII file.')
+
+ # "variables" are similar to conditions but describe what is
+ # being output from ngspice. There should be one entry for
+ # each (unique) column in the data file, matching the names
+ # given in the testbench file.
+
+ if 'variables' in param:
+ pvars = param['variables']
+ # Convert any old-style condition, pin
+ for var in pvars:
+ if 'pin' in var:
+ if not ':' in var['condition']:
+ var['condition'] += ':' + var['pin']
+ var.pop('pin')
+ else:
+ pvars = []
+
+ # Parse all additional variables. At least one (the
+ # analysis variable) must be specified.
+ data_args = []
+ extra = rest.split()
+
+ if len(extra) == 1:
+ # If the testbench specifies no vectors, then they
+ # must all be specified in order in 'variables' in
+ # the datasheet entry for the electrical parameters.
+ for var in pvars:
+ extra.append(var['condition'])
+ if not pvars:
+ print('Error: No variables specified in testbench or datasheet.')
+ rest = ''
+
+ if len(extra) > 1:
+ for varname in extra[1:]:
+ if varname not in locvarresult:
+ locvarresult[varname] = []
+ data_args.append(locvarresult[varname])
+
+ rsize = read_ascii_datafile(extra[0], *data_args)
+
+ # All values in extra[1:] should be param['variables']. If not, add
+ # an entry and flag a warning because information may be incomplete.
+
+ for varname in extra[1:]:
+ try:
+ var = next(item for item in pvars if item['condition'] == varname)
+ except StopIteration:
+ print('Variable ' + varname + ' not specified; ', end='')
+ print('information may be incomplete.')
+ var = {}
+ var['condition'] = varname
+ pvars.append(var)
+
+ # By default, the 2nd result is the result
+ if len(extra) > 2:
+ varname = extra[2]
+ varrec = next(item for item in pvars if item['condition'] == varname)
+ varrec['result'] = True
+ print('Setting condition ' + varname + ' as the result vector.')
+
+ # "measure" records are applied to individual simulation outputs,
+ # usually to reduce a time-based vector to a single value by
+ # measuring a steady-state value, peak-peak, frequency, etc.
+
+ if 'measure' in param:
+ # Diagnostic
+ # print('Applying measurements.')
+
+ for measure in param['measure']:
+ # Convert any old-style condition, pin
+ if 'pin' in measure:
+ if not ':' in measure['condition']:
+ measure['condition'] += ':' + measure['pin']
+ measure.pop('pin')
+ rsize = apply_measure(locvarresult, measure, pvars)
+ # Diagnostic
+ # print("after measure, rsize = " + str(rsize))
+ # print("locvarresult = " + str(locvarresult))
+
+ # Now recast locvarresult back into loccondresult.
+ for varname in locvarresult:
+ varrec = next(item for item in pvars if item['condition'] == varname)
+ if 'result' in varrec:
+ # print('Result for ' + varname + ' = ' + str(locvarresult[varname]))
+ locparamresult = locvarresult[varname]
+ paramname = varname
+ else:
+ # print('Condition ' + varname + ' = ' + str(locvarresult[varname]))
+ loccondresult[varname] = locvarresult[varname]
+ # Diagnostic
+ # print("Variable " + varname + " length = " + str(len(locvarresult[varname])))
+ rest = ''
+
+ else:
+ # For plots, there is not necessarily any measurements. Just
+ # copy values into locparamresult and loccondresult.
+ for varname in locvarresult:
+ varrec = next(item for item in pvars if item['condition'] == varname)
+ if 'result' in varrec:
+ # print('Result for ' + varname + ' = ' + str(locvarresult[varname]))
+ locparamresult = locvarresult[varname]
+ rsize = len(locparamresult)
+ paramname = varname
+ else:
+ # print('Condition ' + varname + ' = ' + str(locvarresult[varname]))
+ loccondresult[varname] = locvarresult[varname]
+ rest = ''
+ else:
+ rsize = 0
+
+ # To-do: Handle raw files in similar manner to ASCII files.
+
+ while rest:
+ # This code depends on values coming first, followed by conditions.
+ matchtext = dictrex.match(rest)
+ if matchtext:
+ # Diagnostic!
+ condname = matchtext.group(1)
+ # Append to the condition list
+ if condname not in loccondresult:
+ loccondresult[condname] = []
+
+ # Find the condition name in the condition list, so values can
+ # be converted back to the expected units.
+ try:
+ condrec = next(item for item in param['conditions'] if item['condition'] == condname)
+ except StopIteration:
+ condunit = ''
+ else:
+ condunit = condrec['unit']
+
+ rest = matchtext.group(3)
+ matchstep = steprex.match(matchtext.group(2))
+ if matchstep:
+ # condition is in form min:step:max, and the
+ # number of values must match rsize.
+ cmin = float(matchstep.group(1))
+ cstep = float(matchstep.group(2))
+ cmax = float(matchstep.group(3))
+ cnum = int(round((cmax + cstep - cmin) / cstep))
+ if cnum != rsize:
+ print("Warning: Number of conditions (" + str(cnum) + ") is not")
+ print("equal to the number of results (" + str(rsize) + ")")
+ # Back-calculate the correct step size. Usually this
+ # means that the testbench did not add margin to the
+ # DC or AC stop condition, and the steps fell 1 short of
+ # the max.
+ if rsize > 1:
+ cstep = (float(cmax) - float(cmin)) / float(rsize - 1)
+
+ condvec = []
+ for r in range(rsize):
+ condvec.append(cmin)
+ cmin += cstep
+
+ cresult = spice_unit_unconvert([condunit, condvec])
+ condval = loccondresult[condname]
+ for cr in cresult:
+ condval.append(str(cr))
+
+ else:
+ # If there is a vector of results but only one condition, copy the
+ # condition for each result. Note that value may not be numeric.
+
+ # (To do: Apply 'measure' records here)
+ condval = loccondresult[condname]
+ try:
+ test = float(matchtext.group(2))
+ except ValueError:
+ cval = matchtext.group(2)
+ else:
+ cval = str(spice_unit_unconvert([condunit, test]))
+ for r in range(rsize):
+ condval.append(cval)
+ else:
+ # Not a key=value pair, so must be a result value
+ matchtext = outrex.match(rest)
+ if matchtext:
+ rest = matchtext.group(2)
+ rsize += 1
+ # Result value units come directly from the param record.
+ if 'unit' in param:
+ condunit = param['unit']
+ else:
+ condunit = ''
+ if binrex.match(condunit):
+ # Digital result with units 'b, 'h, etc. are kept as strings.
+ locparamresult.append(matchtext.group(1))
+ else:
+ locparamresult.append(float(matchtext.group(1)))
+ else:
+ print('Error: Result line cannot be parsed.')
+ print('Bad part of line is: ' + rest)
+ print('Full line is: ' + line)
+ break
+
+ # Values passed in testbench['conditions'] are common to each result
+ # value. From one line there are rsize values, so append each known
+ # condition to loccondresult rsize times.
+ for condrec in testbench['conditions']:
+ condname = condrec[0]
+ if condname in locvarresult:
+ print('Error: name ' + condname + ' is both a variable and a condition!')
+ print('Ignoring the condition.')
+ continue
+ if condname not in loccondresult:
+ loccondresult[condname] = []
+ condval = loccondresult[condname]
+ if 'unit' in condrec:
+ condunit = condrec['unit']
+ else:
+ condunit = ''
+ for r in range(rsize):
+ if condname.split(':')[0] == 'DIGITAL' or condname == 'CORNER':
+ # Values that are known to be strings
+ condval.append(condrec[2])
+ elif binrex.match(condunit):
+ # Alternate digital specification using units 'b, 'h, etc.
+ condval.append(condrec[2])
+ elif condname == 'ITERATIONS':
+ # Values that are known to be integers
+ condval.append(int(float(condrec[2])))
+ else:
+ # All other values to be treated as floats unless
+ # they are non-numeric, in which case they are
+ # treated as strings and copied as-is.
+ try:
+ condval.append(float(condrec[2]))
+ except ValueError:
+ # Values that are not numeric just get copied
+ condval.append(condrec[2])
+
+ spiceproc.stdout.close()
+ return_code = spiceproc.wait()
+ if return_code != 0:
+ raise subprocess.CalledProcessError(return_code, 'ngspice')
+
+ if len(locparamresult) > 0:
+ # Fold local results into total results
+ paramresult.extend(locparamresult)
+ for key in loccondresult:
+ if not key in condresult:
+ condresult[key] = loccondresult[key]
+ else:
+ condresult[key].extend(loccondresult[key])
+
+ else:
+ # Catch simulation failures
+ simfailures += 1
+
+ simulations += 1
+
+ # Clean up pipe file after cosimulation, also the .lxt file and .tvo files
+ if cosim:
+ if os.path.exists('simulator_pipe'):
+ os.remove('simulator_pipe')
+ # Remove all '.tvo', '.lxt', and '.vcd' files from the work area.
+ if keepmode == False:
+ files = os.listdir(simfiles_path)
+ for filename in files:
+ try:
+ fileext = os.path.splitext(filename)[1]
+ except:
+ pass
+ else:
+ if fileext == '.lxt' or fileext == '.vcd' or fileext == '.tvo' or fileext == '.vpi':
+ os.remove(filename)
+
+
+ # Other files to clean up
+ if os.path.exists('b3v32check.log'):
+ os.remove('b3v32check.log')
+
+ # Status
+ if statdoc and not localmode:
+ if simulations < totalsims:
+ status['message'] = 'in progress'
+ else:
+ status['message'] = 'completed'
+ status['completed'] = str(simulations)
+ status['total'] = str(totalsims)
+ send_status(statdoc)
+
+ # Evaluate concatentated results after all files for this electrical parameter
+ # have been run through simulation.
+
+ if paramresult:
+ print(simtype + ':')
+
+ # Diagnostic
+ # print("paramresult length " + str(len(paramresult)))
+ # for key in condresult:
+ # print("condresult length " + str(len(condresult[key])))
+
+ # Write out all results into the JSON file.
+ # Results are a list of lists; the first list is a list of
+ # methods, and the rest are sets of values corresponding to unique
+ # conditions. The first item in each lists is the result value
+ # for that set of conditions.
+
+ # Always keep results, even for remote CACE.
+
+ outnames = [paramname]
+ outunits = []
+
+ if 'unit' in param:
+ outunits.append(param['unit'])
+ else:
+ outunits.append('')
+ for key in condresult:
+ outnames.append(key)
+ try:
+ condrec = next(item for item in param['conditions'] if item['condition'] == key)
+ except:
+ try:
+ condrec = next(item for item in param['variables'] if item['condition'] == key)
+ except:
+ outunits.append('')
+ else:
+ if 'unit' in condrec:
+ outunits.append(condrec['unit'])
+ # 'variable' entries need to be unconverted
+ cconv = spice_unit_unconvert([condrec['unit'], condresult[key]])
+ condresult[key] = cconv
+ else:
+ outunits.append('')
+ else:
+ if 'unit' in condrec:
+ outunits.append(condrec['unit'])
+ else:
+ outunits.append('')
+
+ # Evaluate a script to transform the output, if there is an 'evaluate'
+ # record in the electrical parameter.
+
+ if 'evaluate' in param:
+
+ evalrec = param['evaluate']
+ try:
+ tool = evalrec['tool']
+ except:
+ print("Error: Evaluate record does not indicate a tool to run.")
+ break
+ else:
+ if tool != 'octave' and tool != 'matlab':
+ print("Error: CASE does not know how to use tool '" + tool + "'")
+ break
+
+ try:
+ script = evalrec['script']
+ except:
+ print("Error: Evaluate record does not indicate a script to run.")
+ break
+ else:
+ if os.path.isdir(root_path + '/testbench'):
+ tb_path = root_path + '/testbench/' + script
+ if not os.path.exists(tb_path):
+ if os.path.exists(tb_path + '.m'):
+ tb_path += '.m'
+ else:
+ print("Error: No script '" + script + "' found in testbench path.")
+ break
+ else:
+ print("Error: testbench directory not found in root path.")
+ break
+
+ # General purpose tool-based evaluation. For complex operations of
+ # any kind, dump the simulation results to a file "results.json" and
+ # invoke the specified tool, which should read the results and
+ # generate an output in the form of modified 'paramresult'.
+ # e.g., input is an array of transient vectors, output is an FFT
+ # analysis. Input is a voltage, output is an INL value. Note that
+ # 'unit' is the unit produced by the script. The script is supposed
+ # to know what units it gets as input and what it produces as output.
+
+ # Create octave-compatible output with structures for the condition
+ # names, units, and data.
+ with open('results.dat', 'w') as ofile:
+ print('# Created by cace_gensim.py', file=ofile)
+ print('# name: results', file=ofile)
+ print('# type: scalar struct', file=ofile)
+ print('# ndims: 2', file=ofile)
+ print('# 1 1', file=ofile)
+ numentries = len(outnames)
+ print('# length: ' + str(2 + numentries), file=ofile)
+ print('# name: NAMES', file=ofile)
+ print('# type: cell', file=ofile)
+ print('# rows: ' + str(numentries), file=ofile)
+ print('# columns: 1', file=ofile)
+ for name in outnames:
+ print('# name: <cell-element>', file=ofile)
+ print('# type: sq_string', file=ofile)
+ print('# elements: 1', file=ofile)
+ print('# length: ' + str(len(name)), file=ofile)
+ print(name, file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+
+ print('', file=ofile)
+ print('', file=ofile)
+ print('# name: UNITS', file=ofile)
+ print('# type: cell', file=ofile)
+ print('# rows: ' + str(len(outunits)), file=ofile)
+ print('# columns: 1', file=ofile)
+ for unit in outunits:
+ print('# name: <cell-element>', file=ofile)
+ print('# type: sq_string', file=ofile)
+ print('# elements: 1', file=ofile)
+ print('# length: ' + str(len(unit)), file=ofile)
+ print(unit, file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+
+ # Each condition is output as a 1D array with structure
+ # entry name equal to the condition name. If the units
+ # is empty then the array is a string. Otherwise, the
+ # array is numeric (as far as octave is concerned).
+
+ # First entry is the result (paramresult). This should never
+ # be a string (at least not in this version of CACE)
+
+ idx = 0
+ print('# name: ' + outnames[idx], file=ofile)
+ units = outunits[idx]
+ print('# type: matrix', file=ofile)
+ print('# rows: ' + str(len(paramresult)), file=ofile)
+ print('# columns: 1', file=ofile)
+ for value in paramresult:
+ print(' ' + str(value), file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+
+ idx += 1
+ # The rest of the entries are the conditions. Note that the
+ # name must be a valid octave variable (letters, numbers,
+ # underscores) and so cannot use the condition name. However,
+ # each condition name is held in the names list, so it can be
+ # recovered. Each condition is called CONDITION2, CONDITION3,
+ # etc.
+
+ for key, entry in condresult.items():
+
+ print('# name: CONDITION' + str(idx + 1), file=ofile)
+ units = outunits[idx]
+ if units == '':
+ # Use cell array for strings
+ print('# type: cell', file=ofile)
+ print('# rows: ' + str(len(entry)), file=ofile)
+ print('# columns: 1', file=ofile)
+ for value in entry:
+ print('# name: <cell-element>', file=ofile)
+ print('# type: sq_string', file=ofile)
+ print('# elements: 1', file=ofile)
+ print('# length: ' + str(len(str(value))), file=ofile)
+ print(str(value), file=ofile)
+ print('', file=ofile)
+ print('', file=ofile)
+ else:
+ print('# type: matrix', file=ofile)
+ print('# rows: ' + str(len(entry)), file=ofile)
+ print('# columns: 1', file=ofile)
+ for value in entry:
+ print(' ' + str(value), file=ofile)
+
+ print('', file=ofile)
+ print('', file=ofile)
+ idx += 1
+
+ # Now run the specified octave script on the result. Script
+ # generates an output file. stdout/stderr can be ignored.
+ # May want to watch stderr for error messages and/or handle
+ # exit status.
+
+ postproc = subprocess.Popen(['/ef/apps/bin/octave-cli', tb_path],
+ stdout = subprocess.PIPE)
+ rvalues = postproc.communicate()[0].decode('ascii').splitlines()
+
+ # Replace paramresult with the numeric result
+ paramresult = list(float(item) for item in rvalues)
+
+ # pconv is paramresult scaled to the units used by param.
+ if 'unit' in param:
+ pconv = spice_unit_unconvert([param['unit'], paramresult])
+ else:
+ pconv = paramresult
+
+ outresult = []
+ outresult.append(outnames)
+ outresult.append(outunits)
+
+ for p in range(len(pconv)):
+ outvalues = []
+ outvalues.append(str(pconv[p]))
+ for key, value in condresult.items():
+ try:
+ outvalues.append(str(value[p]))
+ except IndexError:
+ # Note: This should not happen. . .
+ print("Error: number of values in result and conditions do not match!")
+ print("Result: " + str(len(pconv)))
+ print("Conditions: " + str(len(condresult)))
+ break
+
+ outresult.append(outvalues)
+
+ param['results'] = outresult
+
+ if 'unit' in param:
+ units = param['unit']
+ else:
+ units = ''
+
+ # Catch simulation failures.
+ if simfailures > 0:
+ print('Simulation failures: ' + str(simfailures))
+ score = 'fail'
+
+ if 'min' in param:
+ minrec = param['min']
+ if 'calc' in minrec:
+ calc = minrec['calc']
+ else:
+ calc = 'min-above'
+ minscore = calculate(minrec, pconv, condresult, calc, score, units, param)
+ if score != 'fail':
+ score = minscore
+
+ if 'max' in param:
+ maxrec = param['max']
+ if 'calc' in maxrec:
+ calc = maxrec['calc']
+ else:
+ calc = 'max-below'
+ maxscore = calculate(maxrec, pconv, condresult, calc, score, units, param)
+ if score != 'fail':
+ score = maxscore
+
+ if 'typ' in param:
+ typrec = param['typ']
+ if 'calc' in typrec:
+ calc = typrec['calc']
+ else:
+ calc = 'avg-legacy'
+ typscore = calculate(typrec, pconv, condresult, calc, score, units, param)
+ if score != 'fail':
+ score = typscore
+
+ if 'plot' in param:
+ # If not in localmode, or if in plotmode then create a plot and
+ # save it to a file.
+ plotrec = param['plot']
+ if localmode == False or bypassmode == True or plotmode == True:
+ if 'variables' in param:
+ variables = param['variables']
+ else:
+ variables = []
+ result = cace_makeplot.makeplot(plotrec, param['results'], variables)
+ # New behavior implemented 3/28/2017: Always keep results.
+ # param.pop('results')
+ if result:
+ plotrec['status'] = 'done'
+ has_aux_files = True
+ else:
+ print('Failure: No plot from file ' + filename + '\n')
+ else:
+ plotrec['status'] = 'done'
+ else:
+ try:
+ print('Failure: No output from file ' + filename + '\n')
+ except NameError:
+ print('Failure: No simulation file, so no output\n')
+ continue
+
+ # Handle errors where simulation generated no output.
+ # This is the one case where 'typ' can be treated as pass-fail.
+ # "score" will be set to "fail" for any of "min", "max", and
+ # "typ" that exists in the electrical parameters record and
+ # which specifies a target value. "value" is set to "failure"
+ # for display.
+ score = 'fail'
+ if 'typ' in param:
+ typrec = param['typ']
+ if 'target' in typrec:
+ typrec['score'] = 'fail'
+ typrec['value'] = 'failure'
+ if 'max' in param:
+ maxrec = param['max']
+ if 'target' in maxrec:
+ maxrec['score'] = 'fail'
+ maxrec['value'] = 'failure'
+ if 'min' in param:
+ minrec = param['min']
+ if 'target' in minrec:
+ minrec['score'] = 'fail'
+ minrec['value'] = 'failure'
+
+ # Pop the testbenches record, which has been replaced by the 'results' record.
+ param.pop('testbenches')
+
+ # Final cleanup step: Remove any remaining '.tv' files from the work area.
+ if keepmode == False:
+ files = os.listdir(simfiles_path)
+ for filename in files:
+ try:
+ fileext = os.path.splitext(filename)[1]
+ except:
+ pass
+ else:
+ if fileext == '.tv':
+ os.remove(filename)
+
+ # Report the final score, and save it to the JSON data
+
+ print('Completed ' + str(simulations) + ' of ' + str(totalsims) + ' simulations');
+ print('Circuit pre-extraction simulation total score (lower is better) = '
+ + str(score))
+
+ if score == 'fail':
+ dsheet['score'] = 'fail'
+ else:
+ dsheet['score'] = '{0:.4g}'.format(score)
+
+ # Now handle physical parameters
+ netlist_source = dsheet['netlist-source']
+ areaval = 0.0
+
+ totalchecks = 0
+ for param in pparamlist:
+ if 'check' in param:
+ totalchecks += 1
+ print('Total physical parameters to check: ' + str(totalchecks))
+
+ for param in pparamlist:
+ # Process only entries in JSON that have the 'check' record
+ if 'check' not in param:
+ continue
+ if param['check'] != 'true':
+ continue
+
+ cond = param['condition']
+
+ if cond == 'device_area':
+ areaest = 0
+ ipname = dsheet['ip-name']
+ foundry = dsheet['foundry']
+ node = dsheet['node']
+ # Hack---node XH035 should have been specified as EFXH035A; allow
+ # the original one for backwards compatibility.
+ if node == 'XH035':
+ node = 'EFXH035A'
+
+ if layout_path and netlist_path:
+
+ # Run the device area (area estimation) script
+ if os.path.exists(netlist_path + '/' + ipname + '.spi'):
+ estproc = subprocess.Popen(['/ef/efabless/bin/layout_estimate.py',
+ netlist_path + '/' + ipname + '.spi', node.lower()],
+ stdout=subprocess.PIPE,
+ cwd = layout_path, universal_newlines = True)
+ outlines = estproc.communicate()[0]
+ arealine = re.compile('.*=[ \t]*([0-9]+)[ \t]*um\^2')
+ for line in outlines.splitlines():
+ lmatch = arealine.match(line)
+ if lmatch:
+ areaum2 = lmatch.group(1)
+ areaest = int(areaum2)
+
+ if areaest > 0:
+ score = 'pass'
+ maxrec = param['max']
+ targarea = float(maxrec['target'])
+ maxrec['value'] = str(areaest)
+ if 'penalty' in maxrec:
+ if maxrec['penalty'] == 'fail':
+ if areaest > targarea:
+ score = 'fail'
+ else:
+ score = 'pass'
+ else:
+ try:
+ if areaest > targarea:
+ score = str((areaest - targarea) * float(maxrec['penalty']))
+ else:
+ score = 'pass'
+ except:
+ if areaest > targarea:
+ score = maxrec['penalty']
+ else:
+ score = 'pass'
+ else:
+ score = 'pass'
+ maxrec['score'] = score
+
+ if cond == 'area' or cond == 'height' or cond == 'width':
+
+ # First time for any of these, run the check and get values
+
+ if areaval == 0 and not netlist_source == 'schematic':
+
+ ipname = dsheet['ip-name']
+ foundry = dsheet['foundry']
+ node = dsheet['node']
+ # Hack---node XH035 should have been specified as EFXH035A; allow
+ # the original one for backwards compatibility.
+ if node == 'XH035':
+ node = 'EFXH035A'
+
+ if layout_path:
+
+ # Find the layout directory and check if there is a layout
+ # for the cell there. If not, use the layout estimation
+ # script. Result is either an actual area or an area estimate.
+
+ if os.path.exists(layout_path + '/' + ipname + '.mag'):
+ areaproc = subprocess.Popen(['/ef/apps/bin/magic',
+ '-dnull', '-noconsole', layout_path + '/' + ipname + '.mag'],
+ stdin = subprocess.PIPE, stdout = subprocess.PIPE,
+ cwd = layout_path, universal_newlines = True)
+ areaproc.stdin.write("select top cell\n")
+ areaproc.stdin.write("box\n")
+ areaproc.stdin.write("quit -noprompt\n")
+ outlines = areaproc.communicate()[0]
+ magrex = re.compile('microns:[ \t]+([0-9.]+)[ \t]*x[ \t]*([0-9.]+)[ \t]+.*[ \t]+([0-9.]+)[ \t]*$')
+ for line in outlines.splitlines():
+ lmatch = magrex.match(line)
+ if lmatch:
+ widthval = float(lmatch.group(1))
+ heightval = float(lmatch.group(2))
+ areaval = float(lmatch.group(3))
+
+ if areaval > 0:
+
+ # Now work through the physical parameters --- pass 1
+ # If area was estimated, then find target width and height
+ # for estimating actual width and height.
+
+ for checkparam in dsheet['physical-params']:
+ checkcond = checkparam['condition']
+ maxrec = checkparam['max']
+ if checkcond == 'area':
+ targarea = float(maxrec['target'])
+ elif checkcond == 'width':
+ targwidth = float(maxrec['target'])
+ elif checkcond == 'height':
+ targheight = float(maxrec['target'])
+
+ maxrec = param['max']
+ unit = param['unit']
+
+ if cond == 'area':
+ if areaval > 0:
+ maxrec['value'] = str(areaval)
+ if areaval > targarea:
+ score = 'fail'
+ maxrec['score'] = 'fail'
+ else:
+ maxrec['score'] = 'pass'
+ elif cond == 'width':
+ if areaval > 0:
+ maxrec['value'] = str(widthval)
+ if widthval > targwidth:
+ score = 'fail'
+ maxrec['score'] = 'fail'
+ else:
+ maxrec['score'] = 'pass'
+
+ elif cond == 'height':
+ if areaval > 0:
+ maxrec['value'] = str(heightval)
+ if heightval > targheight:
+ score = 'fail'
+ maxrec['score'] = 'fail'
+ else:
+ maxrec['score'] = 'pass'
+
+ elif cond == 'DRC_errors':
+
+ ipname = dsheet['ip-name']
+
+ if layout_path and not netlist_source == 'schematic':
+ if os.path.exists(layout_path + '/' + ipname + '.mag'):
+
+ # Find the layout directory and check if there is a layout
+ # for the cell there.
+
+ areaproc = subprocess.Popen(['/ef/apps/bin/magic',
+ '-dnull', '-noconsole', layout_path + '/' + ipname + '.mag'],
+ stdin = subprocess.PIPE, stdout = subprocess.PIPE,
+ cwd = layout_path, universal_newlines = True)
+ areaproc.stdin.write("drc on\n")
+ areaproc.stdin.write("select top cell\n")
+ areaproc.stdin.write("drc check\n")
+ areaproc.stdin.write("drc catchup\n")
+ areaproc.stdin.write("set dcount [drc list count total]\n")
+ areaproc.stdin.write("puts stdout \"drc = $dcount\"\n")
+ outlines = areaproc.communicate()[0]
+ magrex = re.compile('drc[ \t]+=[ \t]+([0-9.]+)[ \t]*$')
+ for line in outlines.splitlines():
+ # Diagnostic
+ print(line)
+ lmatch = magrex.match(line)
+ if lmatch:
+ drccount = int(lmatch.group(1))
+ maxrec = param['max']
+ maxrec['value'] = str(drccount)
+ if drccount > 0:
+ maxrec['score'] = 'fail'
+ else:
+ maxrec['score'] = 'pass'
+
+ # Check on LVS from comp.out file (must be more recent than both netlists)
+ elif cond == 'LVS_errors':
+ ipname = dsheet['ip-name']
+ foundry = dsheet['foundry']
+ node = dsheet['node']
+ # Hack---node XH035 should have been specified as EFXH035A; allow
+ # the original one for backwards compatibility.
+ if node == 'XH035':
+ node = 'EFXH035A'
+
+ # To do even a precheck, the layout path must exist and must be populated
+ # with the .magicrc file.
+ if not os.path.exists(layout_path):
+ os.makedirs(layout_path)
+ if not os.path.exists(layout_path + '/.magicrc'):
+ pdkdir = '/ef/tech/' + foundry + '/' + node + '/libs.tech/magic/current'
+ if os.path.exists(pdkdir + '/' + node + '.magicrc'):
+ shutil.copy(pdkdir + '/' + node + '.magicrc', layout_path + '/.magicrc')
+
+ # Netlists should have been generated by cace_gensim.py
+ has_layout_nl = os.path.exists(netlist_path + '/lvs/' + ipname + '.spi')
+ has_schem_nl = os.path.exists(netlist_path + '/' + ipname + '.spi')
+ has_vlog_nl = os.path.exists(root_path + '/verilog/' + ipname + '.v')
+ has_stub_nl = os.path.exists(netlist_path + '/stub/' + ipname + '.spi')
+ if has_layout_nl and has_stub_nl and not netlist_source == 'schematic':
+ failures = run_and_analyze_lvs(dsheet)
+ elif has_layout_nl and has_vlog_nl and not netlist_source == 'schematic':
+ failures = run_and_analyze_lvs(dsheet)
+ elif netlist_path and has_schem_nl:
+ if not has_layout_nl or not has_stub_nl:
+ if not has_layout_nl:
+ print("Did not find layout LVS netlist " + netlist_path + '/lvs/' + ipname + '.spi')
+ if not has_stub_nl:
+ print("Did not find schematic LVS netlist " + netlist_path + '/' + ipname + '.spi')
+ print("Running layout device pre-check.")
+ if localmode == True:
+ if keepmode == True:
+ precheck_opts = ['-log', '-debug']
+ else:
+ precheck_opts = ['-log']
+ print('/ef/efabless/bin/layout_precheck.py ' + netlist_path + '/' + ipname + '.spi ' + node.lower() + ' ' + ' '.join(precheck_opts))
+ chkproc = subprocess.Popen(['/ef/efabless/bin/layout_precheck.py',
+ netlist_path + '/' + ipname + '.spi', node.lower(), *precheck_opts],
+ stdout=subprocess.PIPE,
+ cwd = layout_path, universal_newlines = True)
+ else:
+ chkproc = subprocess.Popen(['/ef/efabless/bin/layout_precheck.py',
+ netlist_path + '/' + ipname + '.spi', node.lower()],
+ stdout=subprocess.PIPE,
+ cwd = layout_path, universal_newlines = True)
+ outlines = chkproc.communicate()[0]
+ failline = re.compile('.*=[ \t]*([0-9]+)[ \t]*')
+ for line in outlines.splitlines():
+ lmatch = failline.match(line)
+ if lmatch:
+ failures = int(lmatch.group(1))
+ else:
+ failures = -1
+
+ if failures >= 0:
+ maxrec = param['max']
+ maxrec['value'] = str(failures)
+ if failures > int(maxrec['target']):
+ score = 'fail'
+ maxrec['score'] = 'fail'
+ else:
+ maxrec['score'] = 'pass'
+
+ # Pop the 'check' record, which has been replaced by the 'value' record.
+ param.pop('check')
+
+ # Remove 'project-folder' from document if it exists, as this document
+ # is no longer related to an Open Galaxy account.
+ if 'project-folder' in datatop:
+ datatop.pop('project-folder')
+
+ # Write the annotated JSON file (NOTE: In the absence of further
+ # processing on the CACE side, this file is just getting deleted
+ # right after it's made. But the file appears to be correctly
+ # pushed back to the marketplace server, so this can be removed.
+
+ filem = os.path.splitext(inputfile)
+ if filem[1]:
+ outputfile = filem[0] + '_anno' + filem[1]
+ else:
+ outputfile = inputfile + '_anno.json'
+
+ with open(outputfile, 'w') as ofile:
+ json.dump(datatop, ofile, indent = 4)
+
+ # Create tarball of auxiliary files and send them as well.
+ # Note that the files themselves are tarballed, not the directory
+
+ if has_aux_files:
+ tar = file_compressor.tar_directory_contents(simfiles_path + '/simulation_files')
+ if 'ip-name' in dsheet:
+ tarballname = dsheet['ip-name'] + '_result_files.tar.gz'
+ else:
+ tarballname = 'result_files.tar.gz'
+
+ # In addition to dumping the file locally, also send back to the
+ # marketplace, along with the tarball of simulation-generated files.
+ if postmode == True:
+ send_doc(datatop)
+ if has_aux_files:
+ send_file(hashname, tar, tarballname)
+ else:
+ print('Posting to marketplace was disabled by -nopost\n')
+
+ # Clean up by removing simulation directory
+ if keepmode == False:
+ if localmode == True:
+ print('Simulation results retained per -local option\n')
+ # If cace_gensim and cace_launch are run locally, keep the results
+ # since they won't be posted, but remove all other generated files.
+ os.chdir(simfiles_path)
+ if os.path.exists('datasheet.json'):
+ os.remove('datasheet.json')
+ for filename in filessimmed:
+ os.remove(filename)
+ # Remove any generated ASCII data files
+ dfile = os.path.splitext(filename)[0] + '.data'
+ if os.path.exists(dfile):
+ os.remove(dfile)
+ # Stupid ngspice handling of wrdata command. . .
+ dfile = os.path.splitext(filename)[0] + '.data.data'
+ if os.path.exists(dfile):
+ os.remove(dfile)
+ # Remove any generated raw files
+ dfile = os.path.splitext(filename)[0] + '.raw'
+ if os.path.exists(dfile):
+ os.remove(dfile)
+ # Remove any cosim verilog files
+ verilog = os.path.splitext(filename)[0] + '.tv'
+ if os.path.exists(verilog):
+ os.remove(verilog)
+ else:
+ # Remove the entire simulation directory. To avoid horrible
+ # consequences of, e.g., "-rootdir /" insist that the last path
+ # component of root_path must be the hashname.
+ test = os.path.split(root_path)[0]
+ if test != simulation_path:
+ print('Error: Root path is not in the system simulation path. Not deleting.')
+ print('Root path is ' + root_path + '; simulation path is ' + simulation_path)
+ else:
+ subprocess.run(['rm', '-rf', root_path])
+ else:
+ print('Simulation directory retained per -keep option\n')
+
+ sys.exit(0)
diff --git a/common/cace_makeplot.py b/common/cace_makeplot.py
new file mode 100755
index 0000000..75611b3
--- /dev/null
+++ b/common/cace_makeplot.py
@@ -0,0 +1,310 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+"""
+cace_makeplot.py
+Plot routines for CACE using matplotlib
+"""
+
+import re
+import os
+import matplotlib
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+
+def twos_comp(val, bits):
+ """compute the 2's compliment of int value val"""
+ if (val & (1 << (bits - 1))) != 0: # if sign bit is set e.g., 8bit: 128-255
+ val = val - (1 << bits) # compute negative value
+ return val # return positive value as is
+
+def makeplot(plotrec, results, variables, parent = None):
+ """
+ Given a plot record from a spec sheet and a full set of results, generate
+ a plot. The name of the plot file and the vectors to plot, labels, legends,
+ and so forth are all contained in the 'plotrec' dictionary.
+ """
+
+ binrex = re.compile(r'([0-9]*)\'([bodh])', re.IGNORECASE)
+ # Organize data into plot lines according to formatting
+
+ if 'type' in plotrec:
+ plottype = plotrec['type']
+ else:
+ plottype = 'xyplot'
+
+ # Find index of X data in results
+ if plottype == 'histogram':
+ xname = 'RESULT'
+ else:
+ xname = plotrec['xaxis']
+ rlen = len(results[0])
+ try:
+ xidx = next(r for r in range(rlen) if results[0][r] == xname)
+ except StopIteration:
+ return None
+
+ # Find unique values of each variable (except results, traces, and iterations)
+ steps = [[0]]
+ traces = [0]
+ bmatch = binrex.match(results[1][0])
+ if bmatch:
+ digits = bmatch.group(1)
+ if digits == '':
+ digits = len(results[2][0])
+ else:
+ digits = int(digits)
+ cbase = bmatch.group(2)
+ if cbase == 'b':
+ base = 2
+ elif cbase == 'o':
+ base = 8
+ elif cbase == 'd':
+ base = 10
+ else:
+ base = 16
+ binconv = [[base, digits]]
+ else:
+ binconv = [[]]
+
+ for i in range(1, rlen):
+ lsteps = []
+
+ # results labeled 'ITERATIONS', 'RESULT', 'TRACE', or 'TIME' are treated as plot vectors
+ isvector = False
+ if results[0][i] == 'ITERATIONS':
+ isvector = True
+ elif results[0][i] == 'RESULT':
+ isvector = True
+ elif results[0][i] == 'TIME':
+ isvector = True
+ elif results[0][i].split(':')[0] == 'TRACE':
+ isvector = True
+
+ # results whose labels are in the 'variables' list are treated as plot vectors
+ if isvector == False:
+ if variables:
+ try:
+ varrec = next(item for item in variables if item['condition'] == results[0][i])
+ except StopIteration:
+ pass
+ else:
+ isvector = True
+
+ # those results that are not traces are stepped conditions (unless they are constant)
+ if isvector == False:
+ try:
+ for item in list(a[i] for a in results[2:]):
+ if item not in lsteps:
+ lsteps.append(item)
+ except IndexError:
+ # Diagnostic
+ print("Error: Failed to find " + str(i) + " items in result set")
+ print("Results set has " + len(results[0]) + " entries")
+ print(str(results[0]))
+ for x in range(2, len(results)):
+ if len(results[x]) <= i:
+ print("Failed at entry " + str(x))
+ print(str(results[x]))
+ break
+
+ # 'ITERATIONS' and 'TIME' are the x-axis variable, so don't add them to traces
+ # (but maybe just check that xaxis name is not made into a trace?)
+ elif results[0][i] != 'ITERATIONS' and results[0][i] != 'TIME':
+ traces.append(i)
+ steps.append(lsteps)
+
+ # Mark which items need converting from digital. Format is verilog-like. Use
+ # a format width that is larger than the actual number of digits to force
+ # unsigned conversion.
+ bmatch = binrex.match(results[1][i])
+ if bmatch:
+ digits = bmatch.group(1)
+ if digits == '':
+ digits = len(results[2][i])
+ else:
+ digits = int(digits)
+ cbase = bmatch.group(2)
+ if cbase == 'b':
+ base = 2
+ elif cbase == 'o':
+ base = 8
+ elif cbase == 'd':
+ base = 10
+ else:
+ base = 16
+ binconv.append([base, digits])
+ else:
+ binconv.append([])
+
+ # Support older method of declaring a digital vector
+ if xname.split(':')[0] == 'DIGITAL':
+ binconv[xidx] = [2, len(results[2][0])]
+
+ # Which stepped variables (ignoring X axis variable) have more than one value?
+ watchsteps = list(i for i in range(1, rlen) if len(steps[i]) > 1 and i != xidx)
+
+ # Diagnostic
+ # print("Stepped conditions are: ")
+ # for j in watchsteps:
+ # print(results[0][j] + ' (' + str(len(steps[j])) + ' steps)')
+
+ # Collect results. Make a separate record for each unique set of stepped conditions
+ # encountered. Record has (X, Y) vector and a list of conditions.
+ pdata = {}
+ for item in results[2:]:
+ if xname.split(':')[0] == 'DIGITAL' or binconv[xidx] != []:
+ base = binconv[xidx][0]
+ digits = binconv[xidx][1]
+ # Recast binary strings as integers
+ # Watch for strings that have been cast to floats (need to find the source of this)
+ if '.' in item[xidx]:
+ item[xidx] = item[xidx].split('.')[0]
+ a = int(item[xidx], base)
+ b = twos_comp(a, digits)
+ xvalue = b
+ else:
+ xvalue = item[xidx]
+
+ slist = []
+ for j in watchsteps:
+ slist.append(item[j])
+ istr = ','.join(slist)
+ if istr not in pdata:
+ stextlist = []
+ for j in watchsteps:
+ if results[1][j] == '':
+ stextlist.append(results[0][j] + '=' + item[j])
+ else:
+ stextlist.append(results[0][j] + '=' + item[j] + ' ' + results[1][j])
+ pdict = {}
+ pdata[istr] = pdict
+ pdict['xdata'] = []
+ if stextlist:
+ tracelegnd = False
+ else:
+ tracelegnd = True
+
+ for i in traces:
+ aname = 'ydata' + str(i)
+ pdict[aname] = []
+ alabel = 'ylabel' + str(i)
+ tracename = results[0][i]
+ if ':' in tracename:
+ tracename = tracename.split(':')[1]
+
+ if results[1][i] != '' and not binrex.match(results[1][i]):
+ tracename += ' (' + results[1][i] + ')'
+
+ pdict[alabel] = tracename
+
+ pdict['sdata'] = ' '.join(stextlist)
+ else:
+ pdict = pdata[istr]
+ pdict['xdata'].append(xvalue)
+
+ for i in traces:
+ # For each trace, convert the value from digital to integer if needed
+ if binconv[i] != []:
+ base = binconv[i][0]
+ digits = binconv[i][1]
+ a = int(item[i], base)
+ b = twos_comp(a, digits)
+ yvalue = b
+ else:
+ yvalue = item[i]
+
+ aname = 'ydata' + str(i)
+ pdict[aname].append(yvalue)
+
+ fig = Figure()
+ if parent == None:
+ canvas = FigureCanvasAgg(fig)
+ else:
+ canvas = FigureCanvasTkAgg(fig, parent)
+
+ # With no parent, just make one plot and put the legend off to the side. The
+ # 'extra artists' capability of print_figure will take care of the bounding box.
+ # For display, prepare two subplots so that the legend takes up the space of the
+ # second one.
+ if parent == None:
+ ax = fig.add_subplot(111)
+ else:
+ ax = fig.add_subplot(121)
+
+ fig.hold(True)
+ for record in pdata:
+ pdict = pdata[record]
+
+ # Check if xdata is numeric
+ try:
+ test = float(pdict['xdata'][0])
+ except ValueError:
+ numeric = False
+ xdata = [i for i in range(len(pdict['xdata']))]
+ else:
+ numeric = True
+ xdata = list(map(float,pdict['xdata']))
+
+ if plottype == 'histogram':
+ ax.hist(xdata, histtype='barstacked', label=pdict['sdata'], stacked=True)
+ else:
+ for i in traces:
+ aname = 'ydata' + str(i)
+ alabl = 'ylabel' + str(i)
+ ax.plot(xdata, pdict[aname], label=pdict[alabl] + ' ' + pdict['sdata'])
+ # Diagnostic
+ # print("Y values for " + aname + ": " + str(pdict[aname]))
+
+ if not numeric:
+ ax.set_xticks(xdata)
+ ax.set_xticklabels(pdict['xdata'])
+
+ if 'xlabel' in plotrec:
+ if results[1][xidx] == '' or binrex.match(results[1][xidx]):
+ ax.set_xlabel(plotrec['xlabel'])
+ else:
+ ax.set_xlabel(plotrec['xlabel'] + ' (' + results[1][xidx] + ')')
+ else:
+ # Automatically generate X axis label if not given alternate text
+ xtext = results[0][xidx]
+ if results[1][xidx] != '':
+ xtext += ' (' + results[1][xidx] + ')'
+ ax.set_xlabel(xtext)
+
+ if 'ylabel' in plotrec:
+ if results[1][0] == '' or binrex.match(results[1][0]):
+ ax.set_ylabel(plotrec['ylabel'])
+ else:
+ ax.set_ylabel(plotrec['ylabel'] + ' (' + results[1][0] + ')')
+ else:
+ # Automatically generate Y axis label if not given alternate text
+ ytext = results[0][0]
+ if results[1][0] != '' or binrex.match(results[1][0]):
+ ytext += ' (' + results[1][0] + ')'
+ ax.set_ylabel(ytext)
+
+ ax.grid(True)
+ if watchsteps or tracelegnd:
+ legnd = ax.legend(loc = 2, bbox_to_anchor = (1.05, 1), borderaxespad=0.)
+ else:
+ legnd = None
+
+ if legnd:
+ legnd.draggable()
+
+ if parent == None:
+ if not os.path.exists('simulation_files'):
+ os.makedirs('simulation_files')
+
+ filename = 'simulation_files/' + plotrec['filename']
+ # NOTE: print_figure only makes use of bbox_extra_artists if
+ # bbox_inches is set to 'tight'. This forces a two-pass method
+ # that calculates the real maximum bounds of the figure. Otherwise
+ # the legend gets clipped.
+ if legnd:
+ canvas.print_figure(filename, bbox_inches = 'tight',
+ bbox_extra_artists = [legnd])
+ else:
+ canvas.print_figure(filename, bbox_inches = 'tight')
+
+ return canvas
diff --git a/common/consoletext.py b/common/consoletext.py
index 03276fb..820d465 100755
--- a/common/consoletext.py
+++ b/common/consoletext.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/ef/efabless/opengalaxy/venv/bin/python3
#
#--------------------------------------------------------
"""
@@ -16,7 +16,7 @@
import tkinter
class ConsoleText(tkinter.Text):
- linelimit = 500
+ linelimit = 10000
class IORedirector(object):
'''A general class for redirecting I/O to this Text widget.'''
def __init__(self,text_area):
diff --git a/common/create_project.py b/common/create_project.py
index 3c4cb4a..787274f 100755
--- a/common/create_project.py
+++ b/common/create_project.py
@@ -56,8 +56,9 @@
if pdkname:
if pdkname.startswith('/'):
pdkpath = pdkname
+ pdkname = os.path.split(pdkpath)[1]
else:
- pdkpath = os.path.join('PREFIX', 'pdk', pdkname)
+ pdkpath = os.path.join('/usr/share', 'pdk', pdkname)
else:
try:
pdkpath = os.getenv()['PDK_PATH']
@@ -119,6 +120,10 @@
else:
dongspice = True
+ if not os.path.isdir(pdkpath + '/.ef-config') and not os.path.isdir(pdkpath + '/.config'):
+ print('PDK does not contain .config or .ef-config directory, cannot create project.')
+ sys.exit(1)
+
if domagic or donetgen or doxschem or dongspice:
print('Creating project ' + projectname)
os.makedirs(projectpath)
@@ -126,6 +131,14 @@
print('No setup files were found . . . bailing.')
sys.exit(1)
+ if os.path.isdir(pdkpath + '/.ef-config'):
+ os.makedirs(projectpath + '/.ef-config')
+ os.symlink(pdkpath, projectpath + '/.ef-config/techdir')
+ elif os.path.isdir(pdkpath + '/.config'):
+ os.makedirs(projectpath + '/.config')
+ os.symlink(pdkpath, projectpath + '/.config/techdir')
+
+
if domagic:
magpath = os.path.join(projectpath, 'mag')
os.makedirs(magpath)
diff --git a/common/editparam.py b/common/editparam.py
new file mode 100755
index 0000000..30a9d06
--- /dev/null
+++ b/common/editparam.py
@@ -0,0 +1,647 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#-----------------------------------------------------------
+# Parameter editing for the Open Galaxy characterization tool
+#-----------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# March 28, 2017
+# Version 0.1
+#--------------------------------------------------------
+
+import os
+import re
+import tkinter
+from tkinter import ttk
+
+class Condition(object):
+ def __init__(self, parent = None):
+ self.min = tkinter.StringVar(parent)
+ self.typ = tkinter.StringVar(parent)
+ self.max = tkinter.StringVar(parent)
+ self.step = tkinter.StringVar(parent)
+ self.steptype = tkinter.StringVar(parent)
+ self.unit = tkinter.StringVar(parent)
+ self.condition = tkinter.StringVar(parent)
+ self.display = tkinter.StringVar(parent)
+
+class Limit(object):
+ def __init__(self, parent = None):
+ self.target = tkinter.StringVar(parent)
+ self.penalty = tkinter.StringVar(parent)
+ self.calc = tkinter.StringVar(parent)
+ self.limit = tkinter.StringVar(parent)
+
+class EditParam(tkinter.Toplevel):
+ """Characterization tool electrical parameter editor."""
+
+ def __init__(self, parent=None, fontsize = 11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ s.configure('bg.TFrame', background='gray40')
+ self.parent = parent
+ self.withdraw()
+ self.title('Electrical parameter editor')
+ self.sframe = tkinter.Frame(self)
+ self.sframe.grid(column = 0, row = 0, sticky = "news")
+
+ # Keep current parameter
+ self.param = None
+
+ #-------------------------------------------------------------
+ # Add the entries that are common to all electrical parameters
+
+ self.selmethod = tkinter.StringVar(self)
+ self.display = tkinter.StringVar(self)
+ self.unit = tkinter.StringVar(self)
+ self.minrec = Limit(self)
+ self.typrec = Limit(self)
+ self.maxrec = Limit(self)
+ self.cond = []
+
+ #--------------------------------------------------------
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 2, sticky = "news")
+
+ self.bbar.apply_button = ttk.Button(self.bbar, text='Apply',
+ command=self.apply, style = 'normal.TButton')
+ self.bbar.apply_button.grid(column=0, row=0, padx = 5)
+
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=1, row=0, padx = 5)
+
+ self.rowconfigure(0, weight = 1)
+ self.rowconfigure(1, weight = 0)
+ self.columnconfigure(0, weight = 1)
+
+ self.protocol("WM_DELETE_WINDOW", self.close)
+
+ def grid_configure(self, padx, pady):
+ return
+
+ def redisplay(self):
+ return
+
+ def populate(self, param):
+ # Remove all existing contents
+ for widget in self.sframe.winfo_children():
+ widget.destroy()
+
+ # Add major frames
+
+ frame1 = ttk.Frame(self.sframe)
+ frame1.grid(column = 0, row = 0, sticky = 'news')
+ frame2 = ttk.Frame(self.sframe)
+ frame2.grid(column = 0, row = 1, sticky = 'news')
+ frame3 = ttk.Frame(self.sframe)
+ frame3.grid(column = 0, row = 2, sticky = 'news')
+
+ # The Conditions area is the one that grows
+ self.sframe.rowconfigure(2, weight=1)
+ self.sframe.columnconfigure(0, weight=1)
+
+ ttk.Separator(frame3, orient='horizontal').grid(row = 0, column = 0,
+ sticky = 'news')
+
+ # The conditions list can get very big, so build out a
+ # scrolled canvas.
+
+ frame3.canvas = tkinter.Canvas(frame3)
+ frame3.canvas.grid(row = 1, column = 0, sticky = 'nswe')
+ frame3.canvas.dframe = ttk.Frame(frame3.canvas, style='bg.TFrame')
+ # Save the canvas widget, as we need to access it from places like
+ # the scrollbar callbacks.
+ self.canvas = frame3.canvas
+ # Place the frame in the canvas
+ frame3.canvas.create_window((0,0), window=frame3.canvas.dframe,
+ anchor="nw")
+ # Make sure the main window resizes, not the scrollbars.
+ frame3.rowconfigure(1, weight=1)
+ frame3.columnconfigure(0, weight = 1)
+ # X scrollbar for conditions list
+ main_xscrollbar = ttk.Scrollbar(frame3, orient = 'horizontal')
+ main_xscrollbar.grid(row = 2, column = 0, sticky = 'nswe')
+ # Y scrollbar for conditions list
+ main_yscrollbar = ttk.Scrollbar(frame3, orient = 'vertical')
+ main_yscrollbar.grid(row = 1, column = 1, sticky = 'nswe')
+ # Attach console to scrollbars
+ frame3.canvas.config(xscrollcommand = main_xscrollbar.set)
+ main_xscrollbar.config(command = frame3.canvas.xview)
+ frame3.canvas.config(yscrollcommand = main_yscrollbar.set)
+ main_yscrollbar.config(command = frame3.canvas.yview)
+
+ # Make sure that scrollwheel pans the window
+ frame3.canvas.bind_all("<Button-4>", self.on_mousewheel)
+ frame3.canvas.bind_all("<Button-5>", self.on_mousewheel)
+
+ # Set up configure callback
+ frame3.canvas.dframe.bind("<Configure>", self.frame_configure)
+
+ # Get list of methods from testbench folder
+ dspath = os.path.split(self.parent.cur_datasheet)[0]
+ tbpath = dspath + '/testbench'
+ tbfiles = os.listdir(tbpath)
+ methods = []
+ for spifile in tbfiles:
+ if os.path.splitext(spifile)[1] == '.spi':
+ methods.append(os.path.splitext(spifile)[0].upper())
+
+ # Get list of pins from parent datasheet
+ dsheet = self.parent.datatop['data-sheet']
+ pins = dsheet['pins']
+ pinlist = []
+ for pin in pins:
+ pinlist.append(pin['name'])
+ pinlist.append('(none)')
+
+ # Add common elements
+ frame1.ldisplay = ttk.Label(frame1, text='Description:',
+ style= 'blue.TLabel', anchor = 'e')
+ frame1.lmethod = ttk.Label(frame1, text='Method:',
+ style= 'blue.TLabel', anchor = 'e')
+ frame1.lunit = ttk.Label(frame1, text='Unit:',
+ style= 'blue.TLabel', anchor = 'e')
+
+ # If 'pin' exists (old style), append it to 'condition' and remove.
+ if 'pin' in param:
+ if 'method' in param and ':' not in param['method']:
+ param['method'] += ':' + param['pin']
+ param.pop('pin', 0)
+
+ # Find method and apply to OptionMenu
+ if 'method' in param:
+ self.selmethod.set(param['method'])
+ else:
+ self.selmethod.set('(none)')
+
+
+ frame1.display = ttk.Entry(frame1, textvariable = self.display)
+ frame1.method = ttk.OptionMenu(frame1, self.selmethod, self.selmethod.get(), *methods)
+ frame1.unit = ttk.Entry(frame1, textvariable = self.unit)
+
+ frame1.ldisplay.grid(column = 0, row = 0, sticky = 'news', padx=5, pady=5)
+ frame1.display.grid(column = 1, row = 0, sticky = 'news', padx=5, pady=3)
+ frame1.lmethod.grid(column = 0, row = 1, sticky = 'news', padx=5, pady=5)
+ frame1.method.grid(column = 1, row = 1, sticky = 'news', padx=5, pady=3)
+ frame1.lunit.grid(column = 0, row = 2, sticky = 'news', padx=5, pady=5)
+ frame1.unit.grid(column = 1, row = 2, sticky = 'news', padx=5, pady=3)
+
+ frame1.columnconfigure(0, weight = 0)
+ frame1.columnconfigure(1, weight = 1)
+
+ frame1.display.delete(0, 'end')
+ if 'display' in param:
+ frame1.display.insert(0, param['display'])
+ else:
+ frame1.display.insert(0, '(none)')
+
+ frame1.unit.delete(0, 'end')
+ if 'unit' in param:
+ frame1.unit.insert(0, param['unit'])
+ else:
+ frame1.unit.insert(0, '(none)')
+
+ ttk.Separator(frame1, orient='horizontal').grid(row = 4, column = 0,
+ columnspan = 2, sticky = 'nsew')
+
+ # Calculation types
+ calctypes = ["min", "max", "avg", "diffmin", "diffmax", "(none)"]
+ limittypes = ["above", "below", "exact", "legacy", "(none)"]
+
+ # Add min/typ/max (To-do: Add plot)
+
+ frame2min = ttk.Frame(frame2, borderwidth = 2, relief='groove')
+ frame2min.grid(row = 0, column = 0, padx = 2, pady = 2, sticky = 'news')
+ ttk.Label(frame2min, text="Minimum:", style = 'blue.TLabel',
+ anchor = 'w').grid(row = 0, column = 0, padx = 5,
+ sticky = 'news')
+ if 'min' in param:
+ minrec = param['min']
+ else:
+ minrec = {}
+ ttk.Label(frame2min, text="Target:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 1, column = 0, padx = 5,
+ sticky = 'news')
+ frame2min.tmin = ttk.Entry(frame2min, textvariable = self.minrec.target)
+ frame2min.tmin.grid(row = 1, column = 1, padx = 5, sticky = 'news')
+ frame2min.tmin.delete(0, 'end')
+ if 'target' in minrec:
+ frame2min.tmin.insert(0, minrec['target'])
+ ttk.Label(frame2min, text="Penalty:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 2, column = 0, padx = 5,
+ sticky = 'news')
+ frame2min.pmin = ttk.Entry(frame2min, textvariable = self.minrec.penalty)
+ frame2min.pmin.grid(row = 2, column = 1, padx = 5, sticky = 'news')
+ frame2min.pmin.delete(0, 'end')
+ if 'penalty' in minrec:
+ frame2min.pmin.insert(0, minrec['penalty'])
+ if 'calc' in minrec:
+ calcrec = minrec['calc']
+ try:
+ calctype, limittype = calcrec.split('-')
+ except ValueError:
+ calctype = calcrec
+ if calctype == 'min':
+ limittype = 'above'
+ elif calctype == 'max':
+ limittype = 'below'
+ elif calctype == 'avg':
+ limittype = 'exact'
+ elif calctype == 'diffmin':
+ limittype = 'above'
+ elif calctype == 'diffmax':
+ limittype = 'below'
+ else:
+ limittype = '(none)'
+ else:
+ calctype = 'min'
+ limittype = 'above'
+
+ ttk.Label(frame2min, text="Calculation:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 3, column = 0, padx = 5,
+ sticky = 'news')
+ self.cmin = tkinter.StringVar(self)
+ self.cmin.set(calctype)
+ frame2min.cmin = ttk.OptionMenu(frame2min, self.cmin, calctype, *calctypes)
+ frame2min.cmin.grid(row = 3, column = 1, padx = 5, sticky = 'news')
+ ttk.Label(frame2min, text="Limit:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 4, column = 0, padx = 5,
+ sticky = 'news')
+ self.lmin = tkinter.StringVar(self)
+ self.lmin.set(limittype)
+ frame2min.lmin = ttk.OptionMenu(frame2min, self.lmin, limittype, *limittypes)
+ frame2min.lmin.grid(row = 4, column = 1, padx = 5, sticky = 'news')
+
+ frame2typ = ttk.Frame(frame2, borderwidth = 2, relief='groove')
+ frame2typ.grid(row = 0, column = 1, padx = 2, pady = 2, sticky = 'news')
+ ttk.Label(frame2typ, text="Typical:", style = 'blue.TLabel',
+ anchor = 'w').grid(row = 0, column = 0, padx = 5,
+ sticky = 'news')
+ if 'typ' in param:
+ typrec = param['typ']
+ else:
+ typrec = {}
+ ttk.Label(frame2typ, text="Target:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 1, column = 0, padx = 5,
+ sticky = 'news')
+ frame2typ.ttyp = ttk.Entry(frame2typ, textvariable = self.typrec.target)
+ frame2typ.ttyp.grid(row = 1, column = 1, padx = 5, sticky = 'news')
+ frame2typ.ttyp.delete(0, 'end')
+ if 'target' in typrec:
+ frame2typ.ttyp.insert(0, typrec['target'])
+ ttk.Label(frame2typ, text="Penalty:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 2, column = 0, padx = 5,
+ sticky = 'news')
+ frame2typ.ptyp = ttk.Entry(frame2typ, textvariable = self.typrec.penalty)
+ frame2typ.ptyp.grid(row = 2, column = 1, padx = 5, sticky = 'news')
+ frame2typ.ptyp.delete(0, 'end')
+ if 'penalty' in typrec:
+ frame2typ.ptyp.insert(0, typrec['penalty'])
+ if 'calc' in typrec:
+ calcrec = typrec['calc']
+ try:
+ calctype, limittype = calcrec.split('-')
+ except ValueError:
+ calctype = calcrec
+ if calctype == 'min':
+ limittype = 'above'
+ elif calctype == 'max':
+ limittype = 'below'
+ elif calctype == 'avg':
+ limittype = 'exact'
+ elif calctype == 'diffmin':
+ limittype = 'above'
+ elif calctype == 'diffmax':
+ limittype = 'below'
+ else:
+ limittype = '(none)'
+ else:
+ calctype = 'avg'
+ limittype = 'exact'
+
+ ttk.Label(frame2typ, text="Calculation:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 3, column = 0, padx = 5,
+ sticky = 'news')
+ self.ctyp = tkinter.StringVar(self)
+ self.ctyp.set(calctype)
+ frame2typ.ctyp = ttk.OptionMenu(frame2typ, self.ctyp, calctype, *calctypes)
+ frame2typ.ctyp.grid(row = 3, column = 1, padx = 5, sticky = 'news')
+ ttk.Label(frame2typ, text="Limit:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 4, column = 0, padx = 5,
+ sticky = 'news')
+ self.ltyp = tkinter.StringVar(self)
+ self.ltyp.set(limittype)
+ frame2typ.ltyp = ttk.OptionMenu(frame2typ, self.ltyp, limittype, *limittypes)
+ frame2typ.ltyp.grid(row = 4, column = 1, padx = 5, sticky = 'news')
+
+ frame2max = ttk.Frame(frame2, borderwidth = 2, relief='groove')
+ frame2max.grid(row = 0, column = 2, padx = 2, pady = 2, sticky = 'news')
+ ttk.Label(frame2max, text="Maximum:", style = 'blue.TLabel',
+ anchor = 'w').grid(row = 0, column = 0, padx = 5,
+ sticky = 'news')
+ if 'max' in param:
+ maxrec = param['max']
+ else:
+ maxrec = {}
+ ttk.Label(frame2max, text="Target:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 1, column = 0, padx = 5,
+ sticky = 'news')
+ frame2max.tmax = ttk.Entry(frame2max, textvariable = self.maxrec.target)
+ frame2max.tmax.grid(row = 1, column = 1, padx = 5, sticky = 'news')
+ frame2max.tmax.delete(0, 'end')
+ if 'target' in maxrec:
+ frame2max.tmax.insert(0, maxrec['target'])
+ ttk.Label(frame2max, text="Penalty:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 2, column = 0, padx = 5,
+ sticky = 'news')
+ frame2max.pmax = ttk.Entry(frame2max, textvariable = self.maxrec.penalty)
+ frame2max.pmax.grid(row = 2, column = 1, padx = 5, sticky = 'news')
+ frame2max.pmax.delete(0, 'end')
+ if 'penalty' in maxrec:
+ frame2max.pmax.insert(0, maxrec['penalty'])
+ if 'calc' in maxrec:
+ calcrec = maxrec['calc']
+ try:
+ calctype, limittype = calcrec.split('-')
+ except ValueError:
+ calctype = calcrec
+ if calctype == 'min':
+ limittype = 'above'
+ elif calctype == 'max':
+ limittype = 'below'
+ elif calctype == 'avg':
+ limittype = 'exact'
+ elif calctype == 'diffmin':
+ limittype = 'above'
+ elif calctype == 'diffmax':
+ limittype = 'below'
+ else:
+ limittype = '(none)'
+ else:
+ calctype = 'max'
+ limittype = 'below'
+
+ ttk.Label(frame2max, text="Calculation:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 3, column = 0, padx = 5,
+ sticky = 'news')
+ self.cmax = tkinter.StringVar(self)
+ self.cmax.set(calctype)
+ frame2max.cmax = ttk.OptionMenu(frame2max, self.cmax, calctype, *calctypes)
+ frame2max.cmax.grid(row = 3, column = 1, padx = 5, sticky = 'news')
+ ttk.Label(frame2max, text="Limit:", anchor = 'e',
+ style = 'normal.TLabel').grid(row = 4, column = 0, padx = 5,
+ sticky = 'news')
+ self.lmax = tkinter.StringVar(self)
+ self.lmax.set(limittype)
+ frame2max.lmax = ttk.OptionMenu(frame2max, self.lmax, limittype, *limittypes)
+ frame2max.lmax.grid(row = 4, column = 1, padx = 5, sticky = 'news')
+
+ dframe = frame3.canvas.dframe
+
+ ttk.Label(dframe, text="Conditions:", style = 'blue.TLabel',
+ anchor='w').grid(row = 0, column = 0, padx = 5, sticky = 'news', columnspan = 5)
+
+ # Add conditions
+
+ condtypes = ["VOLTAGE", "DIGITAL", "CURRENT", "RISETIME", "FALLTIME",
+ "RESISTANCE", "CAPACITANCE", "TEMPERATURE", "FREQUENCY",
+ "CORNER", "SIGMA", "ITERATIONS", "(none)"]
+
+ steptypes = ['linear', 'log', '(none)']
+
+ n = 0
+ r = 1
+ self.crec = []
+ self.cond = []
+ for cond in param['conditions']:
+ # If over 5 columns of conditions, create a new row.
+ if n >= 5:
+ r += 1
+ n = 0
+ # New column
+ frame3c = ttk.Frame(dframe, borderwidth = 2, relief='groove')
+ frame3c.grid(row = r, column = n, padx = 2, pady = 2, sticky = 'news')
+
+ crec = Condition(self)
+ # Condition description
+ ttk.Label(frame3c, text='Description:', style='normal.TLabel',
+ anchor='e').grid(row = 0, column = 0, padx = 5, sticky = 'news')
+ c1 = ttk.Entry(frame3c, textvariable = crec.display)
+ c1.grid(row = 0, column = 1, padx = 5, sticky = 'news')
+ c1.delete(0, 'end')
+ if 'display' in cond:
+ c1.insert(0, cond['display'])
+ else:
+ c1.insert(0, '(none)')
+ # Condition type (pulldown menu)
+ if 'condition' in cond:
+ crec.condition.set(cond['condition'])
+ else:
+ crec.condition.set('(none)')
+ ttk.Label(frame3c, text='Condition:', style='normal.TLabel',
+ anchor='e').grid(row = 1, column = 0, padx = 5, sticky = 'news')
+ c2 = ttk.OptionMenu(frame3c, crec.condition, crec.condition.get(), *condtypes)
+ c2.grid(row = 1, column = 1, padx = 5, sticky = 'news')
+ # Condition unit
+ ttk.Label(frame3c, text='Unit:', style='normal.TLabel',
+ anchor='e').grid(row = 3, column = 0, padx = 5, sticky = 'news')
+ c4 = ttk.Entry(frame3c, textvariable = crec.unit)
+ c4.grid(row = 3, column = 1, padx = 5, sticky = 'news')
+ c4.delete(0, 'end')
+ if 'unit' in cond:
+ c4.insert(0, cond['unit'])
+ else:
+ c4.insert(0, '(none)')
+ # Condition min
+ ttk.Label(frame3c, text='Minimum:', style='normal.TLabel',
+ anchor='e').grid(row = 4, column = 0, padx = 5, sticky = 'news')
+ c5 = ttk.Entry(frame3c, textvariable = crec.min)
+ c5.grid(row = 4, column = 1, padx = 5, sticky = 'news')
+ c5.delete(0, 'end')
+ if 'min' in cond:
+ c5.insert(0, cond['min'])
+ else:
+ c5.insert(0, '(none)')
+ # Condition typ
+ ttk.Label(frame3c, text='Typical:', style='normal.TLabel',
+ anchor='e').grid(row = 5, column = 0, padx = 5, sticky = 'news')
+ c6 = ttk.Entry(frame3c, textvariable = crec.typ)
+ c6.grid(row = 5, column = 1, padx = 5, sticky = 'news')
+ c6.delete(0, 'end')
+ if 'typ' in cond:
+ c6.insert(0, cond['typ'])
+ else:
+ c6.insert(0, '(none)')
+ # Condition max
+ ttk.Label(frame3c, text='Maximum:', style='normal.TLabel',
+ anchor='e').grid(row = 6, column = 0, padx = 5, sticky = 'news')
+ c7 = ttk.Entry(frame3c, textvariable = crec.max)
+ c7.grid(row = 6, column = 1, padx = 5, sticky = 'news')
+ c7.delete(0, 'end')
+ if 'max' in cond:
+ c7.insert(0, cond['max'])
+ else:
+ c7.insert(0, '(none)')
+ # Condition steptype
+ ttk.Label(frame3c, text='Step type:', style='normal.TLabel',
+ anchor='e').grid(row = 7, column = 0, padx = 5, sticky = 'news')
+ c8 = ttk.OptionMenu(frame3c, crec.steptype, crec.steptype.get(), *steptypes)
+ c8.grid(row = 7, column = 1, padx = 5, sticky = 'news')
+ if 'linstep' in cond:
+ crec.steptype.set('linear')
+ elif 'logstep' in cond:
+ crec.steptype.set('log')
+ else:
+ crec.steptype.set('(none)')
+ # Condition step
+ ttk.Label(frame3c, text='Step:', style='normal.TLabel',
+ anchor='e').grid(row = 8, column = 0, padx = 5, sticky = 'news')
+ c9 = ttk.Entry(frame3c, textvariable = crec.step)
+ c9.grid(row = 8, column = 1, padx = 5, sticky = 'news')
+ c9.delete(0, 'end')
+ if 'linstep' in cond:
+ c9.insert(0, cond['linstep'])
+ elif 'logstep' in cond:
+ c9.insert(0, cond['logstep'])
+ else:
+ c9.insert(0, '(none)')
+
+ n += 1
+ self.cond.append(crec)
+ # Condition remove
+ c10 = ttk.Button(frame3c, text='Remove', style='normal.TButton',
+ command = lambda cond=cond: self.remove_condition(cond))
+ c10.grid(row = 9, column = 1, padx = 5, sticky = 'news')
+
+ # Add 'add condition' button
+ dframe.bcond = ttk.Button(dframe, text="Add Condition",
+ style = 'blue.TButton', command = self.add_condition)
+ if n >= 5:
+ dframe.bcond.grid(row = r + 1, column = 0, padx = 5, pady = 3, sticky = 'nsw')
+ else:
+ dframe.bcond.grid(row = r, column = n, padx = 5, pady = 3, sticky = 'new')
+
+ # Set the current parameter
+ self.param = param
+
+ def on_mousewheel(self, event):
+ if event.num == 5:
+ self.canvas.yview_scroll(1, "units")
+ elif event.num == 4:
+ self.canvas.yview_scroll(-1, "units")
+
+ def frame_configure(self, event):
+ self.update_idletasks()
+ self.canvas.configure(scrollregion=self.canvas.bbox("all"))
+
+ def add_condition(self):
+ # Add a new condition
+ newcond = {}
+ newcond['condition'] = '(none)'
+ self.param['conditions'].append(newcond)
+ self.populate(self.param)
+
+ def remove_condition(self, cond):
+ # Remove and existing condition
+ condlist = self.param['conditions']
+ eidx = condlist.index(cond)
+ condlist.pop(eidx)
+ self.populate(self.param)
+
+ def apply(self):
+ # Apply the values back to the parameter record
+ self.param['method'] = self.selmethod.get()
+ unit = self.unit.get()
+ if not (unit == '(none)' or unit == ''):
+ self.param['unit'] = unit
+ display = self.display.get()
+ if not (display == '(none)' or display == ''):
+ self.param['display'] = display
+ targmin = self.minrec.target.get()
+ if not (targmin == '(none)' or targmin == ''):
+ pmin = {}
+ pmin['target'] = targmin
+ pmin['penalty'] = self.minrec.penalty.get()
+ cmin = self.minrec.calc.get()
+ if not (cmin == '(none)' or cmin == ''):
+ lmin = self.minrec.limit.get()
+ if not (lmin == '(none)' or lmin == ''):
+ pmin['calc'] = cmin + '-' + lmin
+ else:
+ pmin['calc'] = cmin
+ self.param['min'] = pmin
+ targtyp = self.typrec.target.get()
+ if not (targtyp == '(none)' or targtyp == ''):
+ ptyp= {}
+ ptyp['target'] = targtyp
+ ptyp['penalty'] = self.typrec.penalty.get()
+ ctyp = self.typrec.calc.get()
+ if not (ctyp == '(none)' or ctyp == ''):
+ ltyp = self.typrec.limit.get()
+ if not (ltyp == '(none)' or ltyp == ''):
+ ptyp['calc'] = ctyp + '-' + ltyp
+ else:
+ ptyp['calc'] = ctyp
+ self.param['typ'] = ptyp
+ targmax = self.maxrec.target.get()
+ if not (targmax == '(none)' or targmax == ''):
+ pmax= {}
+ pmax['target'] = targmax
+ pmax['penalty'] = self.maxrec.penalty.get()
+ cmax = self.maxrec.calc.get()
+ if not (cmax == '(none)' or cmax == ''):
+ lmax = self.maxrec.limit.get()
+ if not (lmax == '(none)' or lmax == ''):
+ pmax['calc'] = cmax + '-' + lmax
+ else:
+ pmax['calc'] = cmax
+ self.param['max'] = pmax
+
+ condlist = []
+ for crec in self.cond:
+ cond = {}
+ cname = crec.condition.get()
+ if cname == '(none)' or cname == '':
+ continue
+ cond['condition'] = cname
+ display = crec.display.get()
+ if not (display == '(none)' or display == ''):
+ cond['display'] = display
+ min = crec.min.get()
+ if not (min == '(none)' or min == ''):
+ cond['min'] = min
+ typ = crec.typ.get()
+ if not (typ == '(none)' or typ == ''):
+ cond['typ'] = typ
+ max = crec.max.get()
+ if not (max == '(none)' or max == ''):
+ cond['max'] = max
+ unit = crec.unit.get()
+ if not (unit == '(none)' or unit == ''):
+ cond['unit'] = unit
+ steptype = crec.steptype.get()
+ step = crec.step.get()
+ if not (step == '(none)' or step == ''):
+ if steptype == 'linear':
+ cond['linstep'] = step
+ elif steptype == 'log':
+ cond['logstep'] = step
+ condlist.append(cond)
+ self.param['conditions'] = condlist
+
+ self.parent.create_datasheet_view()
+ return
+
+ def close(self):
+ # pop down settings window
+ self.withdraw()
+
+ def open(self):
+ # pop up settings window
+ self.deiconify()
+ self.lift()
diff --git a/common/failreport.py b/common/failreport.py
new file mode 100755
index 0000000..7a1159b
--- /dev/null
+++ b/common/failreport.py
@@ -0,0 +1,534 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#--------------------------------------------------------------------
+# Characterization Report Window for the Open Galaxy project manager
+#
+#--------------------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# September 12, 2016
+# Version 0.1
+#----------------------------------------------------------
+
+import os
+import base64
+import subprocess
+
+import tkinter
+from tkinter import ttk
+
+import tooltip
+import cace_makeplot
+
+class FailReport(tkinter.Toplevel):
+ """Open Galaxy failure report window."""
+
+ def __init__(self, parent=None, fontsize=11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('bg.TFrame', background='gray40')
+ s.configure('italic.TLabel', font=('Helvetica', fontsize, 'italic'), anchor = 'west')
+ s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'brown', anchor = 'center')
+ s.configure('normal.TLabel', font=('Helvetica', fontsize))
+ s.configure('red.TLabel', font=('Helvetica', fontsize), foreground = 'red')
+ s.configure('green.TLabel', font=('Helvetica', fontsize), foreground = 'green4')
+ s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue')
+ s.configure('brown.TLabel', font=('Helvetica', fontsize, 'italic'),
+ foreground = 'brown', anchor = 'center')
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3,
+ relief = 'raised')
+ s.configure('red.TButton', font=('Helvetica', fontsize), foreground = 'red',
+ border = 3, relief = 'raised')
+ s.configure('green.TButton', font=('Helvetica', fontsize), foreground = 'green4',
+ border = 3, relief = 'raised')
+ s.configure('title.TButton', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'brown', border = 0, relief = 'groove')
+
+ self.withdraw()
+ self.title('Open Galaxy Local Characterization Report')
+ self.root = parent.root
+ self.rowconfigure(0, weight = 1)
+ self.columnconfigure(0, weight = 1)
+
+ # Scrolled frame: Need frame, then canvas and scrollbars; finally, the
+ # actual grid of results gets placed in the canvas.
+ self.failframe = ttk.Frame(self)
+ self.failframe.grid(column = 0, row = 0, sticky = 'nsew')
+ self.mainarea = tkinter.Canvas(self.failframe)
+ self.mainarea.grid(row = 0, column = 0, sticky = 'nsew')
+
+ self.mainarea.faildisplay = ttk.Frame(self.mainarea)
+ self.mainarea.create_window((0,0), window=self.mainarea.faildisplay,
+ anchor="nw", tags="self.frame")
+
+ # Create a frame for displaying plots, but don't put it in the grid.
+ # Make it resizeable.
+ self.plotframe = ttk.Frame(self)
+ self.plotframe.rowconfigure(0, weight = 1)
+ self.plotframe.columnconfigure(0, weight = 1)
+
+ # Main window resizes, not the scrollbars
+ self.failframe.rowconfigure(0, weight = 1)
+ self.failframe.columnconfigure(0, weight = 1)
+ # Add scrollbars
+ xscrollbar = ttk.Scrollbar(self.failframe, orient = 'horizontal')
+ xscrollbar.grid(row = 1, column = 0, sticky = 'nsew')
+ yscrollbar = ttk.Scrollbar(self.failframe, orient = 'vertical')
+ yscrollbar.grid(row = 0, column = 1, sticky = 'nsew')
+ # Attach viewing area to scrollbars
+ self.mainarea.config(xscrollcommand = xscrollbar.set)
+ xscrollbar.config(command = self.mainarea.xview)
+ self.mainarea.config(yscrollcommand = yscrollbar.set)
+ yscrollbar.config(command = self.mainarea.yview)
+ # Set up configure callback
+ self.mainarea.faildisplay.bind("<Configure>", self.frame_configure)
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 1, sticky = "news")
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=0, row=0, padx = 5)
+ # Table button returns to table view but is only displayed for plots.
+ self.bbar.table_button = ttk.Button(self.bbar, text='Table', style = 'normal.TButton')
+
+ self.protocol("WM_DELETE_WINDOW", self.close)
+ tooltip.ToolTip(self.bbar.close_button,
+ text='Close detail view of conditions and results')
+
+ self.sortdir = False
+ self.data = []
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def frame_configure(self, event):
+ self.update_idletasks()
+ self.mainarea.configure(scrollregion=self.mainarea.bbox("all"))
+
+ def check_failure(self, record, calc, value):
+ if not 'target' in record:
+ return None
+ else:
+ target = record['target']
+
+ if calc == 'min':
+ targval = float(target)
+ if value < targval:
+ return True
+ elif calc == 'max':
+ targval = float(target)
+ if value > targval:
+ return True
+ else:
+ return None
+
+ # Given an electrical parameter 'param' and a condition name 'condname', find
+ # the units of that condition. If the condition isn't found in the local
+ # parameters, then it is searched for in 'globcond'.
+
+ def findunit(self, condname, param, globcond):
+ unit = ''
+ try:
+ loccond = next(item for item in param['conditions'] if item['condition'] == condname)
+ except StopIteration:
+ try:
+ globitem = next(item for item in globcond if item['condition'] == condname)
+ except (TypeError, StopIteration):
+ unit = '' # No units
+ else:
+ if 'unit' in globitem:
+ unit = globitem['unit']
+ else:
+ unit = '' # No units
+ else:
+ if 'unit' in loccond:
+ unit = loccond['unit']
+ else:
+ unit = '' # No units
+ return unit
+
+ def size_plotreport(self):
+ self.update_idletasks()
+ width = self.plotframe.winfo_width()
+ height = self.plotframe.winfo_height()
+ if width < 3 * height:
+ self.plotframe.configure(width=height * 3)
+
+ def size_failreport(self):
+ # Attempt to set the datasheet viewer width to the interior width
+ # but do not set it larger than the available desktop.
+
+ self.update_idletasks()
+ width = self.mainarea.faildisplay.winfo_width()
+ screen_width = self.root.winfo_screenwidth()
+ if width > screen_width - 20:
+ self.mainarea.configure(width=screen_width - 20)
+ else:
+ self.mainarea.configure(width=width)
+
+ # Likewise for the height, up to the desktop height. Note that this
+ # needs to account for both the button bar at the bottom of the GUI
+ # window plus the bar at the bottom of the desktop.
+ height = self.mainarea.faildisplay.winfo_height()
+ screen_height = self.root.winfo_screenheight()
+ if height > screen_height - 120:
+ self.mainarea.configure(height=screen_height - 120)
+ else:
+ self.mainarea.configure(height=height)
+
+ def table_to_histogram(self, globcond, filename):
+ # Switch from a table view to a histogram plot view, using the
+ # result as the X axis variable and count for the Y axis.
+
+ # Destroy existing contents.
+ for widget in self.plotframe.winfo_children():
+ widget.destroy()
+
+ param = self.data
+ plotrec = {}
+ plotrec['xaxis'] = param['method']
+ plotrec['xlabel'] = param['method']
+ plotrec['ylabel'] = 'COUNT'
+ plotrec['type'] = 'histogram'
+ if 'unit' in param:
+ plotrec['xlabel'] += ' (' + param['unit'] + ')'
+
+ results = param['results']
+
+ if 'variables' in param:
+ variables = param['variables']
+ else:
+ variables = []
+ # faild = self.mainarea.faildisplay # definition for convenience
+ self.failframe.grid_forget()
+ self.plotframe.grid(row = 0, column = 0, sticky = 'nsew')
+ canvas = cace_makeplot.makeplot(plotrec, results, variables, parent = self.plotframe)
+ if 'display' in param:
+ ttk.Label(self.plotframe, text=param['display'], style='title.TLabel').grid(row=1, column=0)
+ canvas.show()
+ canvas.get_tk_widget().grid(row=0, column=0, sticky = 'nsew')
+ # Finally, open the window if it was not already open.
+ self.open()
+
+ def table_to_plot(self, condition, globcond, filename):
+ # Switch from a table view to a plot view, using the condname as
+ # the X axis variable.
+
+ # Destroy existing contents.
+ for widget in self.plotframe.winfo_children():
+ widget.destroy()
+
+ param = self.data
+ plotrec = {}
+ plotrec['xaxis'] = condition
+ plotrec['xlabel'] = condition
+ # Note: cace_makeplot adds text for units, if available
+ plotrec['ylabel'] = param['method']
+ plotrec['type'] = 'xyplot'
+
+ results = param['results']
+
+ if 'variables' in param:
+ variables = param['variables']
+ else:
+ variables = []
+
+ # faild = self.mainarea.faildisplay # definition for convenience
+ self.failframe.grid_forget()
+ self.plotframe.grid(row = 0, column = 0, sticky = 'nsew')
+ canvas = cace_makeplot.makeplot(plotrec, results, variables, parent = self.plotframe)
+ if 'display' in param:
+ ttk.Label(self.plotframe, text=param['display'], style='title.TLabel').grid(row=1, column=0)
+ canvas.show()
+ canvas.get_tk_widget().grid(row=0, column=0, sticky = 'nsew')
+ # Display the button to return to the table view
+ # except for transient and Monte Carlo simulations which are too large to tabulate.
+ if not condition == 'TIME':
+ self.bbar.table_button.grid(column=1, row=0, padx = 5)
+ self.bbar.table_button.configure(command=lambda param=param, globcond=globcond,
+ filename=filename: self.display(param, globcond, filename))
+
+ # Finally, open the window if it was not already open.
+ self.open()
+
+ def display(self, param=None, globcond=None, filename=None):
+ # (Diagnostic)
+ # print('failure report: passed parameter ' + str(param))
+
+ # Destroy existing contents.
+ for widget in self.mainarea.faildisplay.winfo_children():
+ widget.destroy()
+
+ if not param:
+ param = self.data
+
+ # 'param' is a dictionary pulled in from the annotate datasheet.
+ # If the failure display was called, then 'param' should contain
+ # record called 'results'. If the parameter has no results, then
+ # there is nothing to do.
+
+ if filename and 'plot' in param:
+ simfiles = os.path.split(filename)[0] + '/ngspice/char/simulation_files/'
+ self.failframe.grid_forget()
+ self.plotframe.grid(row = 0, column = 0, sticky = 'nsew')
+
+ # Clear the plotframe and remake
+ for widget in self.plotframe.winfo_children():
+ widget.destroy()
+
+ plotrec = param['plot']
+ results = param['results']
+ if 'variables' in param:
+ variables = param['variables']
+ else:
+ variables = []
+ canvas = cace_makeplot.makeplot(plotrec, results, variables, parent = self.plotframe)
+ if 'display' in param:
+ ttk.Label(self.plotframe, text=param['display'],
+ style='title.TLabel').grid(row=1, column=0)
+ canvas.show()
+ canvas.get_tk_widget().grid(row=0, column=0, sticky = 'nsew')
+ self.data = param
+ # Display the button to return to the table view
+ self.bbar.table_button.grid(column=1, row=0, padx = 5)
+ self.bbar.table_button.configure(command=lambda param=param, globcond=globcond,
+ filename=filename: self.display(param, globcond, filename))
+
+ elif not 'results' in param:
+ print("No results to build a report with.")
+ return
+
+ else:
+ self.data = param
+ self.plotframe.grid_forget()
+ self.failframe.grid(column = 0, row = 0, sticky = 'nsew')
+ faild = self.mainarea.faildisplay # definition for convenience
+ results = param['results']
+ names = results[0]
+ units = results[1]
+ results = results[2:]
+
+ # Check for transient simulation
+ if 'TIME' in names:
+ # Transient data are (usually) too numerous to tabulate, so go straight to plot
+ self.table_to_plot('TIME', globcond, filename)
+ return
+
+ # Check for Monte Carlo simulation
+ if 'ITERATIONS' in names:
+ # Monte Carlo data are too numerous to tabulate, so go straight to plot
+ self.table_to_histogram(globcond, filename)
+ return
+
+ # Numerically sort by result (to be done: sort according to up/down
+ # criteria, which will be retained per header entry)
+ results.sort(key = lambda row: float(row[0]), reverse = self.sortdir)
+
+ # To get ranges, transpose the results matrix, then make unique
+ ranges = list(map(list, zip(*results)))
+ for r, vrange in enumerate(ranges):
+ try:
+ vmin = min(float(v) for v in vrange)
+ vmax = max(float(v) for v in vrange)
+ if vmin == vmax:
+ ranges[r] = [str(vmin)]
+ else:
+ ranges[r] = [str(vmin), str(vmax)]
+ except ValueError:
+ ranges[r] = list(set(vrange))
+ pass
+
+ faild.titlebar = ttk.Frame(faild)
+ faild.titlebar.grid(row = 0, column = 0, sticky = 'ewns')
+
+ faild.titlebar.label1 = ttk.Label(faild.titlebar, text = 'Electrical Parameter: ',
+ style = 'italic.TLabel')
+ faild.titlebar.label1.pack(side = 'left', padx = 6, ipadx = 3)
+ if 'display' in param:
+ faild.titlebar.label2 = ttk.Label(faild.titlebar, text = param['display'],
+ style = 'normal.TLabel')
+ faild.titlebar.label2.pack(side = 'left', padx = 6, ipadx = 3)
+ faild.titlebar.label3 = ttk.Label(faild.titlebar, text = ' Method: ',
+ style = 'italic.TLabel')
+ faild.titlebar.label3.pack(side = 'left', padx = 6, ipadx = 3)
+ faild.titlebar.label4 = ttk.Label(faild.titlebar, text = param['method'],
+ style = 'normal.TLabel')
+ faild.titlebar.label4.pack(side = 'left', padx = 6, ipadx = 3)
+
+ if 'min' in param:
+ if 'target' in param['min']:
+ faild.titlebar.label7 = ttk.Label(faild.titlebar, text = ' Min Limit: ',
+ style = 'italic.TLabel')
+ faild.titlebar.label7.pack(side = 'left', padx = 3, ipadx = 3)
+ faild.titlebar.label8 = ttk.Label(faild.titlebar, text = param['min']['target'],
+ style = 'normal.TLabel')
+ faild.titlebar.label8.pack(side = 'left', padx = 6, ipadx = 3)
+ if 'unit' in param:
+ faild.titlebar.label9 = ttk.Label(faild.titlebar, text = param['unit'],
+ style = 'italic.TLabel')
+ faild.titlebar.label9.pack(side = 'left', padx = 3, ipadx = 3)
+ if 'max' in param:
+ if 'target' in param['max']:
+ faild.titlebar.label10 = ttk.Label(faild.titlebar, text = ' Max Limit: ',
+ style = 'italic.TLabel')
+ faild.titlebar.label10.pack(side = 'left', padx = 6, ipadx = 3)
+ faild.titlebar.label11 = ttk.Label(faild.titlebar, text = param['max']['target'],
+ style = 'normal.TLabel')
+ faild.titlebar.label11.pack(side = 'left', padx = 6, ipadx = 3)
+ if 'unit' in param:
+ faild.titlebar.label12 = ttk.Label(faild.titlebar, text = param['unit'],
+ style = 'italic.TLabel')
+ faild.titlebar.label12.pack(side = 'left', padx = 3, ipadx = 3)
+
+ # Simplify view by removing constant values from the table and just listing them
+ # on the second line.
+
+ faild.constants = ttk.Frame(faild)
+ faild.constants.grid(row = 1, column = 0, sticky = 'ewns')
+ faild.constants.title = ttk.Label(faild.constants, text = 'Constant Conditions: ',
+ style = 'italic.TLabel')
+ faild.constants.title.grid(row = 0, column = 0, padx = 6, ipadx = 3)
+ j = 0
+ for condname, unit, range in zip(names, units, ranges):
+ if len(range) == 1:
+ labtext = condname
+ # unit = self.findunit(condname, param, globcond)
+ labtext += ' = ' + range[0] + ' ' + unit + ' '
+ row = int(j / 3)
+ col = 1 + (j % 3)
+ ttk.Label(faild.constants, text = labtext,
+ style = 'blue.TLabel').grid(row = row,
+ column = col, padx = 6, sticky = 'nsew')
+ j += 1
+
+ body = ttk.Frame(faild, style = 'bg.TFrame')
+ body.grid(row = 2, column = 0, sticky = 'ewns')
+
+ # Print out names
+ j = 0
+ for condname, unit, range in zip(names, units, ranges):
+ # Now find the range for each entry from the global and local conditions.
+ # Use local conditions if specified, otherwise default to global condition.
+ # Each result is a list of three numbers for min, typ, and max. List
+ # entries may be left unfilled.
+
+ if len(range) == 1:
+ continue
+
+ labtext = condname
+ plottext = condname
+ if j == 0:
+ # Add unicode arrow up/down depending on sort direction
+ labtext += ' \u21e9' if self.sortdir else ' \u21e7'
+ header = ttk.Button(body, text=labtext, style = 'title.TButton',
+ command = self.changesort)
+ tooltip.ToolTip(header, text='Reverse order of results')
+ else:
+ header = ttk.Button(body, text=labtext, style = 'title.TLabel',
+ command = lambda plottext=plottext, globcond=globcond,
+ filename=filename: self.table_to_plot(plottext, globcond, filename))
+ tooltip.ToolTip(header, text='Plot results with this condition on the X axis')
+ header.grid(row = 0, column = j, sticky = 'ewns')
+
+ # Second row is the measurement unit
+ # if j == 0:
+ # # Measurement unit of result in first column
+ # if 'unit' in param:
+ # unit = param['unit']
+ # else:
+ # unit = '' # No units
+ # else:
+ # # Measurement unit of condition in other columns
+ # # Find condition in local conditions else global conditions
+ # unit = self.findunit(condname, param, globcond)
+
+ unitlabel = ttk.Label(body, text=unit, style = 'brown.TLabel')
+ unitlabel.grid(row = 1, column = j, sticky = 'ewns')
+
+ # (Pick up limits when all entries have been processed---see below)
+ j += 1
+
+ # Now list entries for each failure record. These should all be in the
+ # same order.
+ m = 2
+ for result in results:
+ m += 1
+ j = 0
+ condition = result[0]
+ lstyle = 'normal.TLabel'
+ value = float(condition)
+ if 'min' in param:
+ minrec = param['min']
+ if 'calc' in minrec:
+ calc = minrec['calc']
+ else:
+ calc = 'min'
+ if self.check_failure(minrec, calc, value):
+ lstyle = 'red.TLabel'
+ if 'max' in param:
+ maxrec = param['max']
+ if 'calc' in maxrec:
+ calc = maxrec['calc']
+ else:
+ calc = 'max'
+ if self.check_failure(maxrec, calc, value):
+ lstyle = 'red.TLabel'
+
+ for condition, range in zip(result, ranges):
+ if len(range) > 1:
+ pname = ttk.Label(body, text=condition, style = lstyle)
+ pname.grid(row = m, column = j, sticky = 'ewns')
+ j += 1
+
+ # Row 2 contains the ranges of each column
+ j = 1
+ k = 1
+ for vrange in ranges[1:]:
+ if len(vrange) > 1:
+
+ condlimits = '( '
+
+ # This is a bit of a hack; results are assumed floating-point
+ # unless they can't be resolved as a number. So numerical values
+ # that should be treated as integers or strings must be handled
+ # here according to the condition type.
+ if names[k].split(':')[0] == 'DIGITAL':
+ for l in vrange:
+ condlimits += str(int(float(l))) + ' '
+ else:
+ for l in vrange:
+ condlimits += l + ' '
+ condlimits += ')'
+ header = ttk.Label(body, text=condlimits, style = 'blue.TLabel')
+ header.grid(row = 2, column = j, sticky = 'ewns')
+ j += 1
+ k += 1
+
+ # Add padding around widgets in the body of the failure report, so that
+ # the frame background comes through, making a grid.
+ for child in body.winfo_children():
+ child.grid_configure(ipadx = 5, ipady = 1, padx = 2, pady = 2)
+
+ # Resize the window to fit in the display, if necessary.
+ self.size_failreport()
+
+ # Don't put the button at the bottom to return to table view.
+ self.bbar.table_button.grid_forget()
+ # Finally, open the window if it was not already open.
+ self.open()
+
+ def changesort(self):
+ self.sortdir = False if self.sortdir == True else True
+ self.display(param=None)
+
+ def close(self):
+ # pop down failure report window
+ self.withdraw()
+
+ def open(self):
+ # pop up failure report window
+ self.deiconify()
+ self.lift()
diff --git a/common/foundry_nodes.py b/common/foundry_nodes.py
new file mode 100755
index 0000000..b431eff
--- /dev/null
+++ b/common/foundry_nodes.py
@@ -0,0 +1,131 @@
+#!/usr/bin/python
+
+# foundry_nodes.py ---
+#
+# This script runs in cloudV and discovers the set of foundry-
+# node names that are on the system and which support digital
+# synthesis. It returns the list of discovered nodes in JSON
+# data format (output to stdout).
+#
+# Note that as this runs on the cloudV server, it is written
+# in python 2.7 syntax
+
+from __future__ import print_function
+
+import os
+import re
+import sys
+import json
+import glob
+
+def print_usage():
+ print('Usage: foundry_nodes.py [all|<tag>]')
+
+if __name__ == '__main__':
+ arguments = []
+ for item in sys.argv[1:]:
+ arguments.append(item)
+
+ dolist = 'active'
+ if len(arguments) == 1:
+ dolist = arguments[0]
+ elif len(arguments) != 0:
+ print_usage()
+ sys.exit(0)
+
+ # Search the /ef/ tree and find all foundry name (root name of the
+ # directory above the foundry node name). If nothing is found,
+ # assume that this is the project name. If the project name
+ # is already set, then generate an error.
+
+ proclist = []
+
+ for procnode in glob.glob('/ef/tech/*/*/.ef-config/nodeinfo.json'):
+ try:
+ with open(procnode, 'r') as ifile:
+ process = json.load(ifile)
+ except:
+ pass
+ else:
+ nodename = process['node']
+ rootpath = os.path.split(procnode)[0]
+ techroot = os.path.realpath(rootpath + '/techdir')
+ qflowlist = glob.glob(techroot + '/libs.tech/qflow/' + nodename + '*.sh')
+
+
+ if 'status' in process:
+ status = process['status']
+ else:
+ # Default behavior is that nodes with "LEGACY" in the name
+ # are inactive, and all others are active.
+ if 'LEGACY' in nodename:
+ status = 'legacy'
+ else:
+ status = 'active'
+
+ # Do not record process nodes that do not match the status-match
+ # argument (unless the argument is "all").
+ if dolist != 'all':
+ if status != dolist:
+ continue
+
+ # Try to find available standard cell sets if they are not marked
+ # as an entry in the nodeinfo.json file. If they are an entry in nodeinfo.json,
+ # check if it is just a list of names. If so, look up each name entry and
+ # expand it into a dictionary. If it is already a dictionary, then just copy
+ # it to the output.
+ validcells = []
+ if 'stdcells' in process:
+ for name in process['stdcells'][:]:
+ if type(name) is not dict:
+ process['stdcells'].remove(name)
+ validcells.append(name)
+
+ stdcells = []
+ for qflowdefs in qflowlist:
+ stdcellname = os.path.split(qflowdefs)[1]
+ validname = os.path.splitext(stdcellname)[0]
+ if validcells == [] or validname in validcells:
+
+ stdcelldef = {}
+ stdcelldef['name'] = validname
+
+ # Read the qflow .sh file for the name of the preferred liberty format
+ # file and the name of the verilog file. Pull the path name from the
+ # verilog file since there may be other supporting files that need to
+ # be read from that path.
+
+ # Diagnostic
+ # print("Reading file " + qflowdefs, file=sys.stderr)
+ with open(qflowdefs, 'r') as ifile:
+ nodevars = ifile.read().splitlines()
+
+ try:
+ libline = next(item for item in nodevars if 'libertyfile' in item and item.strip()[0] != '#')
+ lfile = libline.split('=')[1].strip()
+ lfile = lfile.split()[0]
+ stdcelldef['libertyfile'] = lfile
+ except:
+ pass
+
+ try:
+ vlgline = next(item for item in nodevars if 'verilogfile' in item and item.strip()[0] != '#')
+ vfile = vlgline.split('=')[1].strip()
+ vfile = vfile.split()[0]
+ if os.path.exists(vfile):
+ stdcelldef['verilogpath'] = os.path.split(vfile)[0]
+ else:
+ print("Warning: bad verilogfile path " + vfile, file=sys.stderr)
+ except:
+ pass
+
+ stdcells.append(stdcelldef)
+
+ process['stdcells'] = stdcells
+ proclist.append(process)
+
+ if len(proclist) > 0:
+ json.dump(proclist, sys.stdout, indent=4)
+ else:
+ print("Error, no process nodes found!", file=sys.stderr)
+
diff --git a/common/helpwindow.py b/common/helpwindow.py
new file mode 100755
index 0000000..1f0e1a8
--- /dev/null
+++ b/common/helpwindow.py
@@ -0,0 +1,230 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#--------------------------------------------------------
+# Help Window for the Open Galaxy project manager
+#
+#--------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# September 12, 2016
+# Version 0.1
+#--------------------------------------------------------
+
+import re
+import tkinter
+from tkinter import ttk
+
+class HelpWindow(tkinter.Toplevel):
+ """Open Galaxy help window."""
+
+ def __init__(self, parent=None, fontsize = 11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ self.protocol("WM_DELETE_WINDOW", self.close)
+
+ self.withdraw()
+ self.title('Open Galaxy Help')
+
+ self.helptitle = ttk.Label(self, style='title.TLabel', text = '(no text)')
+ self.helptitle.grid(column = 0, row = 0, sticky = "news")
+ self.helpbar = ttk.Separator(self, orient='horizontal')
+ self.helpbar.grid(column = 0, row = 1, sticky = "news")
+
+ self.hframe = tkinter.Frame(self)
+ self.hframe.grid(column = 0, row = 2, sticky = "news")
+ self.hframe.helpdisplay = ttk.Frame(self.hframe)
+ self.hframe.helpdisplay.pack(side = 'left', fill = 'both', expand = 'true')
+
+ self.hframe.helpdisplay.helptext = tkinter.Text(self.hframe.helpdisplay, wrap='word')
+ self.hframe.helpdisplay.helptext.pack(side = 'top', fill = 'both', expand = 'true')
+ # Add scrollbar to help window
+ self.hframe.scrollbar = ttk.Scrollbar(self.hframe)
+ self.hframe.scrollbar.pack(side='right', fill='y')
+ # attach help window to scrollbar
+ self.hframe.helpdisplay.helptext.config(yscrollcommand = self.hframe.scrollbar.set)
+ self.hframe.scrollbar.config(command = self.hframe.helpdisplay.helptext.yview)
+
+ self.hframe.toc = ttk.Treeview(self.hframe, selectmode='browse')
+ self.hframe.toc.bind('<<TreeviewSelect>>', self.toc_to_page)
+ self.hframe.toc.bind('<<TreeviewOpen>>', self.toc_toggle)
+ self.hframe.toc.bind('<<TreeviewClose>>', self.toc_toggle)
+ self.hframe.toc.tag_configure('title', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'brown', anchor = 'center')
+ self.hframe.toc.heading('#0', text = "Table of Contents")
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 3, sticky = "news")
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=0, row=0, padx = 5)
+
+ self.bbar.prev_button = ttk.Button(self.bbar, text='Prev',
+ command=self.prevpage, style = 'normal.TButton')
+ self.bbar.prev_button.grid(column=1, row=0, padx = 5)
+
+ self.bbar.next_button = ttk.Button(self.bbar, text='Next',
+ command=self.nextpage, style = 'normal.TButton')
+ self.bbar.next_button.grid(column=2, row=0, padx = 5)
+
+ self.bbar.contents_button = ttk.Button(self.bbar, text='Table of Contents',
+ command=self.page_to_toc, style = 'normal.TButton')
+ self.bbar.contents_button.grid(column=3, row=0, padx = 5)
+
+ self.rowconfigure(0, weight=0)
+ self.rowconfigure(1, weight=0)
+ self.rowconfigure(2, weight=1)
+ self.rowconfigure(3, weight=0)
+ self.columnconfigure(0, weight=1)
+
+ # Help pages
+ self.pages = []
+ self.pageno = -1 # No page
+ self.toggle = False
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def redisplay(self):
+ # remove contents
+ if self.pageno >= 0 and self.pageno < len(self.pages):
+ self.hframe.helpdisplay.helptext.delete('1.0', 'end')
+ self.hframe.helpdisplay.helptext.insert('end', self.pages[self.pageno]['text'])
+ self.helptitle.configure(text = self.pages[self.pageno]['title'])
+
+ def toc_toggle(self, event):
+ self.toggle = True
+
+ def toc_to_page(self, event):
+ treeview = event.widget
+ selection = treeview.item(treeview.selection())
+
+ # Make sure any open/close callback is handled first!
+ self.update_idletasks()
+ if self.toggle:
+ # Item was opened or closed, so consider this a 'false select' and
+ # do not go to the page.
+ self.toggle = False
+ return
+
+ if 'values' in selection:
+ pagenum = selection['values'][0]
+ else:
+ print('Unknown page selected.')
+ pagenum = 0
+
+ # Display a page after displaying the table of contents
+ self.hframe.toc.pack_forget()
+ self.hframe.scrollbar.pack_forget()
+ self.hframe.helpdisplay.pack(side='left', fill='both', expand = 'true')
+ self.hframe.scrollbar.pack(side='right', fill='y')
+ self.hframe.scrollbar.config(command = self.hframe.helpdisplay.helptext.yview)
+ # Enable Prev and Next buttons
+ self.bbar.prev_button.configure(state='enabled')
+ self.bbar.next_button.configure(state='enabled')
+ # Redisplay
+ self.page(pagenum)
+
+ def page_to_toc(self):
+ # Display the table of contents after displaying a page
+ self.hframe.scrollbar.pack_forget()
+ self.hframe.helpdisplay.pack_forget()
+ self.hframe.toc.pack(side='left', fill='both', expand = 'true')
+ self.hframe.scrollbar.pack(side='right', fill='y')
+ self.hframe.scrollbar.config(command = self.hframe.toc.yview)
+ # Disable Prev and Next buttons
+ self.bbar.prev_button.configure(state='disabled')
+ self.bbar.next_button.configure(state='disabled')
+
+ # Simple add page with a single block of plain text
+ def add_page(self, toc_text, text_block):
+ newdict = {}
+ newdict['text'] = text_block
+ newdict['title'] = toc_text
+ self.pages.append(newdict)
+ newpageno = len(self.pages)
+ self.hframe.toc.insert('', 'end', text=str(newpageno) + '. ' + toc_text,
+ tag='title', value = newpageno - 1)
+ if self.pageno < 0:
+ self.pageno = 0 # First page
+
+ # Fill the help text from a file. The format of the file is:
+ # <page_num>
+ # <title>
+ # <text>
+ # '.'
+ # Text is multi-line and ends when '.' is encountered by itself
+
+ def add_pages_from_file(self, filename):
+ endpagerex = re.compile('^\.$')
+ newpagerex = re.compile('^[0-9\.]+$')
+ commentrex = re.compile('^[\-]+$')
+ hierarchy = ''
+ print('Loading help text from file ' + filename)
+ with open(filename, 'r') as f:
+ toc_text = []
+ page_text = []
+ for line in f:
+ if newpagerex.match(line) or endpagerex.match(line):
+ if toc_text and page_text:
+ newdict = {}
+ self.pages.append(newdict)
+ newpageno = len(self.pages)
+ if '.' in hierarchy:
+ pageinfo = hierarchy.rsplit('.', 1)
+ if pageinfo[1] == '':
+ parentid = ''
+ pageid = pageinfo[0]
+ else:
+ parentid = pageinfo[0]
+ pageid = pageinfo[1]
+ else:
+ parentid = ''
+ pageid = hierarchy
+ if parentid:
+ pageid = parentid + '.' + pageid
+ newdict['text'] = page_text
+ newdict['title'] = pageid + '. ' + toc_text
+ self.hframe.toc.insert(parentid, 'end',
+ text=newdict['title'], tag='title',
+ value = newpageno - 1, iid = pageid)
+ if newpagerex.match(line):
+ hierarchy = line.rstrip()
+ toc_text = []
+ elif not toc_text:
+ toc_text = line.rstrip()
+ page_text = []
+ elif not commentrex.match(line):
+ if not page_text:
+ page_text = line
+ else:
+ page_text += line
+
+ def nextpage(self):
+ # Go to next page
+ if self.pageno < len(self.pages) - 1:
+ self.pageno += 1
+ self.redisplay()
+
+ def prevpage(self):
+ # Go to previous page
+ if self.pageno > 0:
+ self.pageno -= 1
+ self.redisplay()
+
+ def page(self, pagenum):
+ # Go to indicated page
+ if pagenum >= 0 and pagenum < len(self.pages):
+ self.pageno = pagenum
+ self.redisplay()
+
+ def close(self):
+ # pop down help window
+ self.withdraw()
+
+ def open(self):
+ # pop up help window
+ self.deiconify()
+ self.lift()
diff --git a/common/listboxchoice.py b/common/listboxchoice.py
new file mode 100755
index 0000000..df6b895
--- /dev/null
+++ b/common/listboxchoice.py
@@ -0,0 +1,58 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+# Simple listbox with scrollbar and select button
+
+import re
+import tkinter
+from tkinter import ttk
+
+class ListBoxChoice(ttk.Frame):
+ def __init__(self, parent, fontsize=11, *args, **kwargs):
+ ttk.Frame.__init__(self, parent, *args, **kwargs)
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+
+ def populate(self, title, list=[]):
+ self.value = None
+ self.list = list[:]
+
+ ttk.Label(self, text=title).pack(padx=5, pady=5)
+
+ listFrame = ttk.Frame(self)
+ listFrame.pack(side='top', padx=5, pady=5, fill='both', expand='true')
+
+ scrollBar = ttk.Scrollbar(listFrame)
+ scrollBar.pack(side='right', fill='y')
+ self.listBox = tkinter.Listbox(listFrame, selectmode='single')
+ self.listBox.pack(side='left', fill='x', expand='true')
+ scrollBar.config(command=self.listBox.yview)
+ self.listBox.config(yscrollcommand=scrollBar.set)
+ self.list.sort(key=natsort_key)
+ for item in self.list:
+ self.listBox.insert('end', item)
+
+ if len(self.list) == 0:
+ self.listBox.insert('end', '(no items)')
+ else:
+ buttonFrame = ttk.Frame(self)
+ buttonFrame.pack(side='bottom')
+
+ selectButton = ttk.Button(buttonFrame, text="Select", command=self._select,
+ style='normal.TButton')
+ selectButton.pack(side='left', padx = 5)
+ listFrame.bind("<Return>", self._select)
+
+ def natsort_key(s, _nsre=re.compile('([0-9]+)')):
+ # 'natural' sort function. To make this alphabetical independently of
+ # capitalization, use "else text.lower()" instead of "else text" below.
+ return [int(text) if text.isdigit() else text for text in _nsre.split(s)]
+
+ def _select(self, event=None):
+ try:
+ firstIndex = self.listBox.curselection()[0]
+ self.value = self.list[int(firstIndex)]
+ except IndexError:
+ self.value = None
+
+ def value(self):
+ return self.value
diff --git a/common/make_icon_from_soft.py b/common/make_icon_from_soft.py
new file mode 100644
index 0000000..b866463
--- /dev/null
+++ b/common/make_icon_from_soft.py
@@ -0,0 +1,617 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3 -B
+#--------------------------------------------------------
+# make_icon_from_soft.py --
+#
+# Create an electric icon (manually) from information taken from
+# a verilog module.
+#-----------------------------------------------------------------
+
+import os
+import re
+import sys
+import json
+import datetime
+import subprocess
+
+def create_symbol(projectpath, verilogfile, project, destfile=None, debug=False, dolist=False):
+ if not os.path.exists(projectpath):
+ print('No path to project ' + projectpath)
+ return 1
+
+ if not os.path.isfile(verilogfile):
+ print('No path to verilog file ' + verilogfile)
+ return 1
+
+ if not os.path.exists(projectpath + '/elec'):
+ print('No electric subdirectory /elec/ in project.')
+ return 1
+
+ if not destfile:
+
+ delibdir = projectpath + '/elec/' + project + '.delib'
+ if not os.path.isdir(delibdir):
+ print('No electric library ' + project + '.delib in project.')
+ return 1
+
+ if os.path.isfile(delibdir + '/' + project + '.ic'):
+ print('Symbol file ' + project + '.ic exists already.')
+ print('Please remove it if you want to overwrite it.')
+ return 1
+
+ # By default, put the icon file in the project's electric library
+ destfile = projectpath + '/elec/' + project + '.delib/' + project + '.ic'
+ desthdr = projectpath + '/elec/' + project + '.delib/header'
+
+ else:
+ if os.path.isfile(destfile):
+ print('Symbol file ' + project + '.ic exists already.')
+ print('Please remove it if you want to overwrite it.')
+ return 1
+
+ destdir = os.path.split(destfile)[0]
+ desthdr = destdir + '/header'
+ if not os.path.isdir(destdir):
+ os.makedirs(destdir)
+
+ # Original verilog source can be very complicated to parse. Run through
+ # qflow's vlog2Verilog tool to get a much simplified header, which also
+ # preprocesses the verilog, handles parameters, etc.
+
+ vdir = os.path.split(verilogfile)[0]
+ vtempfile = vdir + '/vtemp.out'
+ p = subprocess.run(['/ef/apps/ocd/qflow/current/share/qflow/bin/vlog2Verilog',
+ '-p', '-o', vtempfile, verilogfile], stdout = subprocess.PIPE)
+
+ if not os.path.exists(vtempfile):
+ print('Error: Failed to create preprocessed verilog from ' + verilogfile)
+ return 1
+
+ # Okay, ready to go. Now read the verilog source file and get the list
+ # of pins.
+
+ commstr1 = '/\*.*\*/'
+ commstr2 = '//[^\n]*\n'
+ c1rex = re.compile(commstr1)
+ c2rex = re.compile(commstr2)
+
+ # Find and isolate the module and its pin list.
+ modstr = 'module[ \t]+' + project + '[ \t]*\(([^\)]+)\)[ \t\n]*;'
+ modrex = re.compile(modstr)
+
+ # End parsing on any of these tokens
+ endrex = re.compile('[ \t]*(initial|function|task|always)')
+
+ inpins = []
+ outpins = []
+ iopins = []
+ invecs = []
+ outvecs = []
+ iovecs = []
+
+ with open(vtempfile, 'r') as ifile:
+ vlines = ifile.read()
+
+ # Remove comments
+ vlines2 = c2rex.sub('\n', c1rex.sub('', vlines))
+
+ # Find and isolate the module pin list
+ modpinslines = modrex.findall(vlines2)
+
+ modpinsstart = modrex.search(vlines2)
+ if modpinsstart:
+ startc = modpinsstart.span()[0]
+ else:
+ startc = 0
+ modpinsend = endrex.search(vlines2[startc:])
+ if modpinsend:
+ endc = modpinsend.span()[0]
+ else:
+ endc = len(vlines2)
+
+ vlines2 = vlines2[startc:endc]
+
+ # Find the module (there should be only one) and get pins if in the
+ # format with input / output declarations in the module heading.
+
+ pinlist = []
+ if len(modpinslines) > 0:
+ modpins = modpinslines[0]
+ pinlist = re.sub('[\t\n]', '', modpins).split(',')
+
+ # If each pinlist entry is only one word, then look for following
+ # lines "input", "output", etc., and compile them into a similar
+ # list. Then parse each list entry.
+
+ knownreal = {}
+ knownpower = {}
+ knownground = {}
+
+ if len(pinlist) > 0 and len(pinlist[0].split()) == 1:
+
+ invecrex = re.compile('\n[ \t]*input[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*([^;]+);')
+ insigrex = re.compile('\n[ \t]*input[ \t]+([^\[;]+);')
+ outvecrex = re.compile('\n[ \t]*output[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*([^;]+);')
+ outsigrex = re.compile('\n[ \t]*output[ \t]+([^;\[]+);')
+ iovecrex = re.compile('\n[ \t]*inout[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*([^;]+);')
+ iosigrex = re.compile('\n[ \t]*inout [ \t]+([^;\[]+);')
+
+ # Find input, output, and inout lines
+ for test in insigrex.findall(vlines2):
+ pinname = list(item.strip() for item in test.split(','))
+ inpins.extend(pinname)
+ for test in outsigrex.findall(vlines2):
+ pinname = list(item.strip() for item in test.split(','))
+ outpins.extend(pinname)
+ for test in iosigrex.findall(vlines2):
+ pinname = list(item.strip() for item in test.split(','))
+ iopins.extend(pinname)
+ for test in invecrex.finditer(vlines2):
+ tpin = test.group(3).split(',')
+ for pin in tpin:
+ pinname = pin.strip() + '[' + test.group(1) + ':' + test.group(2) + ']'
+ invecs.append(pinname)
+ for test in outvecrex.finditer(vlines2):
+ tpin = test.group(3).split(',')
+ for pin in tpin:
+ pinname = pin.strip() + '[' + test.group(1) + ':' + test.group(2) + ']'
+ outvecs.append(pinname)
+ for test in iovecrex.finditer(vlines2):
+ tpin = test.group(3).split(',')
+ for pin in tpin:
+ pinname = pin.strip() + '[' + test.group(1) + ':' + test.group(2) + ']'
+ iovecs.append(pinname)
+
+ # Apply syntax checks (to do: check for "real" above)
+ powerrec = re.compile('VDD|VCC', re.IGNORECASE)
+ groundrec = re.compile('VSS|GND|GROUND', re.IGNORECASE)
+ for pinname in inpins + outpins + iopins + invecs + outvecs + iovecs:
+ pmatch = powerrec.match(pinname)
+ gmatch = groundrec.match(pinname)
+ if pmatch:
+ knownpower[pinname] = True
+ if gmatch:
+ knownground[pinname] = True
+ else:
+
+ # Get pin lists from module pin list. These are simpler to
+ # parse, since they have to be enumerated one by one.
+
+ invecrex = re.compile('[ \t]*input[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*(.+)')
+ insigrex = re.compile('[ \t]*input[ \t]+([a-zA-Z_][^ \t]+)')
+ outvecrex = re.compile('[ \t]*output[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*(.+)')
+ outsigrex = re.compile('[ \t]*output[ \t]+([a-zA-Z_][^ \t]+)')
+ iovecrex = re.compile('[ \t]*inout[ \t]*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\][ \t]*(.+)')
+ iosigrex = re.compile('[ \t]*inout[ \t]+([a-zA-Z_][^ \t]+)')
+ realrec = re.compile('[ \t]+real[ \t]+')
+ logicrec = re.compile('[ \t]+logic[ \t]+')
+ wirerec = re.compile('[ \t]+wire[ \t]+')
+ powerrec = re.compile('VDD|VCC', re.IGNORECASE)
+ groundrec = re.compile('VSS|GND|GROUND', re.IGNORECASE)
+
+ for pin in pinlist:
+ # Pull out any reference to "real", "logic", or "wire" to get pin name
+ ppin = realrec.sub(' ', logicrec.sub(' ', wirerec.sub(' ', pin.strip())))
+ pinname = None
+
+ # Make syntax checks
+ rmatch = realrec.match(pin)
+ pmatch = powerrec.match(pin)
+ gmatch = groundrec.match(pin)
+
+ imatch = insigrex.match(ppin)
+ if imatch:
+ pinname = imatch.group(1)
+ inpins.append(pinname)
+ omatch = outsigrex.match(ppin)
+ if omatch:
+ pinname = omatch.group(1)
+ outpins.append(pinname)
+ bmatch = iosigrex.match(ppin)
+ if bmatch:
+ pinname = bmatch.group(1)
+ iopins.append(pinname)
+ ivmatch = invecrex.match(ppin)
+ if ivmatch:
+ pinname = ivmatch.group(3) + '[' + ivmatch.group(1) + ':' + ivmatch.group(2) + ']'
+ invecs.append(pinname)
+ ovmatch = outvecrex.match(ppin)
+ if ovmatch:
+ pinname = ovmatch.group(3) + '[' + ovmatch.group(1) + ':' + ovmatch.group(2) + ']'
+ outvecs.append(pinname)
+ bvmatch = iovecrex.match(ppin)
+ if bvmatch:
+ pinname = bvmatch.group(3) + '[' + bvmatch.group(1) + ':' + bvmatch.group(2) + ']'
+ iovecs.append(pinname)
+
+ # Apply syntax checks
+ if pinname:
+ if rmatch:
+ knownreal[pinname] = True
+ if pmatch and rmatch:
+ knownpower[pinname] = True
+ if gmatch and rmatch:
+ knownground[pinname] = True
+
+ if (os.path.exists(vtempfile)):
+ os.remove(vtempfile)
+
+ if len(inpins) + len(outpins) + len(iopins) + len(invecs) + len(outvecs) + len(iovecs) == 0:
+ print('Failure to parse pin list for module ' + project + ' out of verilog source.')
+ return 1
+
+ if debug:
+ print("Input pins of module " + project + ":")
+ for pin in inpins:
+ print(pin)
+ print("Output pins of module " + project + ":")
+ for pin in outpins:
+ print(pin)
+ print("Bidirectional pins of module " + project + ":")
+ for pin in iopins:
+ print(pin)
+
+ # If "dolist" is True, then create a list of pin records in the style used by
+ # project.json, and return the list.
+
+ if dolist == True:
+ pinlist = []
+ for pin in inpins:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownreal:
+ pinrec["type"] = 'signal'
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinrec["dir"] = "input"
+ pinlist.append(pinrec)
+ for pin in outpins:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownreal:
+ pinrec["type"] = 'signal'
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinrec["dir"] = "output"
+ pinlist.append(pinrec)
+ for pin in iopins:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownpower:
+ pinrec["type"] = 'power'
+ pinrec["Vmin"] = "3.6"
+ pinrec["Vmax"] = "3.0"
+ elif pin in knownground:
+ pinrec["type"] = 'ground'
+ pinrec["Vmin"] = "0"
+ pinrec["Vmax"] = "0"
+ elif pin in knownreal:
+ pinrec["type"] = 'signal'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinrec["dir"] = "inout"
+ pinlist.append(pinrec)
+ for pin in invecs:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownreal:
+ pinrec["type"] = 'signal'
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["dir"] = "input"
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinlist.append(pinrec)
+ for pin in outvecs:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownreal:
+ pinrec["type"] = 'signal'
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["dir"] = "output"
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinlist.append(pinrec)
+ for pin in iovecs:
+ pinrec = {}
+ pinrec["name"] = pin
+ pinrec["description"] = "(add description here)"
+ if pin in knownpower:
+ pinrec["type"] = 'power'
+ pinrec["Vmin"] = "3.6"
+ pinrec["Vmax"] = "3.0"
+ elif pin in knownground:
+ pinrec["type"] = 'ground'
+ pinrec["Vmin"] = "0"
+ pinrec["Vmax"] = "0"
+ elif pin in knownreal:
+ pinrec["type"] = 'signal'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ else:
+ pinrec["type"] = 'digital'
+ pinrec["Vmin"] = "-0.5"
+ pinrec["Vmax"] = "VDD + 0.3"
+ pinrec["dir"] = "inout"
+ pinlist.append(pinrec)
+
+ return pinlist
+
+ # Okay, we've got all the pins, now build the symbol.
+
+ leftpins = len(inpins) + len(invecs)
+ rightpins = len(outpins) + len(outvecs)
+ # Arbitrarily, bidirectional pins are put on bottom and vectors on top.
+ toppins = len(iovecs)
+ botpins = len(iopins)
+
+ height = 2 + max(leftpins, rightpins) * 10
+ width = 82 + max(toppins, botpins) * 10
+
+ # Enforce minimum height (minimum width enforced above)
+ if height < 40:
+ height = 40
+
+ # Run electric -v to get version string
+ p = subprocess.run(['/ef/apps/bin/electric', '-v'], stdout = subprocess.PIPE)
+ vstring = p.stdout.decode('utf-8').rstrip()
+
+ # Get timestamp
+ timestamp = str(int(datetime.datetime.now().strftime("%s")) * 1000)
+
+ with open(destfile, 'w') as ofile:
+ print('H' + project + '|' + vstring, file=ofile)
+ print('', file=ofile)
+ print('# Cell ' + project + ';1{ic}', file=ofile)
+ print('C' + project + ';1{ic}||artwork|' + timestamp + '|' + timestamp + '|E', file=ofile)
+ print('Ngeneric:Facet-Center|art@0||0|0||||AV', file=ofile)
+ print('NBox|art@1||0|0|' + str(width) + '|' + str(height) + '||', file=ofile)
+ pnum = 0
+
+ # Title
+ print('Ngeneric:Invisible-Pin|pin@' + str(pnum) + '||0|5|||||ART_message(BD5G5;)S' + project, file=ofile)
+
+ pnum += 1
+ # Fill in left side pins
+ px = -(width / 2)
+ py = -(height / 2) + 5
+ for pin in inpins:
+ print('Nschematic:Wire_Pin|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ py += 10
+ for pin in invecs:
+ print('Nschematic:Bus_Pin|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ py += 10
+
+ # Fill in right side pins
+ px = (width / 2)
+ py = -(height / 2) + 5
+ for pin in outpins:
+ print('Nschematic:Wire_Pin|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ py += 10
+ for pin in outvecs:
+ print('Nschematic:Bus_Pin|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ py += 10
+
+ # Fill in bottom side pins
+ py = -(height / 2)
+ px = -(width / 2) + 45
+ for pin in iopins:
+ print('Nschematic:Wire_Pin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py - 10) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py - 10) + '|1|1||', file=ofile)
+ pnum += 1
+ px += 10
+
+ # Fill in top side pins
+ py = (height / 2)
+ px = -(width / 2) + 45
+ for pin in iovecs:
+ print('Nschematic:Bus_Pin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py + 10) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|1|1||', file=ofile)
+ pnum += 1
+ print('NPin|pin@' + str(pnum) + '||' + str(px) + '|' + str(py + 10) + '|1|1||', file=ofile)
+ pnum += 1
+ px += 10
+
+ # Start back at pin 1 and retain the same order when drawing wires
+ pnum = 1
+ nnum = 0
+
+ px = -(width / 2)
+ py = -(height / 2) + 5
+ for pin in inpins:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py), file=ofile)
+ pnum += 2
+ nnum += 1
+ py += 10
+
+ for pin in invecs:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px - 10) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py), file=ofile)
+ pnum += 2
+ nnum += 1
+ py += 10
+
+ px = (width / 2)
+ py = -(height / 2) + 5
+ for pin in outpins:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py), file=ofile)
+ pnum += 2
+ nnum += 1
+ py += 10
+
+ for pin in outvecs:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px + 10) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py), file=ofile)
+ pnum += 2
+ nnum += 1
+ py += 10
+
+ py = -(height / 2)
+ px = -(width / 2) + 45
+ for pin in iopins:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py - 10), file=ofile)
+ pnum += 2
+ nnum += 1
+ px += 10
+
+ py = (height / 2)
+ px = -(width / 2) + 45
+ for pin in iovecs:
+ pnum += 1
+ print('ASolid|net@' + str(nnum) + '|||FS0|pin@' + str(pnum) + '||' + str(px) + '|' + str(py) + '|pin@' + str(pnum + 1) + '||' + str(px) + '|' + str(py + 10), file=ofile)
+ pnum += 2
+ nnum += 1
+ px += 10
+
+ # Add the exports (which are the only nontrivial elements)
+ pnum = 1
+ for pin in inpins:
+ print('E' + pin + '||D6G4;X12.0;Y0.0;|pin@' + str(pnum) + '||I', file=ofile)
+ pnum += 3
+ for pin in invecs:
+ print('E' + pin + '||D6G4;X12.0;Y0.0;|pin@' + str(pnum) + '||I', file=ofile)
+ pnum += 3
+ for pin in outpins:
+ print('E' + pin + '||D4G4;X-12.0;Y0.0;|pin@' + str(pnum) + '||O', file=ofile)
+ pnum += 3
+ for pin in outvecs:
+ print('E' + pin + '||D4G4;X-12.0;Y0.0;|pin@' + str(pnum) + '||O', file=ofile)
+ pnum += 3
+ for pin in iopins:
+ print('E' + pin + '||D6G4;RX0.0;Y12.0;|pin@' + str(pnum) + '||B', file=ofile)
+ pnum += 3
+ for pin in iovecs:
+ print('E' + pin + '||D6G4;RRRX0.0;Y-12.0;|pin@' + str(pnum) + '||B', file=ofile)
+ pnum += 3
+
+ # X marks the spot, or at least the end.
+ print('X', file=ofile)
+
+ if not os.path.isfile(desthdr):
+ with open(desthdr, 'w') as ofile:
+ print('# header information:', file=ofile)
+ print('H' + project + '|' + vstring, file=ofile)
+ print('', file=ofile)
+ print('# Views:', file=ofile)
+ print('Vicon|ic', file=ofile)
+ print('', file=ofile)
+ print('# Tools:', file=ofile)
+ print('Ouser|DefaultTechnology()Sschematic', file=ofile)
+ print('Osimulation|VerilogUseAssign()BT', file=ofile)
+ print('C____SEARCH_FOR_CELL_FILES____', file=ofile)
+
+ return 0
+
+def usage():
+ print("make_icon_from_soft.py <project_path> [<verilog_source>] [<output_file>]")
+ print("")
+ print(" where <project_path> is the path to a standard efabless project, and")
+ print(" <verilog_source> is the path to a verilog source file.")
+ print("")
+ print(" The module name must be the same as the project's ip-name.")
+ print("")
+ print(" <verilog_source> is assumed to be in verilog/source/<ip-name>.v by")
+ print(" default if not otherwise specified.")
+ print("")
+ print(" If <output_file> is not specified, output goes in the project's")
+ print(" electric library.")
+ print("")
+
+if __name__ == '__main__':
+ arguments = []
+ options = []
+
+ for item in sys.argv[1:]:
+ if item[0] == '-':
+ options.append(item.strip('-'))
+ else:
+ arguments.append(item)
+
+ debug = True if 'debug' in options else False
+
+ numarg = len(arguments)
+ if numarg > 3 or numarg == 0:
+ usage()
+ sys.exit(0)
+
+ projectpath = arguments[0]
+
+ projdirname = os.path.split(projectpath)[1]
+ jsonfile = projectpath + '/project.json'
+ if not os.path.isfile(jsonfile):
+ # Legacy behavior is to have the JSON file name the same as the directory name.
+ jsonfile = projectpath + '/' + projdirname + '.json'
+ if not os.path.isfile(jsonfile):
+ print('Error: No project JSON file found for project ' + projdirname)
+ sys.exit(1)
+
+ project = None
+ with open(jsonfile, 'r') as ifile:
+ datatop = json.load(ifile)
+ dsheet = datatop['data-sheet']
+ project = dsheet['ip-name']
+
+ if not project:
+ print('Error: No project IP name in project JSON file.')
+ sys.exit(1)
+
+ if numarg > 1:
+ verilogfile = arguments[1]
+ else:
+ verilogfile = projectpath + '/verilog/source/' + project + '.v'
+ if not os.path.exists(verilogfile):
+ print('Error: No verilog file ' + verilogfile + ' found.')
+ print('Please specify full path as 2nd argument.')
+ sys.exit(1)
+
+ if numarg > 2:
+ destfile = arguments[2]
+ else:
+ destfile = projectpath + '/elec/' + project + '.delib/' + project + '.ic'
+ if os.path.exists(destfile):
+ print('Error: Icon file ' + destfile + ' already exists.')
+ print('Please delete any unwanted original before running this script.')
+ sys.exit(1)
+
+ result = create_symbol(projectpath, verilogfile, project, destfile, debug)
+ sys.exit(result)
diff --git a/common/og_config.py b/common/og_config.py
new file mode 100755
index 0000000..ee9a986
--- /dev/null
+++ b/common/og_config.py
@@ -0,0 +1,33 @@
+# Configuration values for the OpenGalaxy machines
+# Select config-file directed by OPTIONAL (INI file): /etc/sysconfig/ef-config ef_variant= line.
+# File should: have no [section] header, use "# " comments, var="val" (no spaces around =),
+# no dash in var-names, for good compatibility between python and bash.
+#
+# default if fail to read/parse the etc file is STAGING. These values:
+# ef_variant=DEV ef_variant=STAGING ef_variant=PROD
+# yield respectively:
+# import og_config_DEV import og_config_STAGING import og_config_PROD
+#
+# Survive (try:) missing,improper,unreadable /etc/sysconfig/ef-config.
+# DO NOT survive (no try:) failed imports (non-existent file, bad syntax, etc.).
+
+#
+# look-up ef_variant=... in optional etc file, default to STAGING
+#
+import configparser
+#TODO: replace path with PREFIX
+apps_path="/usr/share/pdk/bin"
+#apps_path="PREFIX/pdk/bin"
+
+config = configparser.ConfigParser(strict=False, allow_no_value=True)
+try:
+ config.read_string("[null]\n"+open("/etc/sysconfig/ef-config").read())
+except:
+ pass
+ef_variant = config.get('null','ef_variant', fallback='STAGING').strip('\'"')
+
+#
+# emulate: import og_config_<ef_variant>
+#
+#cfgModule = __import__("og_config_"+ef_variant)
+#globals().update(vars(cfgModule))
diff --git a/common/og_gui_characterize.py b/common/og_gui_characterize.py
new file mode 100755
index 0000000..1c56555
--- /dev/null
+++ b/common/og_gui_characterize.py
@@ -0,0 +1,1781 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3 -B
+#
+#--------------------------------------------------------
+# Open Galaxy Project Manager GUI.
+#
+# This is a Python tkinter script that handles local
+# project management. Much of this involves the
+# running of ng-spice for characterization, allowing
+# the user to determine where a circuit is failing
+# characterization; and when the design passes local
+# characterization, it may be submitted to the
+# marketplace for official characterization.
+#
+#--------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# September 9, 2016
+# Version 1.0
+#--------------------------------------------------------
+
+import io
+import re
+import os
+import sys
+import copy
+import json
+import time
+import signal
+import select
+import datetime
+import contextlib
+import subprocess
+import faulthandler
+
+import tkinter
+from tkinter import ttk
+from tkinter import filedialog
+
+import tksimpledialog
+import tooltip
+from consoletext import ConsoleText
+from helpwindow import HelpWindow
+from failreport import FailReport
+from textreport import TextReport
+from editparam import EditParam
+from settings import Settings
+from simhints import SimHints
+
+import og_config
+
+# User preferences file (if it exists)
+prefsfile = '~/design/.profile/prefs.json'
+
+#------------------------------------------------------
+# Simple dialog for confirming quit or upload
+#------------------------------------------------------
+
+class ConfirmDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed):
+ ttk.Label(master, text=warning, wraplength=500).grid(row = 0, columnspan = 2, sticky = 'wns')
+ return self
+
+ def apply(self):
+ return 'okay'
+
+#------------------------------------------------------
+# Simple dialog with no "OK" button (can only cancel)
+#------------------------------------------------------
+
+class PuntDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed):
+ if warning:
+ ttk.Label(master, text=warning, wraplength=500).grid(row = 0, columnspan = 2, sticky = 'wns')
+ return self
+
+ def buttonbox(self):
+ # Add button box with "Cancel" only.
+ box = ttk.Frame(self.obox)
+ w = ttk.Button(box, text="Cancel", width=10, command=self.cancel)
+ w.pack(side='left', padx=5, pady=5)
+ self.bind("<Escape>", self.cancel)
+ box.pack(fill='x', expand='true')
+
+ def apply(self):
+ return 'okay'
+
+#------------------------------------------------------
+# Main class for this application
+#------------------------------------------------------
+
+class OpenGalaxyCharacterize(ttk.Frame):
+ """Open Galaxy local characterization GUI."""
+
+ def __init__(self, parent, *args, **kwargs):
+ ttk.Frame.__init__(self, parent, *args, **kwargs)
+ self.root = parent
+ self.init_gui()
+ parent.protocol("WM_DELETE_WINDOW", self.on_quit)
+
+ def on_quit(self):
+ """Exits program."""
+ if not self.check_saved():
+ warning = 'Warning: Simulation results have not been saved.'
+ confirm = ConfirmDialog(self, warning).result
+ if not confirm == 'okay':
+ print('Quit canceled.')
+ return
+ if self.logfile:
+ self.logfile.close()
+ quit()
+
+ def on_mousewheel(self, event):
+ if event.num == 5:
+ self.datasheet_viewer.yview_scroll(1, "units")
+ elif event.num == 4:
+ self.datasheet_viewer.yview_scroll(-1, "units")
+
+ 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('bg.TFrame', background='gray40')
+ s.configure('italic.TLabel', font=('Helvetica', fontsize, 'italic'))
+ s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'brown', anchor = 'center')
+ s.configure('normal.TLabel', font=('Helvetica', fontsize))
+ s.configure('red.TLabel', font=('Helvetica', fontsize), foreground = 'red')
+ s.configure('green.TLabel', font=('Helvetica', fontsize), foreground = 'green3')
+ s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue')
+ s.configure('hlight.TLabel', font=('Helvetica', fontsize), background='gray93')
+ s.configure('rhlight.TLabel', font=('Helvetica', fontsize), foreground = 'red',
+ background='gray93')
+ s.configure('ghlight.TLabel', font=('Helvetica', fontsize), foreground = 'green3',
+ background='gray93')
+ s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue')
+ s.configure('blue.TMenubutton', font=('Helvetica', fontsize), foreground = 'blue',
+ border = 3, relief = 'raised')
+ s.configure('normal.TButton', font=('Helvetica', fontsize),
+ border = 3, relief = 'raised')
+ s.configure('red.TButton', font=('Helvetica', fontsize), foreground = 'red',
+ border = 3, relief = 'raised')
+ s.configure('green.TButton', font=('Helvetica', fontsize), foreground = 'green3',
+ border = 3, relief = 'raised')
+ s.configure('hlight.TButton', font=('Helvetica', fontsize),
+ border = 3, relief = 'raised', background='gray93')
+ s.configure('rhlight.TButton', font=('Helvetica', fontsize), foreground = 'red',
+ border = 3, relief = 'raised', background='gray93')
+ s.configure('ghlight.TButton', font=('Helvetica', fontsize), foreground = 'green3',
+ border = 3, relief = 'raised', background='gray93')
+ s.configure('blue.TButton', font=('Helvetica', fontsize), foreground = 'blue',
+ border = 3, relief = 'raised')
+ s.configure('redtitle.TButton', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'red', border = 3, relief = 'raised')
+ s.configure('bluetitle.TButton', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'blue', border = 3, relief = 'raised')
+
+ # Create the help window
+ self.help = HelpWindow(self, fontsize = fontsize)
+
+ with io.StringIO() as buf, contextlib.redirect_stdout(buf):
+ self.help.add_pages_from_file(og_config.apps_path + '/characterize_help.txt')
+ message = buf.getvalue()
+
+ # Set the help display to the first page
+ self.help.page(0)
+
+ # Create the failure report window
+ self.failreport = FailReport(self, fontsize = fontsize)
+
+ # LVS results get a text window of results
+ self.textreport = TextReport(self, fontsize = fontsize)
+
+ # Create the settings window
+ self.settings = Settings(self, fontsize = fontsize, callback = self.callback)
+
+ # Create the simulation hints window
+ self.simhints = SimHints(self, fontsize = fontsize)
+
+ # Create the edit parameter window
+ self.editparam = EditParam(self, fontsize = fontsize)
+
+ # Variables used by option menus and other stuff
+ self.origin = tkinter.StringVar(self)
+ self.cur_project = tkinter.StringVar(self)
+ self.cur_datasheet = "(no selection)"
+ self.datatop = {}
+ self.status = {}
+ self.caceproc = None
+ self.logfile = None
+
+ # Root window title
+ self.root.title('Open Galaxy Characterization')
+ self.root.option_add('*tearOff', 'FALSE')
+ self.pack(side = 'top', fill = 'both', expand = 'true')
+
+ 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)
+
+ # Get username
+ if 'username' in self.prefs:
+ username = self.prefs['username']
+ else:
+ userid = os.environ['USER']
+ p = subprocess.run(['/ef/apps/bin/withnet',
+ og_config.apps_path + '/og_uid_service.py', userid],
+ stdout = subprocess.PIPE)
+ if p.stdout:
+ uid_string = p.stdout.splitlines()[0].decode('utf-8')
+ userspec = re.findall(r'[^"\s]\S*|".+?"', uid_string)
+ if len(userspec) > 0:
+ username = userspec[0].strip('"')
+ # Note userspec[1] = UID and userspec[2] = role, useful
+ # for future applications.
+ else:
+ username = userid
+ else:
+ username = userid
+
+ # Label with the user
+ self.toppane.title_frame = ttk.Frame(self.toppane)
+ self.toppane.title_frame.grid(column = 0, row=0, sticky = 'nswe')
+
+ self.toppane.title_frame.title = ttk.Label(self.toppane.title_frame, text='User:', style = 'red.TLabel')
+ self.toppane.title_frame.user = ttk.Label(self.toppane.title_frame, text=username, style = 'blue.TLabel')
+
+ self.toppane.title_frame.title.grid(column=0, row=0, ipadx = 5)
+ self.toppane.title_frame.user.grid(column=1, row=0, ipadx = 5)
+
+ #---------------------------------------------
+ ttk.Separator(self.toppane, orient='horizontal').grid(column = 0, row = 1, sticky = 'nswe')
+ #---------------------------------------------
+
+ self.toppane.title2_frame = ttk.Frame(self.toppane)
+ self.toppane.title2_frame.grid(column = 0, row = 2, sticky = 'nswe')
+ self.toppane.title2_frame.datasheet_label = ttk.Label(self.toppane.title2_frame, text="Datasheet:",
+ style = 'normal.TLabel')
+ self.toppane.title2_frame.datasheet_label.grid(column=0, row=0, ipadx = 5)
+
+ # New datasheet select button
+ self.toppane.title2_frame.datasheet_select = ttk.Button(self.toppane.title2_frame,
+ text=self.cur_datasheet, style='normal.TButton', command=self.choose_datasheet)
+ self.toppane.title2_frame.datasheet_select.grid(column=1, row=0, ipadx = 5)
+
+ tooltip.ToolTip(self.toppane.title2_frame.datasheet_select,
+ text = "Select new datasheet file")
+
+ # Show path to datasheet
+ self.toppane.title2_frame.path_label = ttk.Label(self.toppane.title2_frame, text=self.cur_datasheet,
+ style = 'normal.TLabel')
+ self.toppane.title2_frame.path_label.grid(column=2, row=0, ipadx = 5, padx = 10)
+
+ # Spacer in middle moves selection button to right
+ self.toppane.title2_frame.sep_label = ttk.Label(self.toppane.title2_frame, text=' ',
+ style = 'normal.TLabel')
+ self.toppane.title2_frame.sep_label.grid(column=3, row=0, ipadx = 5, padx = 10)
+ self.toppane.title2_frame.columnconfigure(3, weight = 1)
+ self.toppane.title2_frame.rowconfigure(0, weight=0)
+
+ # Selection for origin of netlist
+ self.toppane.title2_frame.origin_label = ttk.Label(self.toppane.title2_frame,
+ text='Netlist from:', style = 'normal.TLabel')
+ self.toppane.title2_frame.origin_label.grid(column=4, row=0, ipadx = 5, padx = 10)
+
+ self.origin.set('Schematic Capture')
+ self.toppane.title2_frame.origin_select = ttk.OptionMenu(self.toppane.title2_frame,
+ self.origin, 'Schematic Capture', 'Schematic Capture', 'Layout Extracted',
+ style='blue.TMenubutton', command=self.load_results)
+ self.toppane.title2_frame.origin_select.grid(column=5, row=0, ipadx = 5)
+
+ #---------------------------------------------
+ ttk.Separator(self.toppane, orient='horizontal').grid(column = 0, row = 3, sticky = 'news')
+ #---------------------------------------------
+
+ # Datasheet information goes here when datasheet is loaded.
+ self.mframe = ttk.Frame(self.toppane)
+ self.mframe.grid(column = 0, row = 4, sticky = 'news')
+
+ # Row 4 (mframe) is expandable, the other rows are not.
+ self.toppane.rowconfigure(0, weight = 0)
+ self.toppane.rowconfigure(1, weight = 0)
+ self.toppane.rowconfigure(2, weight = 0)
+ self.toppane.rowconfigure(3, weight = 0)
+ self.toppane.rowconfigure(4, weight = 1)
+ self.toppane.columnconfigure(0, weight = 1)
+
+ #---------------------------------------------
+ # ttk.Separator(self, orient='horizontal').grid(column=0, row=5, sticky='ew')
+ #---------------------------------------------
+
+ # Add a text window below the datasheet to capture output. Redirect
+ # print statements to it.
+
+ self.botpane.console = ttk.Frame(self.botpane)
+ self.botpane.console.pack(side = 'top', fill = 'both', expand = 'true')
+
+ self.text_box = ConsoleText(self.botpane.console, wrap='word', height = 4)
+ self.text_box.pack(side='left', fill='both', expand='true')
+ console_scrollbar = ttk.Scrollbar(self.botpane.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 button bar at the bottom of the window
+ self.bbar = ttk.Frame(self.botpane)
+ self.bbar.pack(side = 'top', fill = 'x')
+ # Progress bar expands with the window, buttons don't
+ self.bbar.columnconfigure(6, weight = 1)
+
+ # Define the "quit" button and action
+ self.bbar.quit_button = ttk.Button(self.bbar, text='Close', command=self.on_quit,
+ style = 'normal.TButton')
+ self.bbar.quit_button.grid(column=0, row=0, padx = 5)
+
+ # Define the save button
+ self.bbar.save_button = ttk.Button(self.bbar, text='Save', command=self.save_results,
+ style = 'normal.TButton')
+ self.bbar.save_button.grid(column=1, row=0, padx = 5)
+
+ # Define the save-as button
+ self.bbar.saveas_button = ttk.Button(self.bbar, text='Save As', command=self.save_manual,
+ style = 'normal.TButton')
+
+ # Also a load button
+ self.bbar.load_button = ttk.Button(self.bbar, text='Load', command=self.load_manual,
+ style = 'normal.TButton')
+
+ # Define help button
+ self.bbar.help_button = ttk.Button(self.bbar, text='Help', command=self.help.open,
+ style = 'normal.TButton')
+ self.bbar.help_button.grid(column = 4, row = 0, padx = 5)
+
+ # Define settings button
+ self.bbar.settings_button = ttk.Button(self.bbar, text='Settings',
+ command=self.settings.open, style = 'normal.TButton')
+ self.bbar.settings_button.grid(column = 5, row = 0, padx = 5)
+
+ # Define upload action
+ self.bbar.upload_button = ttk.Button(self.bbar, text='Submit', state = 'enabled',
+ command=self.upload_to_marketplace, style = 'normal.TButton')
+ # "Submit" button remains unplaced; upload may be done from the web side. . .
+ # self.bbar.upload_button.grid(column = 8, row = 0, padx = 5, sticky = 'ens')
+
+ tooltip.ToolTip(self.bbar.quit_button, text = "Exit characterization tool")
+ tooltip.ToolTip(self.bbar.save_button, text = "Save current characterization state")
+ tooltip.ToolTip(self.bbar.saveas_button, text = "Save current characterization state")
+ tooltip.ToolTip(self.bbar.load_button, text = "Load characterization state from file")
+ tooltip.ToolTip(self.bbar.help_button, text = "Start help tool")
+ tooltip.ToolTip(self.bbar.settings_button, text = "Manage characterization tool settings")
+ tooltip.ToolTip(self.bbar.upload_button, text = "Submit completed design to Marketplace")
+
+ # Inside frame with main electrical parameter display and scrollbar
+ # To make the frame scrollable, it must be a frame inside a canvas.
+ self.datasheet_viewer = tkinter.Canvas(self.mframe)
+ self.datasheet_viewer.grid(row = 0, column = 0, sticky = 'nsew')
+ self.datasheet_viewer.dframe = ttk.Frame(self.datasheet_viewer,
+ style='bg.TFrame')
+ # Place the frame in the canvas
+ self.datasheet_viewer.create_window((0,0),
+ window=self.datasheet_viewer.dframe,
+ anchor="nw", tags="self.frame")
+
+ # Make sure the main window resizes, not the scrollbars.
+ self.mframe.rowconfigure(0, weight = 1)
+ self.mframe.columnconfigure(0, weight = 1)
+ # X scrollbar for datasheet viewer
+ main_xscrollbar = ttk.Scrollbar(self.mframe, orient = 'horizontal')
+ main_xscrollbar.grid(row = 1, column = 0, sticky = 'nsew')
+ # Y scrollbar for datasheet viewer
+ main_yscrollbar = ttk.Scrollbar(self.mframe, orient = 'vertical')
+ main_yscrollbar.grid(row = 0, column = 1, sticky = 'nsew')
+ # Attach console to scrollbars
+ self.datasheet_viewer.config(xscrollcommand = main_xscrollbar.set)
+ main_xscrollbar.config(command = self.datasheet_viewer.xview)
+ self.datasheet_viewer.config(yscrollcommand = main_yscrollbar.set)
+ main_yscrollbar.config(command = self.datasheet_viewer.yview)
+
+ # Make sure that scrollwheel pans window
+ self.datasheet_viewer.bind_all("<Button-4>", self.on_mousewheel)
+ self.datasheet_viewer.bind_all("<Button-5>", self.on_mousewheel)
+
+ # Set up configure callback
+ self.datasheet_viewer.dframe.bind("<Configure>", self.frame_configure)
+
+ # Add the panes once the internal geometry is known
+ pane.add(self.toppane)
+ pane.add(self.botpane)
+ pane.paneconfig(self.toppane, stretch='first')
+
+ # Initialize variables
+ self.sims_to_go = []
+
+ # Capture time of start to compare against the annotated
+ # output file timestamp.
+ self.starttime = time.time()
+
+ # 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
+ sys.stdout = ConsoleText.StdoutRedirector(self.text_box)
+ sys.stderr = ConsoleText.StderrRedirector(self.text_box)
+
+ if message:
+ print(message)
+
+ def frame_configure(self, event):
+ self.update_idletasks()
+ self.datasheet_viewer.configure(scrollregion=self.datasheet_viewer.bbox("all"))
+
+ def logstart(self):
+ # Start a logfile (or append to it, if it already exists)
+ # Disabled by default, as it can get very large.
+ # Can be enabled from Settings.
+ if self.settings.get_log() == True:
+ dataroot = os.path.splitext(self.cur_datasheet)[0]
+ if not self.logfile:
+ self.logfile = open(dataroot + '.log', 'a')
+
+ # Print some initial information to the logfile.
+ self.logprint('-------------------------')
+ self.logprint('Starting new log file ' + datetime.datetime.now().strftime('%c'),
+ doflush=True)
+
+ def logstop(self):
+ if self.logfile:
+ self.logprint('-------------------------', doflush=True)
+ self.logfile.close()
+ self.logfile = []
+
+ def logprint(self, message, doflush=False):
+ if self.logfile:
+ self.logfile.buffer.write(message.encode('utf-8'))
+ self.logfile.buffer.write('\n'.encode('utf-8'))
+ if doflush:
+ self.logfile.flush()
+
+ def set_datasheet(self, datasheet):
+ if self.logfile:
+ self.logprint('end of log.')
+ self.logprint('-------------------------', doflush=True)
+ self.logfile.close()
+ self.logfile = None
+
+ if not os.path.isfile(datasheet):
+ print('Error: File ' + datasheet + ' not found.')
+ return
+
+ [dspath, dsname] = os.path.split(datasheet)
+ # Read the datasheet
+ with open(datasheet) as ifile:
+ try:
+ datatop = json.load(ifile)
+ except json.decoder.JSONDecodeError as e:
+ print("Error: Parse error reading JSON file " + datasheet + ':')
+ print(str(e))
+ return
+ else:
+ # 'request-hash' set to '.' for local simulation
+ datatop['request-hash'] = '.'
+ try:
+ dsheet = datatop['data-sheet']
+ except KeyError:
+ print("Error: JSON file is not a datasheet!\n")
+ else:
+ self.datatop = datatop
+ self.cur_datasheet = datasheet
+ self.create_datasheet_view()
+ self.toppane.title2_frame.datasheet_select.configure(text=dsname)
+ self.toppane.title2_frame.path_label.configure(text=datasheet)
+
+ # Determine if there is a saved, annotated JSON file that is
+ # more recent than the netlist used for simulation.
+ self.load_results()
+
+ # Attempt to set the datasheet viewer width to the interior width
+ # but do not set it larger than the available desktop.
+ self.update_idletasks()
+ widthnow = self.datasheet_viewer.winfo_width()
+ width = self.datasheet_viewer.dframe.winfo_width()
+ screen_width = self.root.winfo_screenwidth()
+ if width > widthnow:
+ if width < screen_width - 10:
+ self.datasheet_viewer.configure(width=width)
+ else:
+ self.datasheet_viewer.configure(width=screen_width - 10)
+ elif widthnow > screen_width:
+ self.datasheet_viewer.configure(width=screen_width - 10)
+ elif widthnow > width:
+ self.datasheet_viewer.configure(width=width)
+
+ # Likewise for the height, up to 3/5 of the desktop height.
+ height = self.datasheet_viewer.dframe.winfo_height()
+ heightnow = self.datasheet_viewer.winfo_height()
+ screen_height = self.root.winfo_screenheight()
+ if height > heightnow:
+ if height < screen_height * 0.6:
+ self.datasheet_viewer.configure(height=height)
+ else:
+ self.datasheet_viewer.configure(height=screen_height * 0.6)
+ elif heightnow > screen_height:
+ self.datasheet_viewer.configure(height=screen_height - 10)
+ elif heightnow > height:
+ self.datasheet_viewer.configure(height=height)
+
+ def choose_datasheet(self):
+ datasheet = filedialog.askopenfilename(multiple = False,
+ initialdir = os.path.expanduser('~/design'),
+ filetypes = (("JSON File", "*.json"),("All Files","*.*")),
+ title = "Find a datasheet.")
+ if datasheet != '':
+ self.set_datasheet(datasheet)
+
+ def cancel_upload(self):
+ # Post a cancelation message to CACE. CACE responds by setting the
+ # status to 'canceled'. The watchprogress procedure is responsible for
+ # returning the button to 'Submit' when the characterization finishes
+ # or is canceled.
+ dspath = os.path.split(self.cur_datasheet)[0]
+ datasheet = os.path.split(self.cur_datasheet)[1]
+ designname = os.path.splitext(datasheet)[0]
+ print('Cancel characterization of ' + designname + ' (' + dspath + ' )')
+ subprocess.run(['/ef/apps/bin/withnet',
+ og_config.apps_path + '/cace_design_upload.py', '-cancel',
+ dspath])
+ self.removeprogress()
+ self.bbar.upload_button.configure(text='Submit', state = 'enabled',
+ command=self.upload_to_marketplace,
+ style = 'normal.TButton')
+ # Delete the remote status file.
+ dsdir = dspath + '/ngspice/char'
+ statusname = dsdir + '/remote_status.json'
+ if os.path.exists(statusname):
+ os.remove(statusname)
+
+ def progress_bar_setup(self, dspath):
+ # Create the progress bar at the bottom of the window to indicate
+ # the status of a challenge submission.
+
+ # Disable the Submit button
+ self.bbar.upload_button.configure(state='disabled')
+
+ # Start progress bar watchclock
+ dsdir = dspath + '/ngspice/char'
+ statusname = dsdir + '/remote_status.json'
+ if os.path.exists(statusname):
+ statbuf = os.stat(statusname)
+ mtime = statbuf.st_mtime
+ else:
+ if os.path.exists(dsdir):
+ # Write a simple status
+ status = {'message': 'not started', 'total': '0', 'completed': '0'}
+ with open(statusname, 'w') as f:
+ json.dump(status, f)
+ mtime = 0
+ # Create a TTK progress bar widget in the buttonbar.
+ self.bbar.progress_label = ttk.Label(self.bbar, text="Characterization: ",
+ style = 'normal.TLabel')
+ self.bbar.progress_label.grid(column=4, row=0, ipadx = 5)
+
+ self.bbar.progress_message = ttk.Label(self.bbar, text="(not started)",
+ style = 'blue.TLabel')
+ self.bbar.progress_message.grid(column=5, row=0, ipadx = 5)
+ self.bbar.progress = ttk.Progressbar(self.bbar,
+ orient='horizontal', mode='determinate')
+ self.bbar.progress.grid(column = 6, row = 0, padx = 5, sticky = 'nsew')
+ self.bbar.progress_text = ttk.Label(self.bbar, text="0/0",
+ style = 'blue.TLabel')
+ self.bbar.progress_text.grid(column=7, row=0, ipadx = 5)
+
+ # Start the timer to watch the progress
+ self.watchprogress(statusname, mtime, 1)
+
+ def check_ongoing_upload(self):
+ # Determine if an upload is ongoing when the characterization tool is
+ # started. If so, immediately go to the 'characterization running'
+ # state with progress bar.
+ dspath = os.path.split(self.cur_datasheet)[0]
+ datasheet = os.path.split(self.cur_datasheet)[1]
+ designname = os.path.splitext(datasheet)[0]
+ dsdir = dspath + '/ngspice/char'
+ statusname = dsdir + '/remote_status.json'
+ if os.path.exists(statusname):
+ with open(statusname, 'r') as f:
+ status = json.load(f)
+ if 'message' in status:
+ if status['message'] == 'in progress':
+ print('Design characterization in progress for ' + designname + ' (' + dspath + ' )')
+ self.progress_bar_setup(dspath)
+ else:
+ print("No message in status file")
+
+ def upload_to_marketplace(self):
+ dspath = os.path.split(self.cur_datasheet)[0]
+ datasheet = os.path.split(self.cur_datasheet)[1]
+ dsheet = self.datatop['data-sheet']
+ designname = dsheet['ip-name']
+
+ # Make sure a netlist has been generated.
+ if self.sim_param('check') == False:
+ print('No netlist was generated, cannot submit!')
+ return
+
+ # For diagnostic purposes, place all of the characterization tool
+ # settings into datatop['settings'] when uploading to remote CACE.
+ runtime_settings = {}
+ runtime_settings['force-regenerate'] = self.settings.get_force()
+ runtime_settings['edit-all-params'] = self.settings.get_edit()
+ runtime_settings['keep-files'] = self.settings.get_keep()
+ runtime_settings['make-plots'] = self.settings.get_plot()
+ runtime_settings['submit-test-mode'] = self.settings.get_test()
+ runtime_settings['submit-as-schematic'] = self.settings.get_schem()
+ runtime_settings['submit-failing'] = self.settings.get_submitfailed()
+ runtime_settings['log-output'] = self.settings.get_log()
+
+ # Write out runtime settings as a JSON file
+ with open(dspath + '/settings.json', 'w') as file:
+ json.dump(runtime_settings, file, indent = 4)
+
+ warning = ''
+ must_confirm = False
+ if self.settings.get_schem() == True:
+ # If a layout exists but "submit as schematic" was chosen, then
+ # flag a warning and insist on confirmation.
+ if os.path.exists(dspath + '/mag/' + designname + '.mag'):
+ warning += 'Warning: layout exists but only schematic has been selected for submission'
+ must_confirm = True
+ else:
+ print('No layout in ' + dspath + '/mag/' + designname + '.mag')
+ print('Schematic only submission selection is not needed.')
+ else:
+ # Likewise, check if schematic netlist results are showing but a layout
+ # exists, which means that the existing results are not the ones that are
+ # going to be tested.
+ if self.origin.get() == 'Schematic Capture':
+ if os.path.exists(dspath + '/mag/' + designname + '.mag'):
+ warning += 'Warning: schematic results are shown but remote CACE will be run on layout results.'
+ must_confirm = True
+
+
+ # Make a check to see if all simulations have been made and passed. If so,
+ # then just do the upload. If not, then generate a warning dialog and
+ # require the user to respond to force an upload in spite of an incomplete
+ # simulation. Give dire warnings if any simulation has failed.
+
+ failures = 0
+ missed = 0
+ for param in dsheet['electrical-params']:
+ if 'max' in param:
+ pmax = param['max']
+ if not 'value' in pmax:
+ missed += 1
+ elif 'score' in pmax:
+ if pmax['score'] == 'fail':
+ failures += 1
+ if 'min' in param:
+ pmin = param['min']
+ if not 'value' in pmin:
+ missed += 1
+ elif 'score' in pmin:
+ if pmin['score'] == 'fail':
+ failures += 1
+
+ if missed > 0:
+ if must_confirm == True:
+ warning += '\n'
+ warning += 'Warning: Not all critical parameters have been simulated.'
+ if missed > 0 and failures > 0:
+ warning += '\n'
+ if failures > 0:
+ warning += 'Dire Warning: This design has errors on critical parameters!'
+
+ # Require confirmation
+ if missed > 0 or failures > 0:
+ must_confirm = True
+
+ if must_confirm:
+ if self.settings.get_submitfailed() == True:
+ confirm = ConfirmDialog(self, warning).result
+ else:
+ confirm = PuntDialog(self, warning).result
+ if not confirm == 'okay':
+ print('Upload canceled.')
+ return
+ print('Upload selected')
+
+ # Save hints in file in spi/ directory.
+ hintlist = []
+ for eparam in dsheet['electrical-params']:
+ if not 'editable' in eparam:
+ if 'hints' in eparam:
+ hintlist.append(eparam['hints'])
+ else:
+ # Must have a placeholder
+ hintlist.append({})
+ if hintlist:
+ hfilename = dspath + '/hints.json'
+ with open(hfilename, 'w') as hfile:
+ json.dump(hintlist, hfile, indent = 4)
+
+ print('Uploading design ' + designname + ' (' + dspath + ' )')
+ print('to marketplace and submitting for characterization.')
+ if not self.settings.get_test():
+ self.progress_bar_setup(dspath)
+ self.update_idletasks()
+ subprocess.run(['/ef/apps/bin/withnet',
+ og_config.apps_path + '/cace_design_upload.py',
+ dspath])
+
+ # Remove the settings file
+ os.remove(dspath + '/settings.json')
+ os.remove(dspath + '/hints.json')
+
+ def removeprogress(self):
+ # Remove the progress bar. This is left up for a second after
+ # completion or cancelation so that the final message has time
+ # to be seen.
+ try:
+ self.bbar.progress_label.destroy()
+ self.bbar.progress_message.destroy()
+ self.bbar.progress.destroy()
+ self.bbar.progress_text.destroy()
+ except:
+ pass
+
+ def watchprogress(self, filename, filemtime, timeout):
+ new_timeout = timeout + 1 if timeout > 0 else 0
+ # 2 minute timeout for startup (note that all simulation files have to be
+ # made during this period.
+ if new_timeout == 120:
+ self.cancel_upload()
+ return
+
+ # If file does not exist, then keep checking at 2 second intervals.
+ if not os.path.exists(filename):
+ self.after(2000, lambda: self.watchprogress(filename, filemtime, new_timeout))
+ return
+
+ # If filename file is modified, then update progress bar;
+ # otherwise, restart the clock.
+ statbuf = os.stat(filename)
+ if statbuf.st_mtime > filemtime:
+ self.after(250) # Otherwise can catch file while it's incomplete. . .
+ if self.update_progress(filename) == True:
+ self.after(1000, lambda: self.watchprogress(filename, filemtime, 0))
+ else:
+ # Remove the progress bar when done, after letting the final
+ # message display for a second.
+ self.after(1500, self.removeprogress)
+ # And return the button to "Submit" and in an enabled state.
+ self.bbar.upload_button.configure(text='Submit', state = 'enabled',
+ command=self.upload_to_marketplace,
+ style = 'normal.TButton')
+ else:
+ self.after(1000, lambda: self.watchprogress(filename, filemtime, new_timeout))
+
+ def update_progress(self, filename):
+ # On first update, button changes from "Submit" to "Cancel"
+ # This ensures that the 'remote_status.json' file has been sent
+ # from the CACE with the hash value needed for the CACE to identify
+ # the right simulation and cancel it.
+ if self.bbar.upload_button.configure('text')[-1] == 'Submit':
+ self.bbar.upload_button.configure(text='Cancel', state = 'enabled',
+ command=self.cancel_upload, style = 'red.TButton')
+
+ if not os.path.exists(filename):
+ return False
+
+ # Update the progress bar during an CACE simulation run.
+ # Read the status file
+ try:
+ with open(filename, 'r') as f:
+ status = json.load(f)
+ except (PermissionError, FileNotFoundError):
+ # For a very short time the user does not have ownership of
+ # the file and the read will fail. This is a rare case, so
+ # just punt until the next cycle.
+ return True
+
+ if 'message' in status:
+ self.bbar.progress_message.configure(text = status['message'])
+
+ try:
+ total = int(status['total'])
+ except:
+ total = 0
+ else:
+ self.bbar.progress.configure(maximum = total)
+
+ try:
+ completed = int(status['completed'])
+ except:
+ completed = 0
+ else:
+ self.bbar.progress.configure(value = completed)
+
+ self.bbar.progress_text.configure(text = str(completed) + '/' + str(total))
+ if completed > 0 and completed == total:
+ print('Notice: Design completed.')
+ print('The CACE server has finished characterizing the design.')
+ print('Go to the efabless marketplace to view submission.')
+ return False
+ elif status['message'] == 'canceled':
+ print('Notice: Design characterization was canceled.')
+ return False
+ else:
+ return True
+
+ def topfilter(self, line):
+ # Check output for ubiquitous "Reference value" lines and remove them.
+ # This happens before logging both to the file and to the console.
+ refrex = re.compile('Reference value')
+ rmatch = refrex.match(line)
+ if not rmatch:
+ return line
+ else:
+ return None
+
+ def spicefilter(self, line):
+ # Check for the alarmist 'tran simulation interrupted' message and remove it.
+ # Check for error or warning and print as stderr or stdout accordingly.
+ intrex = re.compile('tran simulation interrupted')
+ warnrex = re.compile('.*warning', re.IGNORECASE)
+ errrex = re.compile('.*error', re.IGNORECASE)
+
+ imatch = intrex.match(line)
+ if not imatch:
+ ematch = errrex.match(line)
+ wmatch = warnrex.match(line)
+ if ematch or wmatch:
+ print(line, file=sys.stderr)
+ else:
+ print(line, file=sys.stdout)
+
+ def printwarn(self, output):
+ # Check output for warning or error
+ if not output:
+ return 0
+
+ warnrex = re.compile('.*warning', re.IGNORECASE)
+ errrex = re.compile('.*error', re.IGNORECASE)
+
+ errors = 0
+ outlines = output.splitlines()
+ for line in outlines:
+ try:
+ wmatch = warnrex.match(line)
+ except TypeError:
+ line = line.decode('utf-8')
+ wmatch = warnrex.match(line)
+ ematch = errrex.match(line)
+ if ematch:
+ errors += 1
+ if ematch or wmatch:
+ print(line)
+ return errors
+
+ def sim_all(self):
+ if self.caceproc:
+ # Failsafe
+ if self.caceproc.poll() != None:
+ self.caceproc = None
+ else:
+ print('Simulation in progress must finish first.')
+ return
+
+ # Create netlist if necessary, check for valid result
+ if self.sim_param('check') == False:
+ return
+
+ # Simulate all of the electrical parameters in turn
+ self.sims_to_go = []
+ for puniq in self.status:
+ self.sims_to_go.append(puniq)
+
+ # Start first sim
+ if len(self.sims_to_go) > 0:
+ puniq = self.sims_to_go[0]
+ self.sims_to_go = self.sims_to_go[1:]
+ self.sim_param(puniq)
+
+ # Button now stops the simulations
+ self.allsimbutton.configure(style = 'redtitle.TButton', text='Stop Simulations',
+ command=self.stop_sims)
+
+ def stop_sims(self):
+ # Make sure there will be no more simulations
+ self.sims_to_go = []
+ if not self.caceproc:
+ print("No simulation running.")
+ return
+ self.caceproc.terminate()
+ # Use communicate(), not wait() , on piped processes to avoid deadlock.
+ try:
+ self.caceproc.communicate(timeout=10)
+ except subprocess.TimeoutExpired:
+ self.caceproc.kill()
+ self.caceproc.communicate()
+ print("CACE process killed.")
+ else:
+ print("CACE process exited.")
+ # Let watchdog timer see that caceproc is gone and reset the button.
+
+ def edit_param(self, param):
+ # Edit the conditions under which the parameter is tested.
+ if ('editable' in param and param['editable'] == True) or self.settings.get_edit() == True:
+ self.editparam.populate(param)
+ self.editparam.open()
+ else:
+ print('Parameter is not editable')
+
+ def copy_param(self, param):
+ # Make a copy of the parameter (for editing)
+ newparam = param.copy()
+ # Make the copied parameter editable
+ newparam['editable'] = True
+ # Append this to the electrical parameter list after the item being copied
+ if 'display' in param:
+ newparam['display'] = param['display'] + ' (copy)'
+ datatop = self.datatop
+ dsheet = datatop['data-sheet']
+ eparams = dsheet['electrical-params']
+ eidx = eparams.index(param)
+ eparams.insert(eidx + 1, newparam)
+ self.create_datasheet_view()
+
+ def delete_param(self, param):
+ # Remove an electrical parameter from the datasheet. This is only
+ # allowed if the parameter has been copied from another and so does
+ # not belong to the original set of parameters.
+ datatop = self.datatop
+ dsheet = datatop['data-sheet']
+ eparams = dsheet['electrical-params']
+ eidx = eparams.index(param)
+ eparams.pop(eidx)
+ self.create_datasheet_view()
+
+ def add_hints(self, param, simbutton):
+ # Raise hints window and configure appropriately for the parameter.
+ # Fill in any existing hints.
+ self.simhints.populate(param, simbutton)
+ self.simhints.open()
+
+ def sim_param(self, method):
+ if self.caceproc:
+ # Failsafe
+ if self.caceproc.poll() != None:
+ self.caceproc = None
+ else:
+ print('Simulation in progress, queued for simulation.')
+ if not method in self.sims_to_go:
+ self.sims_to_go.append(method)
+ return False
+
+ # Get basic values for datasheet and ip-name
+
+ dspath = os.path.split(self.cur_datasheet)[0]
+ dsheet = self.datatop['data-sheet']
+ dname = dsheet['ip-name']
+
+ # Open log file, if specified
+ self.logstart()
+
+ # Check for whether the netlist is specified to come from schematic
+ # or layout. Add a record to the datasheet depending on whether
+ # the netlist is from layout or extracted. The settings window has
+ # a checkbox to force submitting as a schematic even if layout exists.
+
+ if self.origin.get() == 'Schematic Capture':
+ dsheet['netlist-source'] = 'schematic'
+ else:
+ dsheet['netlist-source'] = 'layout'
+
+ if self.settings.get_force() == True:
+ dsheet['regenerate'] = 'force'
+
+ basemethod = method.split('.')[0]
+ if basemethod == 'check': # used by submit to ensure netlist exists
+ return True
+
+ if basemethod == 'physical':
+ print('Checking ' + method.split('.')[1])
+ else:
+ print('Simulating method = ' + basemethod)
+ self.stat_label = self.status[method]
+ self.stat_label.configure(text='(in progress)', style='blue.TLabel')
+ # Update status now
+ self.update_idletasks()
+ print('Datasheet directory is = ' + dspath + '\n')
+
+ # Instead of using the original datasheet, use the one in memory so that
+ # it accumulates results. A "save" button will update the original.
+ if not os.path.isdir(dspath + '/ngspice'):
+ os.makedirs(dspath + '/ngspice')
+ dsdir = dspath + '/ngspice/char'
+ if not os.path.isdir(dsdir):
+ os.makedirs(dsdir)
+ with open(dsdir + '/datasheet.json', 'w') as file:
+ json.dump(self.datatop, file, indent = 4)
+ # As soon as we call CACE, we will be watching the status of file
+ # datasheet_anno. So create it if it does not exist, else attempting
+ # to stat a nonexistant file will cause the 1st simulation to fail.
+ if not os.path.exists(dsdir + '/datasheet_anno.json'):
+ open(dsdir + '/datasheet_anno.json', 'a').close()
+ # Call cace_gensim with full set of options
+ # First argument is the root directory
+ # (Diagnostic)
+ design_path = dspath + '/spi'
+
+ print('Calling cace_gensim.py ' + dspath +
+ ' -local -method=' + method)
+
+ modetext = ['-local']
+ if self.settings.get_keep() == True:
+ print(' -keep ')
+ modetext.append('-keep')
+
+ if self.settings.get_plot() == True:
+ print(' -plot ')
+ modetext.append('-plot')
+
+ print(' -simdir=' + dsdir + ' -datasheetdir=' + dsdir + ' -designdir=' + design_path)
+ print(' -layoutdir=' + dspath + '/mag' + ' -testbenchdir=' + dspath + '/testbench')
+ print(' -datasheet=datasheet.json')
+
+ self.caceproc = subprocess.Popen([og_config.apps_path + '/cace_gensim.py', dspath,
+ *modetext,
+ '-method=' + method, # Call local mode w/method
+ '-simdir=' + dsdir,
+ '-datasheetdir=' + dsdir,
+ '-designdir=' + design_path,
+ '-layoutdir=' + dspath + '/mag',
+ '-testbenchdir=' + dspath + '/testbench',
+ '-datasheet=datasheet.json'],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0)
+
+ # Simulation finishes on its own time. Use watchdog to handle.
+ # Note that python "watchdog" is threaded, and tkinter is not thread-safe.
+ # So watchdog is done with a simple timer loop.
+ statbuf = os.stat(dsdir + '/datasheet.json')
+ checktime = statbuf.st_mtime
+
+ filename = dsdir + '/datasheet_anno.json'
+ statbuf = os.stat(filename)
+ self.watchclock(filename, statbuf.st_mtime, checktime)
+
+ def watchclock(self, filename, filemtime, checktime):
+ # In case simulations cleared while watchclock was pending
+ if self.caceproc == None:
+ return
+ # Poll cace_gensim to see if it finished
+ cace_status = self.caceproc.poll()
+ if cace_status != None:
+ try:
+ output = self.caceproc.communicate(timeout=1)
+ except ValueError:
+ print("CACE gensim forced stop, status " + str(cace_status))
+ else:
+ outlines = output[0]
+ errlines = output[1]
+ for line in outlines.splitlines():
+ print(line.decode('utf-8'))
+ for line in errlines.splitlines():
+ print(line.decode('utf-8'))
+ print("CACE gensim exited with status " + str(cace_status))
+ else:
+ n = 0
+ while True:
+ self.update_idletasks()
+ # Attempt to avoid infinite loop, unsure of the cause.
+ n += 1
+ if n > 100:
+ n = 0
+ cace_status = self.caceproc.poll()
+ if cace_status != None:
+ break
+ self.logprint("100 lines of output", doflush=True)
+ # Something went wrong. Kill the process.
+ # self.stop_sims()
+ sresult = select.select([self.caceproc.stdout, self.caceproc.stderr], [], [], 0)[0]
+ if self.caceproc.stdout in sresult:
+ outstring = self.caceproc.stdout.readline().decode().strip()
+ self.logprint(outstring, doflush=True)
+ print(outstring)
+ elif self.caceproc.stderr in sresult:
+ # ngspice passes back simulation time on stderr. This ends in \r but no
+ # newline. '\r' ends the transmission, so return.
+ # errstring = self.topfilter(self.caceproc.stderr.readline().decode().strip())
+ # if errstring:
+ # self.logprint(errstring, doflush=True)
+ # # Recast everything that isn't an error back into stdout.
+ # self.spicefilter(errstring)
+ ochar = str(self.caceproc.stderr.read(1).decode())
+ if ochar == '\r':
+ print('')
+ break
+ else:
+ print(ochar, end='')
+ else:
+ break
+
+ # If filename file is modified, then call annotate; otherwise, restart the clock.
+ statbuf = os.stat(filename)
+ if (statbuf.st_mtime > filemtime) or (cace_status != None):
+ if cace_status != None:
+ self.caceproc = None
+ else:
+ # Re-run to catch last output.
+ self.after(500, lambda: self.watchclock(filename, statbuf.st_mtime, checktime))
+ return
+ if cace_status != 0:
+ print('Errors encountered in simulation.')
+ self.logprint('Errors in simulation, CACE status = ' + str(cace_status), doflush=True)
+ self.annotate('anno', checktime)
+ if len(self.sims_to_go) > 0:
+ puniq = self.sims_to_go[0]
+ self.sims_to_go = self.sims_to_go[1:]
+ self.sim_param(puniq)
+ else:
+ # Button goes back to original text and command
+ self.allsimbutton.configure(style = 'bluetitle.TButton',
+ text='Simulate All', command = self.sim_all)
+ elif not self.caceproc:
+ # Process terminated by "stop"
+ # Button goes back to original text and command
+ self.allsimbutton.configure(style = 'bluetitle.TButton',
+ text='Simulate All', command = self.sim_all)
+ # Just redraw everthing so that the "(in progress)" message goes away.
+ self.annotate('anno', checktime)
+ else:
+ self.after(500, lambda: self.watchclock(filename, filemtime, checktime))
+
+ def clear_results(self, dsheet):
+ # Remove results from the window by clearing parameter results
+ paramstodo = []
+ if 'electrical-params' in dsheet:
+ paramstodo.extend(dsheet['electrical-params'])
+ if 'physical-params' in dsheet:
+ paramstodo.extend(dsheet['physical-params'])
+
+ for param in paramstodo:
+ # Fill frame with electrical parameter information
+ if 'max' in param:
+ maxrec = param['max']
+ if 'value' in maxrec:
+ maxrec.pop('value')
+ if 'score' in maxrec:
+ maxrec.pop('score')
+ if 'typ' in param:
+ typrec = param['typ']
+ if 'value' in typrec:
+ typrec.pop('value')
+ if 'score' in typrec:
+ typrec.pop('score')
+ if 'min' in param:
+ minrec = param['min']
+ if 'value' in minrec:
+ minrec.pop('value')
+ if 'score' in minrec:
+ minrec.pop('score')
+ if 'results' in param:
+ param.pop('results')
+
+ if 'plot' in param:
+ plotrec = param['plot']
+ if 'status' in plotrec:
+ plotrec.pop('status')
+
+ # Regenerate datasheet view
+ self.create_datasheet_view()
+
+ def annotate(self, suffix, checktime):
+ # Pull results back from datasheet_anno.json. Do NOT load this
+ # file if it predates the unannotated datasheet (that indicates
+ # simulator failure, and no results).
+ dspath = os.path.split(self.cur_datasheet)[0]
+ dsdir = dspath + '/ngspice/char'
+ anno = dsdir + '/datasheet_' + suffix + '.json'
+ unanno = dsdir + '/datasheet.json'
+
+ if os.path.exists(anno):
+ statbuf = os.stat(anno)
+ mtimea = statbuf.st_mtime
+ if checktime >= mtimea:
+ # print('original = ' + str(checktime) + ' annotated = ' + str(mtimea))
+ print('Error in simulation, no update to results.', file=sys.stderr)
+ elif statbuf.st_size == 0:
+ print('Error in simulation, no results.', file=sys.stderr)
+ else:
+ with open(anno, 'r') as file:
+ self.datatop = json.load(file)
+ else:
+ print('Error in simulation, no update to results.', file=sys.stderr)
+
+ # Regenerate datasheet view
+ self.create_datasheet_view()
+
+ # Close log file, if it was enabled in the settings
+ self.logstop()
+
+ def save_results(self):
+ # Write datasheet_save with all the locally processed results.
+ dspath = os.path.split(self.cur_datasheet)[0]
+ dsdir = dspath + '/ngspice/char'
+
+ if self.origin.get() == 'Layout Extracted':
+ jsonfile = dsdir + '/datasheet_lsave.json'
+ else:
+ jsonfile = dsdir + '/datasheet_save.json'
+
+ with open(jsonfile, 'w') as ofile:
+ json.dump(self.datatop, ofile, indent = 4)
+ self.last_save = os.path.getmtime(jsonfile)
+
+ # Create copy of datasheet without result data. This is
+ # the file appropriate to insert into the IP catalog
+ # metadata JSON file.
+
+ datacopy = copy.copy(self.datatop)
+ dsheet = datacopy['data-sheet']
+ if 'electrical-params' in dsheet:
+ for eparam in dsheet['electrical-params']:
+ if 'results' in eparam:
+ eparam.pop('results')
+
+ datacopy.pop('request-hash')
+ jsonfile = dsdir + '/datasheet_compact.json'
+ with open(jsonfile, 'w') as ofile:
+ json.dump(datacopy, ofile, indent = 4)
+
+ print('Characterization results saved.')
+
+ def check_saved(self):
+ # Check if there is a file 'datasheet_save' and if it is more
+ # recent than 'datasheet_anno'. If so, return True, else False.
+
+ [dspath, dsname] = os.path.split(self.cur_datasheet)
+ dsdir = dspath + '/ngspice/char'
+
+ if self.origin.get() == 'Layout Extracted':
+ savefile = dsdir + '/datasheet_lsave.json'
+ else:
+ savefile = dsdir + '/datasheet_save.json'
+
+ annofile = dsdir + '/datasheet_anno.json'
+ if os.path.exists(annofile):
+ annotime = os.path.getmtime(annofile)
+
+ # If nothing has been updated since the characterization
+ # tool was started, then there is no new information to save.
+ if annotime < self.starttime:
+ return True
+
+ if os.path.exists(savefile):
+ savetime = os.path.getmtime(savefile)
+ # return True if (savetime > annotime) else False
+ if savetime > annotime:
+ print("Save is more recent than sim, so no need to save.")
+ return True
+ else:
+ print("Sim is more recent than save, so need to save.")
+ return False
+ else:
+ # There is a datasheet_anno file but no datasheet_save,
+ # so there are necessarily unsaved results.
+ print("no datasheet_save, so any results have not been saved.")
+ return False
+ else:
+ # There is no datasheet_anno file, so datasheet_save
+ # is either current or there have been no simulations.
+ print("no datasheet_anno, so there are no results to save.")
+ return True
+
+ def callback(self):
+ # Check for manual load/save-as status from settings window (callback
+ # when the settings window is closed).
+ if self.settings.get_loadsave() == True:
+ self.bbar.saveas_button.grid(column=2, row=0, padx = 5)
+ self.bbar.load_button.grid(column=3, row=0, padx = 5)
+ else:
+ self.bbar.saveas_button.grid_forget()
+ self.bbar.load_button.grid_forget()
+
+ def save_manual(self, value={}):
+ dspath = self.cur_datasheet
+ # Set initialdir to the project where cur_datasheet is located
+ dsparent = os.path.split(dspath)[0]
+
+ datasheet = filedialog.asksaveasfilename(multiple = False,
+ initialdir = dsparent,
+ confirmoverwrite = True,
+ defaultextension = ".json",
+ filetypes = (("JSON File", "*.json"),("All Files","*.*")),
+ title = "Select filename for saved datasheet.")
+ with open(datasheet, 'w') as ofile:
+ json.dump(self.datatop, ofile, indent = 4)
+
+ def load_manual(self, value={}):
+ dspath = self.cur_datasheet
+ # Set initialdir to the project where cur_datasheet is located
+ dsparent = os.path.split(dspath)[0]
+
+ datasheet = filedialog.askopenfilename(multiple = False,
+ initialdir = dsparent,
+ filetypes = (("JSON File", "*.json"),("All Files","*.*")),
+ title = "Find a datasheet.")
+ if datasheet != '':
+ try:
+ with open(datasheet, 'r') as file:
+ self.datatop = json.load(file)
+ except:
+ print('Error in file, no update to results.', file=sys.stderr)
+
+ else:
+ # Regenerate datasheet view
+ self.create_datasheet_view()
+
+ def load_results(self, value={}):
+ # Check if datasheet_save exists and is more recent than the
+ # latest design netlist. If so, load it; otherwise, not.
+ # NOTE: Name of .spi file comes from the project 'ip-name'
+ # in the datasheet.
+
+ [dspath, dsname] = os.path.split(self.cur_datasheet)
+ try:
+ dsheet = self.datatop['data-sheet']
+ except KeyError:
+ return
+
+ dsroot = dsheet['ip-name']
+
+ # Remove any existing results from the datasheet records
+ self.clear_results(dsheet)
+
+ # Also must be more recent than datasheet
+ jtime = os.path.getmtime(self.cur_datasheet)
+
+ # dsroot = os.path.splitext(dsname)[0]
+
+ dsdir = dspath + '/spi'
+ if self.origin.get() == 'Layout Extracted':
+ spifile = dsdir + '/pex/' + dsroot + '.spi'
+ savesuffix = 'lsave'
+ else:
+ spifile = dsdir + '/' + dsroot + '.spi'
+ savesuffix = 'save'
+
+ dsdir = dspath + '/ngspice/char'
+ savefile = dsdir + '/datasheet_' + savesuffix + '.json'
+
+ if os.path.exists(savefile):
+ savetime = os.path.getmtime(savefile)
+
+ if os.path.exists(spifile):
+ spitime = os.path.getmtime(spifile)
+
+ if os.path.exists(savefile):
+ if (savetime > spitime and savetime > jtime):
+ self.annotate(savesuffix, 0)
+ print('Characterization results loaded.')
+ # print('(' + savefile + ' timestamp = ' + str(savetime) + '; ' + self.cur_datasheet + ' timestamp = ' + str(jtime))
+ else:
+ print('Saved datasheet is out-of-date, not loading')
+ else:
+ print('Datasheet file ' + savefile)
+ print('No saved datasheet file, nothing to pre-load')
+ else:
+ print('No netlist file ' + spifile + '!')
+
+ # Remove outdated datasheet.json and datasheet_anno.json to prevent
+ # them from overwriting characterization document entries
+
+ if os.path.exists(savefile):
+ if savetime < jtime:
+ print('Removing outdated save file ' + savefile)
+ os.remove(savefile)
+
+ savefile = dsdir + '/datasheet_anno.json'
+ if os.path.exists(savefile):
+ savetime = os.path.getmtime(savefile)
+ if savetime < jtime:
+ print('Removing outdated results file ' + savefile)
+ os.remove(savefile)
+
+ savefile = dsdir + '/datasheet.json'
+ if os.path.exists(savefile):
+ savetime = os.path.getmtime(savefile)
+ if savetime < jtime:
+ print('Removing outdated results file ' + savefile)
+ os.remove(savefile)
+
+ def create_datasheet_view(self):
+ dframe = self.datasheet_viewer.dframe
+
+ # Destroy the existing datasheet frame contents (if any)
+ for widget in dframe.winfo_children():
+ widget.destroy()
+ self.status = {} # Clear dictionary
+
+ dsheet = self.datatop['data-sheet']
+ if 'global-conditions' in dsheet:
+ globcond = dsheet['global-conditions']
+ else:
+ globcond = []
+
+ # Add basic information at the top
+
+ n = 0
+ dframe.cframe = ttk.Frame(dframe)
+ dframe.cframe.grid(column = 0, row = n, sticky='ewns', columnspan = 10)
+
+ dframe.cframe.plabel = ttk.Label(dframe.cframe, text = 'Project IP name:',
+ style = 'italic.TLabel')
+ dframe.cframe.plabel.grid(column = 0, row = n, sticky='ewns', ipadx = 5)
+ dframe.cframe.pname = ttk.Label(dframe.cframe, text = dsheet['ip-name'],
+ style = 'normal.TLabel')
+ dframe.cframe.pname.grid(column = 1, row = n, sticky='ewns', ipadx = 5)
+ dframe.cframe.fname = ttk.Label(dframe.cframe, text = dsheet['foundry'],
+ style = 'normal.TLabel')
+ dframe.cframe.fname.grid(column = 2, row = n, sticky='ewns', ipadx = 5)
+ dframe.cframe.fname = ttk.Label(dframe.cframe, text = dsheet['node'],
+ style = 'normal.TLabel')
+ dframe.cframe.fname.grid(column = 3, row = n, sticky='ewns', ipadx = 5)
+ if 'decription' in dsheet:
+ dframe.cframe.pdesc = ttk.Label(dframe.cframe, text = dsheet['description'],
+ style = 'normal.TLabel')
+ dframe.cframe.pdesc.grid(column = 4, row = n, sticky='ewns', ipadx = 5)
+
+ if 'UID' in self.datatop:
+ n += 1
+ dframe.cframe.ulabel = ttk.Label(dframe.cframe, text = 'UID:',
+ style = 'italic.TLabel')
+ dframe.cframe.ulabel.grid(column = 0, row = n, sticky='ewns', ipadx = 5)
+ dframe.cframe.uname = ttk.Label(dframe.cframe, text = self.datatop['UID'],
+ style = 'normal.TLabel')
+ dframe.cframe.uname.grid(column = 1, row = n, columnspan = 5, sticky='ewns', ipadx = 5)
+
+ n = 1
+ ttk.Separator(dframe, orient='horizontal').grid(column=0, row=n, sticky='ewns', columnspan=10)
+
+ # Title block
+ n += 1
+ dframe.desc_title = ttk.Label(dframe, text = 'Parameter', style = 'title.TLabel')
+ dframe.desc_title.grid(column = 0, row = n, sticky='ewns')
+ dframe.method_title = ttk.Label(dframe, text = 'Method', style = 'title.TLabel')
+ dframe.method_title.grid(column = 1, row = n, sticky='ewns')
+ dframe.min_title = ttk.Label(dframe, text = 'Min', style = 'title.TLabel')
+ dframe.min_title.grid(column = 2, row = n, sticky='ewns', columnspan = 2)
+ dframe.typ_title = ttk.Label(dframe, text = 'Typ', style = 'title.TLabel')
+ dframe.typ_title.grid(column = 4, row = n, sticky='ewns', columnspan = 2)
+ dframe.max_title = ttk.Label(dframe, text = 'Max', style = 'title.TLabel')
+ dframe.max_title.grid(column = 6, row = n, sticky='ewns', columnspan = 2)
+ dframe.stat_title = ttk.Label(dframe, text = 'Status', style = 'title.TLabel')
+ dframe.stat_title.grid(column = 8, row = n, sticky='ewns')
+
+ if not self.sims_to_go:
+ self.allsimbutton = ttk.Button(dframe, text='Simulate All',
+ style = 'bluetitle.TButton', command = self.sim_all)
+ else:
+ self.allsimbutton = ttk.Button(dframe, text='Stop Simulations',
+ style = 'redtitle.TButton', command = self.stop_sims)
+ self.allsimbutton.grid(column = 9, row=n, sticky='ewns')
+
+ tooltip.ToolTip(self.allsimbutton, text = "Simulate all electrical parameters")
+
+ # Make all columns equally expandable
+ for i in range(10):
+ dframe.columnconfigure(i, weight = 1)
+
+ # Parse the file for electrical parameters
+ n += 1
+ binrex = re.compile(r'([0-9]*)\'([bodh])', re.IGNORECASE)
+ paramstodo = []
+ if 'electrical-params' in dsheet:
+ paramstodo.extend(dsheet['electrical-params'])
+ if 'physical-params' in dsheet:
+ paramstodo.extend(dsheet['physical-params'])
+
+ if self.origin.get() == 'Schematic Capture':
+ isschem = True
+ else:
+ isschem = False
+
+ for param in paramstodo:
+ # Fill frame with electrical parameter information
+ if 'method' in param:
+ p = param['method']
+ puniq = p + '.0'
+ if puniq in self.status:
+ # This method was used before, so give it a unique identifier
+ j = 1
+ while True:
+ puniq = p + '.' + str(j)
+ if puniq not in self.status:
+ break
+ else:
+ j += 1
+ else:
+ j = 0
+ paramtype = 'electrical'
+ else:
+ paramtype = 'physical'
+ p = param['condition']
+ puniq = paramtype + '.' + p
+ j = 0
+
+ if 'editable' in param and param['editable'] == True:
+ normlabel = 'hlight.TLabel'
+ redlabel = 'rhlight.TLabel'
+ greenlabel = 'ghlight.TLabel'
+ normbutton = 'hlight.TButton'
+ redbutton = 'rhlight.TButton'
+ greenbutton = 'ghlight.TButton'
+ else:
+ normlabel = 'normal.TLabel'
+ redlabel = 'red.TLabel'
+ greenlabel = 'green.TLabel'
+ normbutton = 'normal.TButton'
+ redbutton = 'red.TButton'
+ greenbutton = 'green.TButton'
+
+ if 'display' in param:
+ dtext = param['display']
+ else:
+ dtext = p
+
+ # Special handling: Change LVS_errors to "device check" when using
+ # schematic netlist.
+ if paramtype == 'physical':
+ if isschem:
+ if p == 'LVS_errors':
+ dtext = 'Invalid device check'
+
+ dframe.description = ttk.Label(dframe, text = dtext, style = normlabel)
+
+ dframe.description.grid(column = 0, row=n, sticky='ewns')
+ dframe.method = ttk.Label(dframe, text = p, style = normlabel)
+ dframe.method.grid(column = 1, row=n, sticky='ewns')
+ if 'plot' in param:
+ status_style = normlabel
+ dframe.plots = ttk.Frame(dframe)
+ dframe.plots.grid(column = 2, row=n, columnspan = 6, sticky='ewns')
+ plotrec = param['plot']
+ if 'status' in plotrec:
+ status_value = plotrec['status']
+ else:
+ status_value = '(not checked)'
+ dframe_plot = ttk.Label(dframe.plots, text=plotrec['filename'],
+ style = normlabel)
+ dframe_plot.grid(column = j, row = n, sticky='ewns')
+ else:
+ # For schematic capture, mark physical parameters that can't and won't be
+ # checked as "not applicable".
+ status_value = '(not checked)'
+ if paramtype == 'physical':
+ if isschem:
+ if p == 'area' or p == 'width' or p == 'height' or p == 'DRC_errors':
+ status_value = '(N/A)'
+
+ if 'min' in param:
+ status_style = normlabel
+ pmin = param['min']
+ if 'target' in pmin:
+ if 'unit' in param and not binrex.match(param['unit']):
+ targettext = pmin['target'] + ' ' + param['unit']
+ else:
+ targettext = pmin['target']
+ # Hack for use of min to change method of scoring
+ if not 'penalty' in pmin or pmin['penalty'] != '0':
+ dframe.min = ttk.Label(dframe, text=targettext, style = normlabel)
+ else:
+ dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ else:
+ dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ if 'score' in pmin:
+ if pmin['score'] != 'fail':
+ status_style = greenlabel
+ if status_value != 'fail':
+ status_value = 'pass'
+ else:
+ status_style = redlabel
+ status_value = 'fail'
+ if 'value' in pmin:
+ if 'unit' in param and not binrex.match(param['unit']):
+ valuetext = pmin['value'] + ' ' + param['unit']
+ else:
+ valuetext = pmin['value']
+ dframe.value = ttk.Label(dframe, text=valuetext, style=status_style)
+ dframe.value.grid(column = 3, row=n, sticky='ewns')
+ else:
+ dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ dframe.min.grid(column = 2, row=n, sticky='ewns')
+ if 'typ' in param:
+ status_style = normlabel
+ ptyp = param['typ']
+ if 'target' in ptyp:
+ if 'unit' in param and not binrex.match(param['unit']):
+ targettext = ptyp['target'] + ' ' + param['unit']
+ else:
+ targettext = ptyp['target']
+ dframe.typ = ttk.Label(dframe, text=targettext, style = normlabel)
+ else:
+ dframe.typ = ttk.Label(dframe, text='(no target)', style = normlabel)
+ if 'score' in ptyp:
+ # Note: You can't fail a "typ" score, but there is only one "Status",
+ # so if it is a "fail", it must remain a "fail".
+ if ptyp['score'] != 'fail':
+ status_style = greenlabel
+ if status_value != 'fail':
+ status_value = 'pass'
+ else:
+ status_style = redlabel
+ status_value = 'fail'
+ if 'value' in ptyp:
+ if 'unit' in param and not binrex.match(param['unit']):
+ valuetext = ptyp['value'] + ' ' + param['unit']
+ else:
+ valuetext = ptyp['value']
+ dframe.value = ttk.Label(dframe, text=valuetext, style=status_style)
+ dframe.value.grid(column = 5, row=n, sticky='ewns')
+ else:
+ dframe.typ = ttk.Label(dframe, text='(no target)', style = normlabel)
+ dframe.typ.grid(column = 4, row=n, sticky='ewns')
+ if 'max' in param:
+ status_style = normlabel
+ pmax = param['max']
+ if 'target' in pmax:
+ if 'unit' in param and not binrex.match(param['unit']):
+ targettext = pmax['target'] + ' ' + param['unit']
+ else:
+ targettext = pmax['target']
+ # Hack for use of max to change method of scoring
+ if not 'penalty' in pmax or pmax['penalty'] != '0':
+ dframe.max = ttk.Label(dframe, text=targettext, style = normlabel)
+ else:
+ dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ else:
+ dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ if 'score' in pmax:
+ if pmax['score'] != 'fail':
+ status_style = greenlabel
+ if status_value != 'fail':
+ status_value = 'pass'
+ else:
+ status_style = redlabel
+ status_value = 'fail'
+ if 'value' in pmax:
+ if 'unit' in param and not binrex.match(param['unit']):
+ valuetext = pmax['value'] + ' ' + param['unit']
+ else:
+ valuetext = pmax['value']
+ dframe.value = ttk.Label(dframe, text=valuetext, style=status_style)
+ dframe.value.grid(column = 7, row=n, sticky='ewns')
+ else:
+ dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel)
+ dframe.max.grid(column = 6, row=n, sticky='ewns')
+
+ if paramtype == 'electrical':
+ if 'hints' in param:
+ simtext = '\u2022Simulate'
+ else:
+ simtext = 'Simulate'
+ else:
+ simtext = 'Check'
+
+ simbutton = ttk.Menubutton(dframe, text=simtext, style = normbutton)
+
+ # Generate pull-down menu on Simulate button. Most items apply
+ # only to electrical parameters (at least for now)
+ simmenu = tkinter.Menu(simbutton)
+ simmenu.add_command(label='Run',
+ command = lambda puniq=puniq: self.sim_param(puniq))
+ simmenu.add_command(label='Stop', command = self.stop_sims)
+ if paramtype == 'electrical':
+ simmenu.add_command(label='Hints',
+ command = lambda param=param, simbutton=simbutton: self.add_hints(param, simbutton))
+ simmenu.add_command(label='Edit',
+ command = lambda param=param: self.edit_param(param))
+ simmenu.add_command(label='Copy',
+ command = lambda param=param: self.copy_param(param))
+ if 'editable' in param and param['editable'] == True:
+ simmenu.add_command(label='Delete',
+ command = lambda param=param: self.delete_param(param))
+
+ # Attach the menu to the button
+ simbutton.config(menu=simmenu)
+
+ # simbutton = ttk.Button(dframe, text=simtext, style = normbutton)
+ # command = lambda puniq=puniq: self.sim_param(puniq))
+
+ simbutton.grid(column = 9, row=n, sticky='ewns')
+
+ if paramtype == 'electrical':
+ tooltip.ToolTip(simbutton, text = "Simulate one electrical parameter")
+ else:
+ tooltip.ToolTip(simbutton, text = "Check one physical parameter")
+
+ # If 'pass', then just display message. If 'fail', then create a button that
+ # opens and configures the failure report window.
+ if status_value == '(not checked)':
+ bstyle=normbutton
+ stat_label = ttk.Label(dframe, text=status_value, style=bstyle)
+ else:
+ if status_value == 'fail':
+ bstyle=redbutton
+ else:
+ bstyle=greenbutton
+ if paramtype == 'electrical':
+ stat_label = ttk.Button(dframe, text=status_value, style=bstyle,
+ command = lambda param=param, globcond=globcond:
+ self.failreport.display(param, globcond,
+ self.cur_datasheet))
+ elif p == 'LVS_errors':
+ dspath = os.path.split(self.cur_datasheet)[0]
+ datasheet = os.path.split(self.cur_datasheet)[1]
+ dsheet = self.datatop['data-sheet']
+ designname = dsheet['ip-name']
+ if self.origin.get() == 'Schematic Capture':
+ lvs_file = dspath + '/mag/precheck.log'
+ else:
+ lvs_file = dspath + '/mag/comp.out'
+ if not os.path.exists(lvs_file):
+ if os.path.exists(dspath + '/mag/precheck.log'):
+ lvs_file = dspath + '/mag/precheck.log'
+ elif os.path.exists(dspath + '/mag/comp.out'):
+ lvs_file = dspath + '/mag/comp.out'
+
+ stat_label = ttk.Button(dframe, text=status_value, style=bstyle,
+ command = lambda lvs_file=lvs_file: self.textreport.display(lvs_file))
+ else:
+ stat_label = ttk.Label(dframe, text=status_value, style=bstyle)
+ tooltip.ToolTip(stat_label,
+ text = "Show detail view of simulation conditions and results")
+ stat_label.grid(column = 8, row=n, sticky='ewns')
+ self.status[puniq] = stat_label
+ n += 1
+
+ for child in dframe.winfo_children():
+ child.grid_configure(ipadx = 5, ipady = 1, padx = 2, pady = 2)
+
+ # Check if a design submission and characterization may be in progress.
+ # If so, add the progress bar at the bottom.
+ self.check_ongoing_upload()
+
+if __name__ == '__main__':
+ faulthandler.register(signal.SIGUSR2)
+ options = []
+ arguments = []
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ root = tkinter.Tk()
+ app = OpenGalaxyCharacterize(root)
+ if arguments:
+ print('Calling set_datasheet with argument ' + arguments[0])
+ app.set_datasheet(arguments[0])
+
+ root.mainloop()
diff --git a/common/og_gui_manager.py b/common/og_gui_manager.py
new file mode 100755
index 0000000..921b3f1
--- /dev/null
+++ b/common/og_gui_manager.py
@@ -0,0 +1,4138 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3 -B
+#
+#--------------------------------------------------------
+# Open Galaxy Project Manager GUI.
+#
+# This is a Python tkinter script that handles local
+# project management. It is meant as a replacement for
+# appsel_zenity.sh
+#
+#--------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# September 9, 2016
+# Modifications 2017, 2018
+# Version 1.0
+#--------------------------------------------------------
+
+import sys
+# Require python 3.5.x (and not python 3.6.x). Without this trap here, in several
+# instances of VMs where /usr/bin/python3 symlinked to 3.6.x by mistake, it manifests
+# as (misleading) errors like: ImportError: No module named 'yaml'
+#
+# '%x' % sys.hexversion -> '30502f0'
+
+import tkinter
+from tkinter import ttk, StringVar, Listbox, END
+from tkinter import filedialog
+
+# globals
+theProg = sys.argv[0]
+root = tkinter.Tk() # WARNING: must be exactly one instance of Tk; don't call again elsewhere
+
+# 4 configurations based on booleans: splash,defer
+# n,n: no splash, show only form when completed: LEGACY MODE, user confused by visual lag.
+# n,y: no splash but defer projLoad: show an empty form ASAP
+# y,n: yes splash, and wait for projLoad before showing completed form
+# y,y: yes splash, but also defer projLoad: show empty form ASAP
+
+# deferLoad = False # LEGACY: no splash, and wait for completed form
+# doSplash = False
+
+deferLoad = True # True: display GUI before (slow) loading of projects, so no splash:
+doSplash = not deferLoad # splash IFF GUI-construction includes slow loading of projects
+
+# deferLoad = False # load projects before showing form, so need splash:
+# doSplash = not deferLoad # splash IFF GUI-construction includes slow loading of projects
+
+# deferLoad = True # here keep splash also, despite also deferred-loading
+# doSplash = True
+
+#------------------------------------------------------
+# Splash screen: display ASAP: BEFORE bulk of imports.
+#------------------------------------------------------
+
+class SplashScreen(tkinter.Toplevel):
+ """Open Galaxy Project Management Splash Screen"""
+
+ def __init__(self, parent, *args, **kwargs):
+ super().__init__(parent, *args, **kwargs)
+ parent.withdraw()
+ #EFABLESS PLATFORM
+ #image = tkinter.PhotoImage(file="/ef/efabless/opengalaxy/og_splashscreen50.gif")
+ label = ttk.Label(self, image=image)
+ label.pack()
+
+ # required to make window show before the program gets to the mainloop
+ self.update_idletasks()
+
+import faulthandler
+import signal
+
+# SplashScreen here. fyi: there's a 2nd/later __main__ section for main app
+splash = None # a global
+if __name__ == '__main__':
+ faulthandler.register(signal.SIGUSR2)
+ if doSplash:
+ splash = SplashScreen(root)
+
+import io
+import os
+import re
+import json
+import yaml
+import shutil
+import tarfile
+import datetime
+import subprocess
+import contextlib
+import tempfile
+import glob
+
+import tksimpledialog
+import tooltip
+from rename_project import rename_project_all
+#from fix_libdirs import fix_libdirs
+from consoletext import ConsoleText
+from helpwindow import HelpWindow
+from treeviewchoice import TreeViewChoice
+from symbolbuilder import SymbolBuilder
+from make_icon_from_soft import create_symbol
+from profile import Profile
+
+import og_config
+
+# Global name for design directory
+designdir = 'design'
+# Global name for import directory
+importdir = 'import'
+# Global name for cloudv directory
+cloudvdir = 'cloudv'
+# Global name for archived imports project sub-directory
+archiveimportdir = 'imported'
+# Global name for current design file
+#EFABLESS PLATFORM
+currdesign = '~/.open_pdks/currdesign'
+prefsfile = '~/.open_pdks/prefs.json'
+
+
+#---------------------------------------------------------------
+# Watch a directory for modified time change. Repeat every two
+# seconds. Call routine callback() if a change occurs
+#---------------------------------------------------------------
+
+class WatchClock(object):
+ def __init__(self, parent, path, callback, interval=2000, interval0=None):
+ self.parent = parent
+ self.callback = callback
+ self.path = path
+ self.interval = interval
+ if interval0 != None:
+ self.interval0 = interval0
+ self.restart(first=True)
+ else:
+ self.interval0 = interval
+ self.restart()
+
+ def query(self):
+ for entry in self.path:
+ statbuf = os.stat(entry)
+ if statbuf.st_mtime > self.reftime:
+ self.callback()
+ self.restart()
+ return
+ self.timer = self.parent.after(self.interval, self.query)
+
+ def stop(self):
+ self.parent.after_cancel(self.timer)
+
+ # if first: optionally use different (typically shorter) interval, AND DON'T
+ # pre-record watched-dir mtime-s (which forces the callback on first timer fire)
+ def restart(self, first=False):
+ self.reftime = 0
+ if not first:
+ for entry in self.path:
+ statbuf = os.stat(entry)
+ if statbuf.st_mtime > self.reftime:
+ self.reftime = statbuf.st_mtime
+ self.timer = self.parent.after(self.interval0 if first and self.interval0 != None else self.interval, self.query)
+
+#------------------------------------------------------
+# Dialog for generating a new layout
+#------------------------------------------------------
+
+class NewLayoutDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed=''):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+
+ self.l1prefs = tkinter.IntVar(master)
+ self.l1prefs.set(1)
+ ttk.Checkbutton(master, text='Populate new layout from netlist',
+ variable = self.l1prefs).grid(row = 2, columnspan = 2, sticky = 'enws')
+
+ return self
+
+ def apply(self):
+ return self.l1prefs.get
+
+#------------------------------------------------------
+# Simple dialog for entering project names
+#------------------------------------------------------
+
+class ProjectNameDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed=''):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ ttk.Label(master, text='Enter new project name:').grid(row = 1, column = 0, sticky = 'wns')
+ self.nentry = ttk.Entry(master)
+ self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
+ self.nentry.insert(0, seed)
+ return self.nentry # initial focus
+
+ def apply(self):
+ return self.nentry.get()
+
+class PadFrameCellNameDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed=''):
+ description='PadFrame' # TODO: make this an extra optional parameter of a generic CellNameDialog?
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ if description:
+ description = description + " "
+ else:
+ description = ""
+ ttk.Label(master, text=("Enter %scell name:" %(description))).grid(row = 1, column = 0, sticky = 'wns')
+ self.nentry = ttk.Entry(master)
+ self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
+ self.nentry.insert(0, seed)
+ return self.nentry # initial focus
+
+ def apply(self):
+ return self.nentry.get()
+
+#------------------------------------------------------
+# Dialog for copying projects. Includes checkbox
+# entries for preferences.
+#------------------------------------------------------
+
+class CopyProjectDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed=''):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ ttk.Label(master, text="Enter new project name:").grid(row = 1, column = 0, sticky = 'wns')
+ self.nentry = ttk.Entry(master)
+ self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
+ self.nentry.insert(0, seed)
+ self.elprefs = tkinter.IntVar(master)
+ self.elprefs.set(0)
+ ttk.Checkbutton(master, text='Copy electric preferences (not recommended)',
+ variable = self.elprefs).grid(row = 2, columnspan = 2, sticky = 'enws')
+ self.spprefs = tkinter.IntVar(master)
+ self.spprefs.set(0)
+ ttk.Checkbutton(master, text='Copy ngspice folder (not recommended)',
+ variable = self.spprefs).grid(row = 3, columnspan = 2, sticky = 'enws')
+ return self.nentry # initial focus
+
+ def apply(self):
+ # Return a list containing the entry text and the checkbox states.
+ elprefs = True if self.elprefs.get() == 1 else False
+ spprefs = True if self.spprefs.get() == 1 else False
+ return [self.nentry.get(), elprefs, spprefs]
+
+#-------------------------------------------------------
+# Not-Quite-So-Simple dialog for entering a new project.
+# Select a project name and a PDK from a drop-down list.
+#-------------------------------------------------------
+
+class NewProjectDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed='', importnode=None, development=False):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ ttk.Label(master, text="Enter new project name:").grid(row = 1, column = 0)
+ self.nentry = ttk.Entry(master)
+ self.nentry.grid(row = 1, column = 1, sticky = 'ewns')
+ self.nentry.insert(0, seed or '') # may be None
+ self.pvar = tkinter.StringVar(master)
+ if not importnode:
+ # Add PDKs as found by searching /ef/tech for 'libs.tech' directories
+ ttk.Label(master, text="Select foundry/node:").grid(row = 2, column = 0)
+ else:
+ ttk.Label(master, text="Foundry/node:").grid(row = 2, column = 0)
+ self.infolabel = ttk.Label(master, text="", style = 'brown.TLabel', wraplength=250)
+ self.infolabel.grid(row = 3, column = 0, columnspan = 2, sticky = 'news')
+ self.pdkmap = {}
+ self.pdkdesc = {}
+ self.pdkstat = {}
+ pdk_def = None
+
+ node_def = importnode
+ if not node_def:
+ node_def = "EFXH035B"
+
+ # use glob instead of os.walk. Don't need to recurse large PDK hier.
+ # TODO: stop hardwired default EFXH035B: get from an overall flow /ef/tech/.ef-config/plist.json
+ # (or get it from the currently selected project)
+ #EFABLESS PLATFORM
+ #TODO: Replace with PREFIX
+ for pdkdir_lr in glob.glob('/usr/share/pdk/*/libs.tech/'):
+ pdkdir = os.path.split( os.path.split( pdkdir_lr )[0])[0] # discard final .../libs.tech/
+ (foundry, node, desc, status) = OpenGalaxyManager.pdkdir2fnd( pdkdir )
+ if not foundry or not node:
+ continue
+ key = foundry + '/' + node
+ self.pdkmap[key] = pdkdir
+ self.pdkdesc[key] = desc
+ self.pdkstat[key] = status
+ if node == node_def and not pdk_def:
+ pdk_def = key
+
+ # Quick hack: sorting puts EFXH035A before EFXH035LEGACY. However, some
+ # ranking is needed.
+ pdklist = sorted( self.pdkmap.keys())
+ if not pdklist:
+ raise ValueError( "assertion failed, no available PDKs found")
+ pdk_def = (pdk_def or pdklist[0])
+
+ self.pvar.set(pdk_def)
+
+ # Restrict list to single entry if importnode was non-NULL and
+ # is in the PDK list (OptionMenu is replaced by a simple label)
+ # Otherwise, restrict the list to entries having an "status"
+ # entry equal to "active". This allows some legacy PDKs to be
+ # disabled for creating new projects (but available for projects
+ # that already have them).
+
+ if importnode:
+ self.pdkselect = ttk.Label(master, text = pdk_def, style='blue.TLabel')
+ else:
+ pdkactive = list(item for item in pdklist if self.pdkstat[item] == 'active')
+ if development:
+ pdkactive.extend(list(item for item in pdklist if self.pdkstat[item] == 'development'))
+
+ self.pdkselect = ttk.OptionMenu(master, self.pvar, pdk_def, *pdkactive,
+ style='blue.TMenubutton', command=self.show_info)
+ self.pdkselect.grid(row = 2, column = 1)
+ self.show_info(0)
+
+ return self.nentry # initial focus
+
+ def show_info(self, args):
+ key = str(self.pvar.get())
+ desc = self.pdkdesc[key]
+ if desc == '':
+ self.infolabel.config(text='(no description available)')
+ else:
+ self.infolabel.config(text=desc)
+
+ def apply(self):
+ return self.nentry.get(), self.pdkmap[ str(self.pvar.get()) ] # Note converts StringVar to string
+
+#----------------------------------------------------------------
+# Not-Quite-So-Simple dialog for selecting an existing project.
+# Select a project name from a drop-down list. This could be
+# replaced by simply using the selected (current) project.
+#----------------------------------------------------------------
+
+class ExistingProjectDialog(tksimpledialog.Dialog):
+ def body(self, master, plist, seed, warning='Enter name of existing project to import into:'):
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+
+ # Alphebetize list
+ plist.sort()
+ # Add projects
+ self.pvar = tkinter.StringVar(master)
+ self.pvar.set(plist[0])
+
+ ttk.Label(master, text='Select project:').grid(row = 1, column = 0)
+
+ self.projectselect = ttk.OptionMenu(master, self.pvar, plist[0], *plist, style='blue.TMenubutton')
+ self.projectselect.grid(row = 1, column = 1, sticky = 'ewns')
+ # pack version (below) hangs. Don't know why, changed to grid (like ProjectNameDialog)
+ # self.projectselect.pack(side = 'top', fill = 'both', expand = 'true')
+ return self.projectselect # initial focus
+
+ def apply(self):
+ return self.pvar.get() # Note converts StringVar to string
+
+#----------------------------------------------------------------
+# Not-Quite-So-Simple dialog for selecting an existing ElecLib of existing project.
+# Select an elecLib name from a drop-down list.
+#----------------------------------------------------------------
+
+class ExistingElecLibDialog(tksimpledialog.Dialog):
+ def body(self, master, plist, seed):
+ warning = "Enter name of existing Electric library to import into:"
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+
+ # Alphebetize list
+ plist.sort()
+ # Add electric libraries
+ self.pvar = tkinter.StringVar(master)
+ self.pvar.set(plist[0])
+
+ ttk.Label(master, text="Select library:").grid(row = 1, column = 0)
+
+ self.libselect = ttk.OptionMenu(master, self.pvar, plist[0], *plist, style='blue.TMenubutton')
+ self.libselect.grid(row = 1, column = 1)
+ return self.libselect # initial focus
+
+ def apply(self):
+ return self.pvar.get() # Note converts StringVar to string
+
+#----------------------------------------------------------------
+# Dialog for layout, in case of multiple layout names, none of
+# which matches the project name (ip-name). Method: Select a
+# layout name from a drop-down list. If there is no project.json
+# file, add a checkbox for creating one and seeding the ip-name
+# with the name of the selected layout. Include entry for
+# new layout, and for new layouts add a checkbox to import the
+# layout from schematic or verilog, if a valid candidate exists.
+#----------------------------------------------------------------
+
+class EditLayoutDialog(tksimpledialog.Dialog):
+ def body(self, master, plist, seed='', ppath='', pname='', warning='', hasnet=False):
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ self.ppath = ppath
+ self.pname = pname
+
+ # Checkbox variable
+ self.confirm = tkinter.IntVar(master)
+ self.confirm.set(0)
+
+ # To-Do: Add checkbox for netlist import
+
+ # Alphebetize list
+ plist.sort()
+ # Add additional item for new layout
+ plist.append('(New layout)')
+
+ # Add layouts to list
+ self.pvar = tkinter.StringVar(master)
+ self.pvar.set(plist[0])
+
+ ttk.Label(master, text='Selected layout to edit:').grid(row = 1, column = 0)
+
+ if pname in plist:
+ pseed = plist.index(pname)
+ else:
+ pseed = 0
+
+ self.layoutselect = ttk.OptionMenu(master, self.pvar, plist[pseed], *plist,
+ style='blue.TMenubutton', command=self.handle_choice)
+ self.layoutselect.grid(row = 1, column = 1, sticky = 'ewns')
+
+ # Create an entry form and checkbox for entering a new layout name, but
+ # keep them unpacked unless the "(New layout)" selection is chosen.
+
+ self.layoutbox = ttk.Frame(master)
+ self.layoutlabel = ttk.Label(self.layoutbox, text='New layout name:')
+ self.layoutlabel.grid(row = 0, column = 0, sticky = 'ewns')
+ self.layoutentry = ttk.Entry(self.layoutbox)
+ self.layoutentry.grid(row = 0, column = 1, sticky = 'ewns')
+ self.layoutentry.insert(0, pname)
+
+ # Only allow 'makeproject' checkbox if there is no project.json file
+ jname = ppath + '/project.json'
+ if not os.path.exists(jname):
+ dname = os.path.split(ppath)[1]
+ jname = ppath + '/' + dname + '.json'
+ if not os.path.exists(jname):
+ self.makeproject = ttk.Checkbutton(self.layoutbox,
+ text='Make default project name',
+ variable = self.confirm)
+ self.makeproject.grid(row = 2, column = 0, columnspan = 2, sticky = 'ewns')
+ return self.layoutselect # initial focus
+
+ def handle_choice(self, event):
+ if self.pvar.get() == '(New layout)':
+ # Add entry and checkbox for creating ad-hoc project.json file
+ self.layoutbox.grid(row = 1, column = 0, columnspan = 2, sticky = 'ewns')
+ else:
+ # Remove entry and checkbox
+ self.layoutbox.grid_forget()
+ return
+
+ def apply(self):
+ if self.pvar.get() == '(New layout)':
+ if self.confirm.get() == 1:
+ pname = self.pname
+ master.create_ad_hoc_json(self.layoutentry.get(), pname)
+ return self.layoutentry.get()
+ else:
+ return self.pvar.get() # Note converts StringVar to string
+
+#----------------------------------------------------------------
+# Dialog for padframe: select existing ElecLib of existing project, type in a cellName.
+# Select an elecLib name from a drop-down list.
+# Text field for entry of a cellName.
+#----------------------------------------------------------------
+
+class ExistingElecLibCellDialog(tksimpledialog.Dialog):
+ def body(self, master, descPre, seed='', descPost='', plist=None, seedLibNm=None, seedCellNm=''):
+ warning = 'Pick existing Electric library; enter cell name'
+ warning = (descPre or '') + ((descPre and ': ') or '') + warning + ((descPost and ' ') or '') + (descPost or '')
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+
+ # Alphebetize list
+ plist.sort()
+ # Add electric libraries
+ self.pvar = tkinter.StringVar(master)
+ pNdx = 0
+ if seedLibNm and seedLibNm in plist:
+ pNdx = plist.index(seedLibNm)
+ self.pvar.set(plist[pNdx])
+
+ ttk.Label(master, text='Electric library:').grid(row = 1, column = 0, sticky = 'ens')
+ self.libselect = ttk.OptionMenu(master, self.pvar, plist[pNdx], *plist, style='blue.TMenubutton')
+ self.libselect.grid(row = 1, column = 1, sticky = 'wns')
+
+ ttk.Label(master, text=('cell name:')).grid(row = 2, column = 0, sticky = 'ens')
+ self.nentry = ttk.Entry(master)
+ self.nentry.grid(row = 2, column = 1, sticky = 'ewns')
+ self.nentry.insert(0, seedCellNm)
+
+ return self.libselect # initial focus
+
+ def apply(self):
+ # return list of 2 strings: selected ElecLibName, typed-in cellName.
+ return [self.pvar.get(), self.nentry.get()] # Note converts StringVar to string
+
+#------------------------------------------------------
+# Simple dialog for confirming anything.
+#------------------------------------------------------
+
+class ConfirmDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ return self
+
+ def apply(self):
+ return 'okay'
+
+#------------------------------------------------------
+# More proactive dialog for confirming an invasive
+# procedure like "delete project". Requires user to
+# click a checkbox to ensure this is not a mistake.
+# confirmPrompt can be overridden, default='I am sure I want to do this.'
+#------------------------------------------------------
+
+class ProtectedConfirmDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed='', confirmPrompt=None):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ self.confirm = tkinter.IntVar(master)
+ self.confirm.set(0)
+ if not confirmPrompt:
+ confirmPrompt='I am sure I want to do this.'
+ ttk.Checkbutton(master, text=confirmPrompt,
+ variable = self.confirm).grid(row = 1, columnspan = 2, sticky = 'enws')
+ return self
+
+ def apply(self):
+ return 'okay' if self.confirm.get() == 1 else ''
+
+#------------------------------------------------------
+# Simple dialog to say "blah is not implemented yet."
+#------------------------------------------------------
+
+class NotImplementedDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed):
+ if not warning:
+ warning = "Sorry, that feature is not implemented yet"
+ if warning:
+ warning = "Sorry, " + warning + ", is not implemented yet"
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ return self
+
+ def apply(self):
+ return 'okay'
+
+#------------------------------------------------------
+# (This is actually a generic confirm dialogue, no install/overwrite intelligence)
+# But so far dedicated to confirming the installation of one or more files,
+# with notification of which (if any) will overwrite existing files.
+#
+# The warning parameter is fully constructed by caller, as multiple lines as either:
+# For the import of module 'blah',
+# CONFIRM installation of (*: OVERWRITE existing):
+# * path1
+# path2
+# ....
+# or:
+# For the import of module 'blah',
+# CONFIRM installation of:
+# path1
+# path2
+# ....
+# TODO: bastardizes warning parameter as multiple lines. Implement some other way?
+#------------------------------------------------------
+
+class ConfirmInstallDialog(tksimpledialog.Dialog):
+ def body(self, master, warning, seed):
+ if warning:
+ ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns')
+ return self
+
+ def apply(self):
+ return 'okay'
+
+#------------------------------------------------------
+# Open Galaxy Manager class
+#------------------------------------------------------
+
+class OpenGalaxyManager(ttk.Frame):
+ """Open Galaxy Project Management GUI."""
+
+ def __init__(self, parent, *args, **kwargs):
+ super().__init__(parent, *args, **kwargs)
+ self.root = parent
+ parent.withdraw()
+ # self.update()
+ self.update_idletasks() # erase small initial frame asap
+ self.init_gui()
+ parent.protocol("WM_DELETE_WINDOW", self.on_quit)
+ if splash:
+ splash.destroy()
+ parent.deiconify()
+
+ def on_quit(self):
+ """Exits program."""
+ quit()
+
+ def init_gui(self):
+ """Builds GUI."""
+ global designdir
+ global importdir
+ global archiveimportdir
+ global currdesign
+ global theProg
+ global deferLoad
+
+ message = []
+ allPaneOpen = False
+ prjPaneMinh = 10
+ iplPaneMinh = 4
+ impPaneMinh = 4
+
+ # if deferLoad: # temp. for testing... open all panes
+ # allPaneOpen = True
+
+ # Read user preferences
+ self.prefs = {}
+ self.read_prefs()
+
+ # Get default font size from user preferences
+ fontsize = self.prefs['fontsize']
+
+ s = ttk.Style()
+ available_themes = s.theme_names()
+ # print("themes: " + str(available_themes))
+ s.theme_use(available_themes[0])
+
+ s.configure('gray.TFrame', background='gray40')
+ s.configure('blue_white.TFrame', bordercolor = 'blue', borderwidth = 3)
+ s.configure('italic.TLabel', font=('Helvetica', fontsize, 'italic'))
+ s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'brown', anchor = 'center')
+ s.configure('title2.TLabel', font=('Helvetica', fontsize, 'bold italic'),
+ foreground = 'blue')
+ s.configure('normal.TLabel', font=('Helvetica', fontsize))
+ s.configure('red.TLabel', font=('Helvetica', fontsize), foreground = 'red')
+ s.configure('brown.TLabel', font=('Helvetica', fontsize), foreground = 'brown3', background = 'gray95')
+ s.configure('green.TLabel', font=('Helvetica', fontsize), foreground = 'green3')
+ s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue')
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ s.configure('red.TButton', font=('Helvetica', fontsize), foreground = 'red', border = 3,
+ relief = 'raised')
+ s.configure('green.TButton', font=('Helvetica', fontsize), foreground = 'green3', border = 3,
+ relief = 'raised')
+ s.configure('blue.TMenubutton', font=('Helvetica', fontsize), foreground = 'blue', border = 3,
+ relief = 'raised')
+
+ # Create the help window
+ self.help = HelpWindow(self, fontsize=fontsize)
+
+ with io.StringIO() as buf, contextlib.redirect_stdout(buf):
+ self.help.add_pages_from_file(og_config.apps_path + '/manager_help.txt')
+ message = buf.getvalue()
+
+
+ # Set the help display to the first page
+ self.help.page(0)
+
+ # Create the profile settings window
+ self.profile = Profile(self, fontsize=fontsize)
+
+ # Variables used by option menus
+ self.seltype = tkinter.StringVar(self)
+ self.cur_project = tkinter.StringVar(self)
+ self.cur_import = "(nothing selected)"
+ self.project_name = ""
+
+ # Root window title
+ self.root.title('Open Galaxy Project Manager')
+ self.root.option_add('*tearOff', 'FALSE')
+ self.pack(side = 'top', fill = 'both', expand = 'true')
+
+ 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)
+
+ # All interior windows size to toppane
+ self.toppane.columnconfigure(0, weight = 1)
+ # Projects window resizes preferably to others
+ self.toppane.rowconfigure(3, weight = 1)
+
+ # Get username, and from it determine the project directory.
+ # Save this path, because it gets used often.
+ username = self.prefs['username']
+ self.projectdir = os.path.expanduser('~/' + designdir)
+ self.cloudvdir = os.path.expanduser('~/' + cloudvdir)
+
+ # Check that the project directory exists, and create it if not
+ if not os.path.isdir(self.projectdir):
+ os.makedirs(self.projectdir)
+
+ # Label with the user
+ self.toppane.user_frame = ttk.Frame(self.toppane)
+ self.toppane.user_frame.grid(row = 0, sticky = 'news')
+
+ # Put logo image in corner. Ignore if something goes wrong, as this
+ # is only decorative. Note: ef_logo must be kept as a record in self,
+ # or else it gets garbage collected.
+ try:
+ #EFABLESS PLATFORM
+ self.ef_logo = tkinter.PhotoImage(file='/ef/efabless/opengalaxy/efabless_logo_small.gif')
+ self.toppane.user_frame.logo = ttk.Label(self.toppane.user_frame, image=self.ef_logo)
+ self.toppane.user_frame.logo.pack(side = 'left', padx = 5)
+ except:
+ pass
+
+ self.toppane.user_frame.title = ttk.Label(self.toppane.user_frame, text='User:', style='red.TLabel')
+ self.toppane.user_frame.user = ttk.Label(self.toppane.user_frame, text=username, style='blue.TLabel')
+
+ self.toppane.user_frame.title.pack(side = 'left', padx = 5)
+ self.toppane.user_frame.user.pack(side = 'left', padx = 5)
+
+ #---------------------------------------------
+ ttk.Separator(self.toppane, orient='horizontal').grid(row = 1, sticky = 'news')
+ #---------------------------------------------
+
+ # List of projects:
+ self.toppane.design_frame = ttk.Frame(self.toppane)
+ self.toppane.design_frame.grid(row = 2, sticky = 'news')
+
+ self.toppane.design_frame.design_header = ttk.Label(self.toppane.design_frame, text='Projects',
+ style='title.TLabel')
+ self.toppane.design_frame.design_header.pack(side = 'left', padx = 5)
+
+ self.toppane.design_frame.design_header2 = ttk.Label(self.toppane.design_frame,
+ text='(' + self.projectdir + '/)', style='normal.TLabel')
+ self.toppane.design_frame.design_header2.pack(side = 'left', padx = 5)
+
+ # Get current project from ~/.efmeta/currdesign and set the selection.
+ try:
+ with open(os.path.expanduser(currdesign), 'r') as f:
+ pnameCur = f.read().rstrip()
+ except:
+ pnameCur = None
+
+ # Create listbox of projects
+ projectlist = self.get_project_list() if not deferLoad else []
+ height = min(10, max(prjPaneMinh, 2 + len(projectlist)))
+ self.projectselect = TreeViewChoice(self.toppane, fontsize=fontsize, deferLoad=deferLoad, selectVal=pnameCur, natSort=True)
+ self.projectselect.populate("Available Projects:", projectlist,
+ [["Create", True, self.createproject],
+ ["Copy", False, self.copyproject],
+ ["Rename IP", False, self.renameproject],
+ ["<CloudV", True, self.cloudvimport],
+ ["Clean", False, self.cleanproject],
+ ["Delete", False, self.deleteproject]],
+ height=height, columns=[0, 1])
+ self.projectselect.grid(row = 3, sticky = 'news')
+ self.projectselect.bindselect(self.setcurrent)
+
+ tooltip.ToolTip(self.projectselect.get_button(0), text="Create a new project")
+ tooltip.ToolTip(self.projectselect.get_button(1), text="Make a copy of an entire project")
+ tooltip.ToolTip(self.projectselect.get_button(2), text="Rename a project folder")
+ tooltip.ToolTip(self.projectselect.get_button(3), text="Import CloudV project as new project")
+ tooltip.ToolTip(self.projectselect.get_button(4), text="Clean simulation data from project")
+ tooltip.ToolTip(self.projectselect.get_button(5), text="Delete an entire project")
+
+ pdklist = self.get_pdk_list(projectlist)
+ self.projectselect.populate2("PDK", projectlist, pdklist)
+
+ if pnameCur:
+ try:
+ curitem = next(item for item in projectlist if pnameCur == os.path.split(item)[1])
+ except StopIteration:
+ pass
+ else:
+ if curitem:
+ self.projectselect.setselect(pnameCur)
+
+ # Check that the import directory exists, and create it if not
+ if not os.path.isdir(self.projectdir + '/' + importdir):
+ os.makedirs(self.projectdir + '/' + importdir)
+
+ # Create a watchdog on the project and import directories
+ watchlist = [self.projectdir, self.projectdir + '/' + importdir]
+ if os.path.isdir(self.projectdir + '/upload'):
+ watchlist.append(self.projectdir + '/upload')
+
+ # Check the creation time of the project manager app itself. Because the project
+ # manager tends to be left running indefinitely, it is important to know when it
+ # has been updated. This is checked once every hour since it is really expected
+ # only to happen occasionally.
+
+ thisapp = [theProg]
+ self.watchself = WatchClock(self, thisapp, self.update_alert, 3600000)
+
+ #---------------------------------------------
+
+ # Add second button bar for major project applications
+ self.toppane.apptitle = ttk.Label(self.toppane, text='Tools:', style='title2.TLabel')
+ self.toppane.apptitle.grid(row = 4, sticky = 'news')
+ self.toppane.appbar = ttk.Frame(self.toppane)
+ self.toppane.appbar.grid(row = 5, sticky = 'news')
+
+ # Define the application buttons and actions
+ self.toppane.appbar.schem_button = ttk.Button(self.toppane.appbar, text='Edit Schematic',
+ command=self.edit_schematic, style = 'normal.TButton')
+ self.toppane.appbar.schem_button.pack(side = 'left', padx = 5)
+ self.toppane.appbar.layout_button = ttk.Button(self.toppane.appbar, text='Edit Layout',
+ command=self.edit_layout, style = 'normal.TButton')
+ self.toppane.appbar.layout_button.pack(side = 'left', padx = 5)
+ self.toppane.appbar.lvs_button = ttk.Button(self.toppane.appbar, text='Run LVS',
+ command=self.run_lvs, style = 'normal.TButton')
+ self.toppane.appbar.lvs_button.pack(side = 'left', padx = 5)
+ self.toppane.appbar.char_button = ttk.Button(self.toppane.appbar, text='Characterize',
+ command=self.characterize, style = 'normal.TButton')
+ self.toppane.appbar.char_button.pack(side = 'left', padx = 5)
+ self.toppane.appbar.synth_button = ttk.Button(self.toppane.appbar, text='Synthesis Flow',
+ command=self.synthesize, style = 'normal.TButton')
+ self.toppane.appbar.synth_button.pack(side = 'left', padx = 5)
+
+ self.toppane.appbar.padframeCalc_button = ttk.Button(self.toppane.appbar, text='Pad Frame',
+ command=self.padframe_calc, style = 'normal.TButton')
+ self.toppane.appbar.padframeCalc_button.pack(side = 'left', padx = 5)
+ '''
+ if self.prefs['schemeditor'] == 'xcircuit':
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'XCircuit' schematic editor")
+ elif self.prefs['schemeditor'] == 'xschem':
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'XSchem' schematic editor")
+ else:
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'Electric' schematic editor")
+
+ if self.prefs['layouteditor'] == 'klayout':
+ tooltip.ToolTip(self.toppane.appbar.layout_button, text="Start 'KLayout' layout editor")
+ else:
+ tooltip.ToolTip(self.toppane.appbar.layout_button, text="Start 'Magic' layout editor")
+ '''
+ self.refreshToolTips()
+
+ tooltip.ToolTip(self.toppane.appbar.lvs_button, text="Start LVS tool")
+ tooltip.ToolTip(self.toppane.appbar.char_button, text="Start Characterization tool")
+ tooltip.ToolTip(self.toppane.appbar.synth_button, text="Start Digital Synthesis tool")
+ tooltip.ToolTip(self.toppane.appbar.padframeCalc_button, text="Start Pad Frame Generator")
+
+ #---------------------------------------------
+ ttk.Separator(self.toppane, orient='horizontal').grid(row = 6, sticky = 'news')
+ #---------------------------------------------
+ # List of IP libraries:
+ self.toppane.library_frame = ttk.Frame(self.toppane)
+ self.toppane.library_frame.grid(row = 7, sticky = 'news')
+
+ self.toppane.library_frame.library_header = ttk.Label(self.toppane.library_frame, text='IP Library:',
+ style='title.TLabel')
+ self.toppane.library_frame.library_header.pack(side = 'left', padx = 5)
+
+ self.toppane.library_frame.library_header2 = ttk.Label(self.toppane.library_frame,
+ text='(' + self.projectdir + '/ip/)', style='normal.TLabel')
+ self.toppane.library_frame.library_header2.pack(side = 'left', padx = 5)
+
+ self.toppane.library_frame.library_header3 = ttk.Button(self.toppane.library_frame,
+ text=(allPaneOpen and '-' or '+'), command=self.library_toggle, style = 'normal.TButton', width = 2)
+ self.toppane.library_frame.library_header3.pack(side = 'right', padx = 5)
+
+ # Create listbox of IP libraries
+ iplist = self.get_library_list() if not deferLoad else []
+ height = min(8, max(iplPaneMinh, 2 + len(iplist)))
+ self.ipselect = TreeViewChoice(self.toppane, fontsize=fontsize, deferLoad=deferLoad, natSort=True)
+ self.ipselect.populate("IP Library:", iplist,
+ [], height=height, columns=[0, 1], versioning=True)
+ valuelist = self.ipselect.getvaluelist()
+ datelist = self.get_date_list(valuelist)
+ itemlist = self.ipselect.getlist()
+ self.ipselect.populate2("date", itemlist, datelist)
+ if allPaneOpen:
+ self.library_open()
+
+ #---------------------------------------------
+ ttk.Separator(self.toppane, orient='horizontal').grid(row = 9, sticky = 'news')
+ #---------------------------------------------
+ # List of imports:
+ self.toppane.import_frame = ttk.Frame(self.toppane)
+ self.toppane.import_frame.grid(row = 10, sticky = 'news')
+
+ self.toppane.import_frame.import_header = ttk.Label(self.toppane.import_frame, text='Imports:',
+ style='title.TLabel')
+ self.toppane.import_frame.import_header.pack(side = 'left', padx = 5)
+
+ self.toppane.import_frame.import_header2 = ttk.Label(self.toppane.import_frame,
+ text='(' + self.projectdir + '/import/)', style='normal.TLabel')
+ self.toppane.import_frame.import_header2.pack(side = 'left', padx = 5)
+
+ self.toppane.import_frame.import_header3 = ttk.Button(self.toppane.import_frame,
+ text=(allPaneOpen and '-' or '+'), command=self.import_toggle, style = 'normal.TButton', width = 2)
+ self.toppane.import_frame.import_header3.pack(side = 'right', padx = 5)
+
+ # Create listbox of imports
+ importlist = self.get_import_list() if not deferLoad else []
+ self.number_of_imports = len(importlist) if not deferLoad else None
+ height = min(8, max(impPaneMinh, 2 + len(importlist)))
+ self.importselect = TreeViewChoice(self.toppane, fontsize=fontsize, markDir=True, deferLoad=deferLoad)
+ self.importselect.populate("Pending Imports:", importlist,
+ [["Import As", False, self.importdesign],
+ ["Import Into", False, self.importintodesign],
+ ["Delete", False, self.deleteimport]], height=height, columns=[0, 1])
+ valuelist = self.importselect.getvaluelist()
+ datelist = self.get_date_list(valuelist)
+ itemlist = self.importselect.getlist()
+ self.importselect.populate2("date", itemlist, datelist)
+
+ tooltip.ToolTip(self.importselect.get_button(0), text="Import as a new project")
+ tooltip.ToolTip(self.importselect.get_button(1), text="Import into an existing project")
+ tooltip.ToolTip(self.importselect.get_button(2), text="Remove the import file(s)")
+ if allPaneOpen:
+ self.import_open()
+
+ #---------------------------------------------
+ # ttk.Separator(self, orient='horizontal').grid(column = 0, row = 8, columnspan=4, sticky='ew')
+ #---------------------------------------------
+
+ # Add a text window below the import to capture output. Redirect
+ # print statements to it.
+ self.botpane.console = ttk.Frame(self.botpane)
+ self.botpane.console.pack(side = 'top', fill = 'both', expand = 'true')
+
+ self.text_box = ConsoleText(self.botpane.console, wrap='word', height = 4)
+ self.text_box.pack(side='left', fill='both', expand = 'true')
+ console_scrollbar = ttk.Scrollbar(self.botpane.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)
+
+ # Give all the expansion weight to the message window.
+ # self.rowconfigure(9, weight = 1)
+ # self.columnconfigure(0, weight = 1)
+
+ # at bottom (legacy mode): window height grows by one row.
+ # at top the buttons share a row with user name, reduce window height, save screen real estate.
+ bottomButtons = False
+
+ # Add button bar: at the bottom of window (legacy mode), or share top row with user-name
+ if bottomButtons:
+ bbar = ttk.Frame(self.botpane)
+ bbar.pack(side='top', fill = 'x')
+ else:
+ bbar = self.toppane.user_frame
+
+ # Define help button
+ bbar.help_button = ttk.Button(bbar, text='Help',
+ command=self.help.open, style = 'normal.TButton')
+
+ # Define profile settings button
+ bbar.profile_button = ttk.Button(bbar, text='Settings',
+ command=self.profile.open, style = 'normal.TButton')
+
+ # Define the "quit" button and action
+ bbar.quit_button = ttk.Button(bbar, text='Quit', command=self.on_quit,
+ style = 'normal.TButton')
+ # Tool tips for button bar
+ tooltip.ToolTip(bbar.quit_button, text="Exit the project manager")
+ tooltip.ToolTip(bbar.help_button, text="Show help window")
+
+ if bottomButtons:
+ bbar.help_button.pack(side = 'left', padx = 5)
+ bbar.profile_button.pack(side = 'left', padx = 5)
+ bbar.quit_button.pack(side = 'right', padx = 5)
+ else:
+ # quit at TR like window-title's close; help towards the outside, settings towards inside
+ bbar.quit_button.pack(side = 'right', padx = 5)
+ bbar.help_button.pack(side = 'right', padx = 5)
+ bbar.profile_button.pack(side = 'right', padx = 5)
+
+ # Add the panes once the internal geometry is known
+ pane.add(self.toppane)
+ pane.add(self.botpane)
+ pane.paneconfig(self.toppane, stretch='first')
+ # self.update_idletasks()
+
+ #---------------------------------------------------------------
+ # Project list
+ # projects = os.listdir(os.path.expanduser('~/' + designdir))
+ # self.cur_project.set(projects[0])
+ # self.design_select = ttk.OptionMenu(self, self.cur_project, projects[0], *projects,
+ # style='blue.TMenubutton')
+
+ # New import list
+ # self.import_select = ttk.Button(self, text=self.cur_import, command=self.choose_import)
+
+ #---------------------------------------------------------
+ # Define project design actions
+ # self.design_actions = ttk.Frame(self)
+ # self.design_actions.characterize = ttk.Button(self.design_actions,
+ # text='Upload and Characterize', command=self.characterize)
+ # self.design_actions.characterize.grid(column = 0, row = 0)
+
+ # Define import actions
+ # self.import_actions = ttk.Frame(self)
+ # self.import_actions.upload = ttk.Button(self.import_actions,
+ # text='Upload Challenge', command=self.make_challenge)
+ # self.import_actions.upload.grid(column = 0, row = 0)
+
+ self.watchclock = WatchClock(self, watchlist, self.update_project_views, 2000,
+ 0 if deferLoad else None) # do immediate forced refresh (1st in mainloop)
+ # self.watchclock = WatchClock(self, watchlist, self.update_project_views, 2000)
+
+ # 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
+ sys.stdout = ConsoleText.StdoutRedirector(self.text_box)
+ sys.stderr = ConsoleText.StderrRedirector(self.text_box)
+
+ if message:
+ print(message)
+
+ if self.prefs == {}:
+ print("No user preferences file, using default settings.")
+
+ # helper for Profile to do live mods of some of the user-prefs (without restart projectManager):
+ def setUsername(self, newname):
+ self.toppane.user_frame.user.config(text=newname)
+
+ def refreshToolTips(self):
+ if self.prefs['schemeditor'] == 'xcircuit':
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'XCircuit' schematic editor")
+ elif self.prefs['schemeditor'] == 'xschem':
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'XSchem' schematic editor")
+ else:
+ tooltip.ToolTip(self.toppane.appbar.schem_button, text="Start 'Electric' schematic editor")
+
+ if self.prefs['layouteditor'] == 'klayout':
+ tooltip.ToolTip(self.toppane.appbar.layout_button, text="Start 'KLayout' layout editor")
+ else:
+ tooltip.ToolTip(self.toppane.appbar.layout_button, text="Start 'Magic' layout editor")
+
+ def config_path(self, path):
+ #returns the directory that path contains between .config and .ef-config
+ if (os.path.exists(path + '/.config')):
+ return '/.config'
+ elif (os.path.exists(path + '/.ef-config')):
+ return '/.ef-config'
+ raise FileNotFoundError('Neither '+path+'/.config nor '+path+'/.ef-config exists.')
+
+ #------------------------------------------------------------------------
+ # Check if a name is blacklisted for being a project folder
+ #------------------------------------------------------------------------
+
+ def blacklisted(self, dirname):
+ # Blacklist: Do not show files of these names:
+ blacklist = [importdir, 'ip', 'upload', 'export', 'lost+found']
+ if dirname in blacklist:
+ return True
+ else:
+ return False
+
+ def write_prefs(self):
+ global prefsfile
+
+ if self.prefs:
+ expprefsfile = os.path.expanduser(prefsfile)
+ prefspath = os.path.split(expprefsfile)[0]
+ if not os.path.exists(prefspath):
+ os.makedirs(prefspath)
+ with open(os.path.expanduser(prefsfile), 'w') as f:
+ json.dump(self.prefs, f, indent = 4)
+
+ def read_prefs(self):
+ global prefsfile
+
+ # Set all known defaults even if they are not in the JSON file so
+ # that it is not necessary to check for the existence of the keyword
+ # in the dictionary every time it is accessed.
+ if 'fontsize' not in self.prefs:
+ self.prefs['fontsize'] = 11
+ userid = os.environ['USER']
+ uid = ''
+ username = userid
+ self.prefs['username'] = username
+
+ '''
+ if 'username' not in self.prefs:
+
+ #
+ #EFABLESS PLATFORM
+ p = subprocess.run(['/ef/apps/bin/withnet' ,
+ og_config.apps_path + '/og_uid_service.py', userid],
+ stdout = subprocess.PIPE)
+ if p.stdout:
+ uid_string = p.stdout.splitlines()[0].decode('utf-8')
+ userspec = re.findall(r'[^"\s]\S*|".+?"', uid_string)
+ if len(userspec) > 0:
+ username = userspec[0].strip('"')
+ # uid = userspec[1]
+ # Note userspec[1] = UID and userspec[2] = role, useful
+ # for future applications.
+ else:
+ username = userid
+ else:
+ username = userid
+ self.prefs['username'] = username
+ # self.prefs['uid'] = uid
+ '''
+ if 'schemeditor' not in self.prefs:
+ self.prefs['schemeditor'] = 'electric'
+
+ if 'layouteditor' not in self.prefs:
+ self.prefs['layouteditor'] = 'magic'
+
+ if 'magic-graphics' not in self.prefs:
+ self.prefs['magic-graphics'] = 'X11'
+
+ if 'development' not in self.prefs:
+ self.prefs['development'] = False
+
+ if 'devstdcells' not in self.prefs:
+ self.prefs['devstdcells'] = False
+
+ # Any additional user preferences go above this line.
+
+ # Get user preferences from ~/design/.profile/prefs.json and use it to
+ # overwrite default entries in self.prefs
+ try:
+ with open(os.path.expanduser(prefsfile), 'r') as f:
+ prefsdict = json.load(f)
+ for key in prefsdict:
+ self.prefs[key] = prefsdict[key]
+ except:
+ # No preferences file, so create an initial one.
+ if not os.path.exists(prefsfile):
+ self.write_prefs()
+
+ # if 'User:' Label exists, this updates it live (Profile calls read_prefs after write)
+ try:
+ self.setUsername(self.prefs['username'])
+ except:
+ pass
+
+ #------------------------------------------------------------------------
+ # Get a list of the projects in the user's design directory. Exclude
+ # items that are not directories, or which are blacklisted.
+ #------------------------------------------------------------------------
+
+ def get_project_list(self):
+ global importdir
+
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[ \t\n].*")
+
+ # Get contents of directory. Look only at directories
+ projectlist = list(item for item in os.listdir(self.projectdir) if
+ os.path.isdir(self.projectdir + '/' + item))
+
+ # 'import' and others in the blacklist are not projects!
+ # Files beginning with '.' and files with whitespace are
+ # also not listed.
+ for item in projectlist[:]:
+ if self.blacklisted(item):
+ projectlist.remove(item)
+ elif badrex1.match(item):
+ projectlist.remove(item)
+ elif badrex2.match(item):
+ projectlist.remove(item)
+
+ # Add pathname to all items in projectlist
+ projectlist = [self.projectdir + '/' + item for item in projectlist]
+ return projectlist
+
+ #------------------------------------------------------------------------
+ # Get a list of the projects in the user's cloudv directory. Exclude
+ # items that are not directories, or which are blacklisted.
+ #------------------------------------------------------------------------
+
+ def get_cloudv_project_list(self):
+ global importdir
+
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[ \t\n].*")
+
+ if not os.path.exists(self.cloudvdir):
+ print('No user cloudv dir exists; no projects to import.')
+ return None
+
+ # Get contents of cloudv directory. Look only at directories
+ projectlist = list(item for item in os.listdir(self.cloudvdir) if
+ os.path.isdir(self.cloudvdir + '/' + item))
+
+ # 'import' and others in the blacklist are not projects!
+ # Files beginning with '.' and files with whitespace are
+ # also not listed.
+ for item in projectlist[:]:
+ if self.blacklisted(item):
+ projectlist.remove(item)
+ elif badrex1.match(item):
+ projectlist.remove(item)
+ elif badrex2.match(item):
+ projectlist.remove(item)
+
+ # Add pathname to all items in projectlist
+ projectlist = [self.cloudvdir + '/' + item for item in projectlist]
+ return projectlist
+
+ #------------------------------------------------------------------------
+ # utility: [re]intialize a project's elec/ dir: the .java preferences and LIBDIRS.
+ # So user can just delete .java, and restart electric (from projectManager), to reinit preferences.
+ # So user can just delete LIBDIRS, and restart electric (from projectManager), to reinit LIBDIRS.
+ # So project copies/imports can filter ngspice/run (and ../.allwaves), we'll recreate it here.
+ #
+ # The global /ef/efabless/deskel/* is used and the PDK name substituted.
+ #
+ # This SINGLE function is used to setup elec/ contents for new projects, in addition to being
+ # called in-line prior to "Edit Schematics" (on-the-fly).
+ #------------------------------------------------------------------------
+ @classmethod
+ def reinitElec(cls, design):
+ pdkdir = os.path.join( design, ".ef-config/techdir")
+ elec = os.path.join( design, "elec")
+
+ # on the fly, ensure has elec/ dir, ensure has ngspice/run/allwaves dir
+ try:
+ os.makedirs(design + '/elec', exist_ok=True)
+ except IOError as e:
+ print('Error in os.makedirs(elec): ' + str(e))
+ try:
+ os.makedirs(design + '/ngspice/run/.allwaves', exist_ok=True)
+ except IOError as e:
+ print('Error in os.makedirs(.../.allwaves): ' + str(e))
+ #EFABLESS PLATFORM
+ deskel = '/ef/efabless/deskel'
+
+ # on the fly:
+ # .../elec/.java : reinstall if missing. From PDK-specific if any.
+ if not os.path.exists( os.path.join( elec, '.java')):
+ # Copy Electric preferences
+ try:
+ shutil.copytree(deskel + '/dotjava', design + '/elec/.java', symlinks = True)
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+
+ # .../elec/LIBDIRS : reinstall if missing, from PDK-specific LIBDIRS
+ # in libs.tech/elec/LIBDIRS
+
+ libdirsloc = pdkdir + '/libs.tech/elec/LIBDIRS'
+
+ if not os.path.exists( os.path.join( elec, 'LIBDIRS')):
+ if os.path.exists( libdirsloc ):
+ # Copy Electric LIBDIRS
+ try:
+ shutil.copy(libdirsloc, design + '/elec/LIBDIRS')
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ else:
+ print('Info: PDK not configured for Electric: no libs.tech/elec/LIBDIRS')
+
+ return None
+
+ #------------------------------------------------------------------------
+ # utility: filter a list removing: empty strings, strings with any whitespace
+ #------------------------------------------------------------------------
+ whitespaceREX = re.compile('\s')
+ @classmethod
+ def filterNullOrWS(cls, inlist):
+ return [ i for i in inlist if i and not cls.whitespaceREX.search(i) ]
+
+ #------------------------------------------------------------------------
+ # utility: do a glob.glob of relative pattern, but specify the rootDir,
+ # so returns the matching paths found below that rootDir.
+ #------------------------------------------------------------------------
+ @classmethod
+ def globFromDir(cls, pattern, dir=None):
+ if dir:
+ dir = dir.rstrip('/') + '/'
+ pattern = dir + pattern
+ result = glob.glob(pattern)
+ if dir and result:
+ nbr = len(dir)
+ result = [ i[nbr:] for i in result ]
+ return result
+
+ #------------------------------------------------------------------------
+ # utility: from a pdkPath, return list of 3 strings: <foundry>, <node>, <description>.
+ # i.e. pdkPath has form '[.../]<foundry>[.<ext>]/<node>'. For now the description
+ # is always ''. And an optional foundry extension is pruned/dropped.
+ # thus '.../XFAB.2/EFXP018A4' -> 'XFAB', 'EFXP018A4', ''
+ #
+ # optionally store in each PDK: .ef-config/nodeinfo.json which can define keys:
+ # 'foundry', 'node', 'description' to override the foundry (computed from the path)
+ # and (fixed, empty) description currently returned by this.
+ #
+ # Intent: keep a short-description field at least, intended to be one-line max 40 chars,
+ # suitable for a on-hover-tooltip display. (Distinct from a big multiline description).
+ #
+ # On error (malformed pdkPath: can't determine foundry or node), the foundry or node
+ # or both may be '' or as specified in the optional default values (if you're
+ # generating something for display and want an unknown to appear as 'none' etc.).
+ #------------------------------------------------------------------------
+ @classmethod
+ def pdkdir2fnd(cls, pdkdir, def_foundry='', def_node='', def_description=''):
+ foundry = ''
+ node = ''
+ description = ''
+ status = 'active'
+ if pdkdir:
+ split = os.path.split(os.path.realpath(pdkdir))
+ # Full path should be [<something>/]<foundry>[.ext]/<node>
+ node = split[1]
+ foundry = os.path.split(split[0])[1]
+ foundry = os.path.splitext(foundry)[0]
+ # Check for nodeinfo.json
+ infofile = pdkdir + '/.config/nodeinfo.json'
+ if os.path.exists(infofile):
+ with open(infofile, 'r') as ifile:
+ nodeinfo = json.load(ifile)
+ if 'foundry' in nodeinfo:
+ foundry = nodeinfo['foundry']
+ if 'node' in nodeinfo:
+ node = nodeinfo['node']
+ if 'description' in nodeinfo:
+ description = nodeinfo['description']
+ if 'status' in nodeinfo:
+ status = nodeinfo['status']
+ return foundry, node, description, status
+
+ infofile = pdkdir + '/.ef-config/nodeinfo.json'
+ if os.path.exists(infofile):
+ with open(infofile, 'r') as ifile:
+ nodeinfo = json.load(ifile)
+ if 'foundry' in nodeinfo:
+ foundry = nodeinfo['foundry']
+ if 'node' in nodeinfo:
+ node = nodeinfo['node']
+ if 'description' in nodeinfo:
+ description = nodeinfo['description']
+ if 'status' in nodeinfo:
+ status = nodeinfo['status']
+
+
+ return foundry, node, description, status
+
+ #------------------------------------------------------------------------
+ # Get a list of the electric-libraries (DELIB only) in a given project.
+ # List of full-paths each ending in '.delib'
+ #------------------------------------------------------------------------
+
+ def get_elecLib_list(self, pname):
+ elibs = self.globFromDir(pname + '/elec/*.delib/', self.projectdir)
+ elibs = [ re.sub("/$", "", i) for i in elibs ]
+ return self.filterNullOrWS(elibs)
+
+ #------------------------------------------------------------------------
+ # Create a list of datestamps for each import file
+ #------------------------------------------------------------------------
+ def get_date_list(self, valuelist):
+ datelist = []
+ for value in valuelist:
+ try:
+ importfile = value[0]
+ try:
+ statbuf = os.stat(importfile)
+ except:
+ # Note entries that can't be accessed.
+ datelist.append("(unknown)")
+ else:
+ datestamp = datetime.datetime.fromtimestamp(statbuf.st_mtime)
+ datestr = datestamp.strftime("%c")
+ datelist.append(datestr)
+ except:
+ datelist.append("(N/A)")
+
+ return datelist
+
+ #------------------------------------------------------------------------
+ # Get the PDK attached to a project for display as: '<foundry> : <node>'
+ # unless path=True: then return true PDK dir-path.
+ #
+ # TODO: the ef-config prog output is not used below. Intent was use
+ # ef-config to be the one official query for *any* project's PDK value, and
+ # therein-only hide a built-in default for legacy projects without techdir symlink.
+ # In below ef-config will always give an EF_TECHDIR, so that code-branch always
+ # says '(default)', the ef-config subproc is wasted, and '(no PDK)' is never
+ # reached.
+ #------------------------------------------------------------------------
+ def get_pdk_dir(self, project, path=False):
+ pdkdir = os.path.realpath(project + self.config_path(project)+'/techdir')
+ if path:
+ return pdkdir
+ foundry, node, desc, status = self.pdkdir2fnd( pdkdir )
+ return foundry + ' : ' + node
+ '''
+ if os.path.isdir(project + '/.ef-config'):
+ if os.path.exists(project + '/.ef-config/techdir'):
+ pdkdir = os.path.realpath(project + '/.ef-config/techdir')
+
+ elif os.path.isdir(project + '/.config'):
+ if os.path.exists(project + '/.config/techdir'):
+ pdkdir = os.path.realpath(project + '/.config/techdir')
+ if path:
+ return pdkdir
+ foundry, node, desc, status = self.pdkdir2fnd( pdkdir )
+ return foundry + ' : ' + node
+ '''
+ '''
+ if not pdkdir:
+ # Run "ef-config" script for backward compatibility
+ export = {'EF_DESIGNDIR': project}
+ #EFABLESS PLATFORM
+ p = subprocess.run(['/ef/efabless/bin/ef-config', '-sh', '-t'],
+ stdout = subprocess.PIPE, env = export)
+ config_out = p.stdout.splitlines()
+ for line in config_out:
+ setline = line.decode('utf-8').split('=')
+ if setline[0] == 'EF_TECHDIR':
+ pdkdir = ( setline[1] if path else '(default)' )
+ if not pdkdir:
+ pdkdir = ( None if path else '(no PDK)' ) # shouldn't get here
+ '''
+
+
+
+ return pdkdir
+
+ #------------------------------------------------------------------------
+ # Get the list of PDKs that are attached to each project
+ #------------------------------------------------------------------------
+ def get_pdk_list(self, projectlist):
+ pdklist = []
+ for project in projectlist:
+ pdkdir = self.get_pdk_dir(project)
+ pdklist.append(pdkdir)
+
+ return pdklist
+
+ #------------------------------------------------------------------------
+ # Find a .json's associated tar.gz (or .tgz) if any.
+ # Return path to the tar.gz if any, else None.
+ #------------------------------------------------------------------------
+
+ def json2targz(self, jsonPath):
+ root = os.path.splitext(jsonPath)[0]
+ for ext in ('.tgz', '.tar.gz'):
+ if os.path.isfile(root + ext):
+ return root + ext
+ return None
+
+ #------------------------------------------------------------------------
+ # Remove a .json and associated tar.gz (or .tgz) if any.
+ # If not a .json, remove just that file (no test for a tar).
+ #------------------------------------------------------------------------
+
+ def removeJsonPlus(self, jsonPath):
+ ext = os.path.splitext(jsonPath)[1]
+ if ext == ".json":
+ tar = self.json2targz(jsonPath)
+ if tar: os.remove(tar)
+ return os.remove(jsonPath)
+
+ #------------------------------------------------------------------------
+ # MOVE a .json and associated tar.gz (or .tgz) if any, to targetDir.
+ # If not a .json, move just that file (no test for a tar).
+ #------------------------------------------------------------------------
+
+ def moveJsonPlus(self, jsonPath, targetDir):
+ ext = os.path.splitext(jsonPath)[1]
+ if ext == ".json":
+ tar = self.json2targz(jsonPath)
+ if tar:
+ shutil.move(tar, targetDir)
+ # believe the move throws an error. So return value (the targetDir name) isn't really useful.
+ return shutil.move(jsonPath, targetDir)
+
+ #------------------------------------------------------------------------
+ # Get a list of the libraries in the user's ip folder
+ #------------------------------------------------------------------------
+
+ def get_library_list(self):
+ # Get contents of directory
+ try:
+ iplist = glob.glob(self.projectdir + '/ip/*/*')
+ except:
+ iplist = []
+ else:
+ pass
+
+ return iplist
+
+ #------------------------------------------------------------------------
+ # Get a list of the files in the user's design import folder
+ # (use current 'import' but also original 'upload')
+ #------------------------------------------------------------------------
+
+ def get_import_list(self):
+ # Get contents of directory
+ importlist = os.listdir(self.projectdir + '/' + importdir)
+
+ # If entries have both a .json and .tar.gz file, remove the .tar.gz (also .tgz).
+ # Also ignore any .swp files dropped by the vim editor.
+ # Also ignore any subdirectories of import
+ for item in importlist[:]:
+ if item[-1] in '#~':
+ importlist.remove(item)
+ continue
+ ipath = self.projectdir + '/' + importdir + '/' + item
+
+ # recognize dirs (as u2u projects) if not symlink and has a 'project.json',
+ # hide dirs named *.bak. If originating user does u2u twice before target user
+ # can consume/import it, the previous one (only) is retained as *.bak.
+ if os.path.isdir(ipath):
+ if os.path.islink(ipath) or not self.validProjectName(item) \
+ or self.importProjNameBadrex1.match(item) \
+ or not os.path.isfile(ipath + '/project.json'):
+ importlist.remove(item)
+ continue
+ else:
+ ext = os.path.splitext(item)
+ if ext[1] == '.json':
+ if ext[0] + '.tar.gz' in importlist:
+ importlist.remove(ext[0] + '.tar.gz')
+ elif ext[0] + '.tgz' in importlist:
+ importlist.remove(ext[0] + '.tgz')
+ elif ext[1] == '.swp':
+ importlist.remove(item)
+ elif os.path.isdir(self.projectdir + '/' + importdir + '/' + item):
+ importlist.remove(item)
+
+ # Add pathname to all items in projectlist
+ importlist = [self.projectdir + '/' + importdir + '/' + item for item in importlist]
+
+ # Add support for original "upload" directory (backward compatibility)
+ if os.path.exists(self.projectdir + '/upload'):
+ uploadlist = os.listdir(self.projectdir + '/upload')
+
+ # If entries have both a .json and .tar.gz file, remove the .tar.gz (also .tgz).
+ # Also ignore any .swp files dropped by the vim editor.
+ for item in uploadlist[:]:
+ ext = os.path.splitext(item)
+ if ext[1] == '.json':
+ if ext[0] + '.tar.gz' in uploadlist:
+ uploadlist.remove(ext[0] + '.tar.gz')
+ elif ext[0] + '.tgz' in uploadlist:
+ uploadlist.remove(ext[0] + '.tgz')
+ elif ext[1] == '.swp':
+ uploadlist.remove(item)
+
+ # Add pathname to all items in projectlist
+ uploadlist = [self.projectdir + '/upload/' + item for item in uploadlist]
+ importlist.extend(uploadlist)
+
+ # Remember the size of the list so we know when it changed
+ self.number_of_imports = len(importlist)
+ return importlist
+
+ #------------------------------------------------------------------------
+ # Import for json documents and related tarballs (.gz or .tgz):
+ #------------------------------------------------------------------------
+
+ def importjson(self, projname, importfile):
+ # (1) Check if there is a tarball with the same root name as the JSON
+ importroot = os.path.splitext(importfile)[0]
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[/ \t\n\\\><\*\?].*")
+ if os.path.isfile(importroot + '.tgz'):
+ tarname = importroot + '.tgz'
+ elif os.path.isfile(importroot + '.tar.gz'):
+ tarname = importroot + '.tar.gz'
+ else:
+ tarname = []
+ # (2) Check for name conflict
+ origname = projname
+ newproject = self.projectdir + '/' + projname
+ newname = projname
+ while os.path.isdir(newproject) or self.blacklisted(newname):
+ if self.blacklisted(newname):
+ warning = "Name " + newname + " is not allowed for a project name."
+ elif badrex1.match(newname):
+ warning = 'project name may not start with "."'
+ elif badrex2.match(newname):
+ warning = 'project name contains illegal characters or whitespace.'
+ else:
+ warning = "Project " + newname + " already exists!"
+ newname = ProjectNameDialog(self, warning, seed=newname).result
+ if not newname:
+ return 0 # Canceled, no action.
+ newproject = self.projectdir + '/' + newname
+ print("New project name is " + newname + ".")
+ # (3) Create new directory
+ os.makedirs(newproject)
+ # (4) Dump the tarball (if any) in the new directory
+ if tarname:
+ with tarfile.open(tarname, mode='r:gz') as archive:
+ for member in archive:
+ archive.extract(member, newproject)
+ # (5) Copy the JSON document into the new directory. Keep the
+ # original name of the project, so as to overwrite any existing
+ # document, then change the name to match that of the project
+ # folder.
+ # New behavior 12/2018: JSON file is always called 'project.json'.
+ # Also support legacy JSON name if it exists (don't generate files with
+ # both names)
+
+ jsonfile = newproject + '/project.json'
+ if not os.path.isfile(jsonfile):
+ if os.path.isfile(newproject + '/' + projname + '.json'):
+ jsonfile = newproject + '/' + projname + '.json'
+
+ try:
+ shutil.copy(importfile, jsonfile)
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ return None
+ else:
+ # If filename is 'project.json' then it does not need to be changed.
+ # This is for legacy name support only.
+ if jsonfile != newproject + '/project.json':
+ shutil.move(jsonfile, newproject + '/' + newname + '.json')
+
+ # (6) Remove the original files from the import folder
+ os.remove(importfile)
+ if tarname:
+ os.remove(tarname)
+
+ # (7) Standard project setup: if spi/, elec/, and ngspice/ do not
+ # exist, create them. If elec/.java does not exist, create it and
+ # seed from deskel. If ngspice/run and ngspice/run/.allwaves do not
+ # exist, create them.
+
+ if not os.path.exists(newproject + '/spi'):
+ os.makedirs(newproject + '/spi')
+ if not os.path.exists(newproject + '/spi/pex'):
+ os.makedirs(newproject + '/spi/pex')
+ if not os.path.exists(newproject + '/spi/lvs'):
+ os.makedirs(newproject + '/spi/lvs')
+ if not os.path.exists(newproject + '/ngspice'):
+ os.makedirs(newproject + '/ngspice')
+ if not os.path.exists(newproject + '/ngspice/run'):
+ os.makedirs(newproject + '/ngspice/run')
+ if not os.path.exists(newproject + '/ngspice/run/.allwaves'):
+ os.makedirs(newproject + '/ngspice/run/.allwaves')
+ if not os.path.exists(newproject + '/elec'):
+ os.makedirs(newproject + '/elec')
+ if not os.path.exists(newproject + '/xcirc'):
+ os.makedirs(newproject + '/xcirc')
+ if not os.path.exists(newproject + '/mag'):
+ os.makedirs(newproject + '/mag')
+
+ self.reinitElec(newproject) # [re]install elec/.java, elec/LIBDIRS if needed, from pdk-specific if-any
+
+ return 1 # Success
+
+ #------------------------------------------------------------------------
+ # Import for netlists (.spi):
+ # (1) Request project name
+ # (2) Create new project if name does not exist, or
+ # place netlist in existing project if it does.
+ #------------------------------------------------------------------------
+
+ #--------------------------------------------------------------------
+ # Install netlist in electric:
+ # "importfile" is the filename in ~/design/import
+ # "pname" is the name of the target project (folder)
+ # "newfile" is the netlist file name (which may or may not be the same
+ # as 'importfile').
+ #--------------------------------------------------------------------
+
+ def install_in_electric(self, importfile, pname, newfile, isnew=True):
+ #--------------------------------------------------------------------
+ # Install the netlist.
+ # If netlist is CDL, then call cdl2spi first
+ #--------------------------------------------------------------------
+
+ newproject = self.projectdir + '/' + pname
+ if not os.path.isdir(newproject + '/spi/'):
+ os.makedirs(newproject + '/spi/')
+ if os.path.splitext(newfile)[1] == '.cdl':
+ if not os.path.isdir(newproject + '/cdl/'):
+ os.makedirs(newproject + '/cdl/')
+ shutil.copy(importfile, newproject + '/cdl/' + newfile)
+ try:
+ p = subprocess.run(['/ef/apps/bin/cdl2spi', importfile],
+ stdout = subprocess.PIPE, stderr = subprocess.PIPE,
+ check = True)
+ except subprocess.CalledProcessError as e:
+ print('Error running cdl2spi: ' + e.output.decode('utf-8'))
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return None
+ else:
+ spi_string = p.stdout.splitlines()[0].decode('utf-8')
+ if p.stderr:
+ err_string = p.stderr.splitlines()[0].decode('utf-8')
+ # Print error messages to console
+ print(err_string)
+ if not spi_string:
+ print('Error: cdl2spi has no output')
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return None
+ outname = os.path.splitext(newproject + '/spi/' + newfile)[0] + '.spi'
+ with open(outname, 'w') as f:
+ f.write(spi_string)
+ else:
+ outname = newproject + '/spi/' + newfile
+ try:
+ shutil.copy(importfile, outname)
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return None
+
+ #--------------------------------------------------------------------
+ # Symbol generator---this code to be moved into its own def.
+ #--------------------------------------------------------------------
+ # To-do, need a more thorough SPICE parser, maybe use netgen to parse.
+ # Need to find topmost subcircuit, by parsing the hieararchy.
+ subcktrex = re.compile('\.subckt[ \t]+([^ \t]+)[ \t]+', re.IGNORECASE)
+ subnames = []
+ with open(importfile, 'r') as f:
+ for line in f:
+ lmatch = subcktrex.match(line)
+ if lmatch:
+ subnames.append(lmatch.group(1))
+
+ if subnames:
+ subname = subnames[0]
+
+ # Run cdl2icon perl script
+ try:
+ p = subprocess.run(['/ef/apps/bin/cdl2icon', '-file', importfile, '-cellname',
+ subname, '-libname', pname, '-projname', pname, '--prntgussddirs'],
+ stdout = subprocess.PIPE, stderr = subprocess.PIPE, check = True)
+ except subprocess.CalledProcessError as e:
+ print('Error running cdl2spi: ' + e.output.decode('utf-8'))
+ return None
+ else:
+ pin_string = p.stdout.splitlines()[0].decode('utf-8')
+ if not pin_string:
+ print('Error: cdl2icon has no output')
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return None
+ if p.stderr:
+ err_string = p.stderr.splitlines()[0].decode('utf-8')
+ print(err_string)
+
+ # Invoke dialog to arrange pins here
+ pin_info_list = SymbolBuilder(self, pin_string.split(), fontsize=self.prefs['fontsize']).result
+ if not pin_info_list:
+ # Dialog was canceled
+ print("Symbol builder was canceled.")
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return 0
+
+ for pin in pin_info_list:
+ pin_info = pin.split(':')
+ pin_name = pin_info[0]
+ pin_type = pin_info[1]
+
+ # Call cdl2icon with the final pin directions
+ outname = newproject + '/elec/' + pname + '.delib/' + os.path.splitext(newfile)[0] + '.ic'
+ try:
+ p = subprocess.run(['/ef/apps/bin/cdl2icon', '-file', importfile, '-cellname',
+ subname, '-libname', pname, '-projname', pname, '-output',
+ outname, '-pindircmbndstring', ','.join(pin_info_list)],
+ stdout = subprocess.PIPE, stderr = subprocess.PIPE, check = True)
+ except subprocess.CalledProcessError as e:
+ print('Error running cdl2icon: ' + e.output.decode('utf-8'))
+ if isnew == True:
+ shutil.rmtree(newproject)
+ return None
+ else:
+ icon_string = p.stdout.splitlines()[0].decode('utf-8') # not used, AFAIK
+ if p.stderr:
+ err_string = p.stderr.splitlines()[0].decode('utf-8')
+ print(err_string)
+
+ return 1 # Success
+
+ #------------------------------------------------------------------------
+ # Import netlist file into existing project
+ #------------------------------------------------------------------------
+
+ def importspiceinto(self, newfile, importfile):
+ # Require existing project location
+ ppath = ExistingProjectDialog(self, self.get_project_list()).result
+ if not ppath:
+ return 0 # Canceled in dialog, no action.
+ pname = os.path.split(ppath)[1]
+ print("Importing into existing project " + pname)
+ result = self.install_in_electric(importfile, pname, newfile, isnew=False)
+ if result == None:
+ print('Error during import.')
+ return None
+ elif result == 0:
+ return 0 # Canceled
+ else:
+ # Remove original file from imports area
+ os.remove(importfile)
+ return 1 # Success
+
+ #------------------------------------------------------------------------
+ # Import netlist file as a new project
+ #------------------------------------------------------------------------
+
+ def importspice(self, newfile, importfile):
+ # Use create project code first to generate a valid project space.
+ newname = self.createproject(None)
+ if not newname:
+ return 0 # Canceled in dialog, no action.
+ print("Importing as new project " + newname + ".")
+ result = self.install_in_electric(importfile, newname, newfile, isnew=True)
+ if result == None:
+ print('Error during install')
+ return None
+ elif result == 0:
+ # Canceled, so do not remove the import
+ return 0
+ else:
+ # Remove original file from imports area
+ os.remove(importfile)
+ return 1 # Success
+
+ #------------------------------------------------------------------------
+ # Determine if JSON's tar can be imported as-if it were just a *.v.
+ # This is thin wrapper around tarVglImportable. Find the JSON's associated
+ # tar.gz if any, and call tarVglImportable.
+ # Returns list of two:
+ # None if rules not satisified; else path of the single GL .v member.
+ # None if rules not satisified; else root-name of the single .json member.
+ #------------------------------------------------------------------------
+
+ def jsonTarVglImportable(self, path):
+ ext = os.path.splitext(path)[1]
+ if ext != '.json': return None, None, None
+
+ tar = self.json2targz(path)
+ if not tar: return None, None, None
+
+ return self.tarVglImportable(tar)
+
+ #------------------------------------------------------------------------
+ # Get a single named member (memPath) out of a JSON's tar file.
+ # This is thin wrapper around tarMember2tempfile. Find the JSON's associated
+ # tar.gz if any, and call tarMember2tempfile.
+ #------------------------------------------------------------------------
+
+ def jsonTarMember2tempfile(self, path, memPath):
+ ext = os.path.splitext(path)[1]
+ if ext != '.json': return None
+
+ tar = self.json2targz(path)
+ if not tar: return None
+
+ return self.tarMember2tempfile(tar, memPath)
+
+ #------------------------------------------------------------------------
+ # Determine if tar-file can be imported as-if it were just a *.v.
+ # Require exactly one yosys-output .netlist.v, and exactly one .json.
+ # Nothing else matters: Ignore all other *.v, *.tv, *.jelib, *.vcd...
+ #
+ # If user renames *.netlist.v in cloudv before export to not end in
+ # netlist.v, we won't recognize it.
+ #
+ # Returns list of two:
+ # None if rules not satisified; else path of the single GL netlist.v member.
+ # None if rules not satisified; else root-name of the single .json member.
+ #------------------------------------------------------------------------
+
+ def tarVglImportable(self, path):
+ # count tar members by extensions. Track the .netlist.v. and .json. Screw the rest.
+ nbrExt = {'.v':0, '.netlist.v':0, '.tv':0, '.jelib':0, '.json':0, '/other/':0, '/vgl/':0}
+ nbrGLv = 0
+ jname = None
+ vfile = None
+ node = None
+ t = tarfile.open(path)
+ for i in t:
+ # ignore (without counting) dir entries. From cloudv (so far) the tar does not
+ # have dir-entries, but most tar do (esp. most manually made test cases).
+ if i.isdir():
+ continue
+ # TODO: should we require all below counted files to be plain files (no symlinks etc.)?
+ # get extension, but recognize a multi-ext for .netlist.v case
+ basenm = os.path.basename(i.name)
+ ext = os.path.splitext(basenm)[1]
+ root = os.path.splitext(basenm)[0]
+ ext2 = os.path.splitext(root)[1]
+ if ext2 == '.netlist' and ext == '.v':
+ ext = ext2 + ext
+ if ext and ext not in nbrExt:
+ ext = '/other/'
+ elif ext == '.netlist.v' and self.tarMemberIsGLverilog(t, i.name):
+ vfile = i.name
+ ext = '/vgl/'
+ elif ext == '.json':
+ node = self.tarMemberHasFoundryNode(t, i.name)
+ jname = root
+ nbrExt[ext] += 1
+
+ # check rules. Require exactly one yosys-output .netlist.v, and exactly one .json.
+ # Quantities of other types are all don't cares.
+ if (nbrExt['/vgl/'] == 1 and nbrExt['.json'] == 1):
+ # vfile is the name of the verilog netlist in the tarball, while jname
+ # is the root name of the JSON file found in the tarball (if any)
+ return vfile, jname, node
+
+ # failed, not gate-level-verilog importable:
+ return None, None, node
+
+
+ #------------------------------------------------------------------------
+ # OBSOLETE VERSION: Determine if tar-file can be imported as-if it were just a *.v.
+ # Rules for members: one *.v, {0,1} *.jelib, {0,1} *.json, 0 other types.
+ # Return None if rules not satisified; else return path of the single .v.
+ #------------------------------------------------------------------------
+ #
+ # def tarVglImportable(self, path):
+ # # count tar members by extensions. Track the .v.
+ # nbrExt = {'.v':0, '.jelib':0, '.json':0, 'other':0}
+ # vfile = ""
+ # t = tarfile.open(path)
+ # for i in t:
+ # ext = os.path.splitext(i.name)[1]
+ # if ext not in nbrExt:
+ # ext = 'other'
+ # nbrExt[ext] += 1
+ # if ext == ".v": vfile = i.name
+ #
+ # # check rules.
+ # if (nbrExt['.v'] != 1 or nbrExt['other'] != 0 or
+ # nbrExt['.jelib'] > 1 or nbrExt['.json'] > 1):
+ # return None
+ # return vfile
+
+ #------------------------------------------------------------------------
+ # Get a single named member (memPath) out of a tar file (tarPath), into a
+ # temp-file, so subprocesses can process it.
+ # Return path to the temp-file, or None if member not found in the tar.
+ #------------------------------------------------------------------------
+
+ def tarMember2tempfile(self, tarPath, memPath):
+ t = tarfile.open(tarPath)
+ member = t.getmember(memPath)
+ if not member: return None
+
+ # Change member.name so it extracts into our new temp-file.
+ # extract() can specify the root-dir befow which the member path
+ # resides. If temp is an absolute-path, that root-dir must be /.
+ tmpf1 = tempfile.NamedTemporaryFile(delete=False)
+ if tmpf1.name[0] != "/":
+ raise ValueError("assertion failed, temp-file path not absolute: %s" % tmpf1.name)
+ member.name = tmpf1.name
+ t.extract(member,"/")
+
+ return tmpf1.name
+
+ #------------------------------------------------------------------------
+ # Create an electric .delib directory and seed it with a header file
+ #------------------------------------------------------------------------
+
+ def create_electric_header_file(self, project, libname):
+ if not os.path.isdir(project + '/elec/' + libname + '.delib'):
+ os.makedirs(project + '/elec/' + libname + '.delib')
+
+ p = subprocess.run(['electric', '-v'], stdout=subprocess.PIPE)
+ eversion = p.stdout.splitlines()[0].decode('utf-8')
+ # Create header file
+ with open(project + '/elec/' + libname + '.delib/header', 'w') as f:
+ f.write('# header information:\n')
+ f.write('H' + libname + '|' + eversion + '\n\n')
+ f.write('# Tools:\n')
+ f.write('Ouser|DefaultTechnology()Sschematic\n')
+ f.write('Osimulation|VerilogUseAssign()BT\n')
+ f.write('C____SEARCH_FOR_CELL_FILES____\n')
+
+ #------------------------------------------------------------------------
+ # Create an ad-hoc "project.json" dictionary and fill essential records
+ #------------------------------------------------------------------------
+
+ def create_ad_hoc_json(self, ipname, pname):
+ # Create ad-hoc JSON file and fill it with the minimum
+ # necessary entries to define a project.
+ jData = {}
+ jDS = {}
+ jDS['ip-name'] = ipname
+ pdkdir = self.get_pdk_dir(pname, path=True)
+ try:
+ jDS['foundry'], jDS['node'], pdk_desc, pdk_stat = self.pdkdir2fnd( pdkdir )
+ except:
+ # Cannot parse PDK name, so foundry and node will remain undefined
+ pass
+ jDS['format'] = '3'
+ pparams = []
+ param = {}
+ param['unit'] = "\u00b5m\u00b2"
+ param['condition'] = "device_area"
+ param['display'] = "Device area"
+ pmax = {}
+ pmax['penalty'] = '0'
+ pmax['target'] = '100000'
+ param['max'] = pmax
+ pparams.append(param)
+
+ param = {}
+ param['unit'] = "\u00b5m\u00b2"
+ param['condition'] = "area"
+ param['display'] = "Layout area"
+ pmax = {}
+ pmax['penalty'] = '0'
+ pmax['target'] = '100000'
+ param['max'] = pmax
+ pparams.append(param)
+
+ param = {}
+ param['unit'] = "\u00b5m"
+ param['condition'] = "width"
+ param['display'] = "Layout width"
+ pmax = {}
+ pmax['penalty'] = '0'
+ pmax['target'] = '300'
+ param['max'] = pmax
+ pparams.append(param)
+
+ param = {}
+ param['condition'] = "DRC_errors"
+ param['display'] = "DRC errors"
+ pmax = {}
+ pmax['penalty'] = 'fail'
+ pmax['target'] = '0'
+ param['max'] = pmax
+ pparams.append(param)
+
+ param = {}
+ param['condition'] = "LVS_errors"
+ param['display'] = "LVS errors"
+ pmax = {}
+ pmax['penalty'] = 'fail'
+ pmax['target'] = '0'
+ param['max'] = pmax
+ pparams.append(param)
+
+ jDS['physical-params'] = pparams
+ jData['data-sheet'] = jDS
+
+ return jData
+
+ #------------------------------------------------------------------------
+ # For a single named member (memPath) out of an open tarfile (tarf),
+ # determine if it is a JSON file, and attempt to extract value of entry
+ # 'node' in dictionary entry 'data-sheet'. Otherwise return None.
+ #------------------------------------------------------------------------
+
+ def tarMemberHasFoundryNode(self, tarf, memPath):
+ fileJSON = tarf.extractfile(memPath)
+ if not fileJSON: return None
+
+ try:
+ # NOTE: tarfile data is in bytes, json.load(fileJSON) does not work.
+ datatop = json.loads(fileJSON.read().decode('utf-8'))
+ except:
+ print("Failed to load extract file " + memPath + " as JSON data")
+ return None
+ else:
+ node = None
+ if 'data-sheet' in datatop:
+ dsheet = datatop['data-sheet']
+ if 'node' in dsheet:
+ node = dsheet['node']
+
+ fileJSON.close() # close open-tarfile before any return
+ return node
+
+ #------------------------------------------------------------------------
+ # For a single named member (memPath) out of an open tarfile (tarf),
+ # determine if first line embeds (case-insensitive match): Generated by Yosys
+ # Return True or False. If no such member or it has no 1st line, returns False.
+ #------------------------------------------------------------------------
+
+ def tarMemberIsGLverilog(self, tarf, memPath):
+ fileHdl = tarf.extractfile(memPath)
+ if not fileHdl: return False
+
+ line = fileHdl.readline()
+ fileHdl.close() # close open-tarfile before any return
+ if not line: return False
+ return ('generated by yosys' in line.decode('utf-8').lower())
+
+ #------------------------------------------------------------------------
+ # Import vgl-netlist file INTO existing project.
+ # The importfile can be a .v; or a .json-with-tar that embeds a .v.
+ # What is newfile? not used here.
+ #
+ # PROMPT to select an existing project is here.
+ # (Is also a PROMPT to select existing electric lib, but that's within importvgl).
+ #------------------------------------------------------------------------
+
+ def importvglinto(self, newfile, importfile):
+ # Require existing project location
+ ppath = ExistingProjectDialog(self, self.get_project_list()).result
+ if not ppath: return 0 # Canceled in dialog, no action.
+ pname = os.path.split(ppath)[1]
+ print( "Importing into existing project: %s" % (pname))
+
+ return self.importvgl(newfile, importfile, pname)
+
+ #------------------------------------------------------------------------
+ # Import cloudv project as new project.
+ #------------------------------------------------------------------------
+
+ def install_from_cloudv(self, opath, ppath, pdkname, stdcellname, ydicts):
+ oname = os.path.split(opath)[1]
+ pname = os.path.split(ppath)[1]
+
+ print('Cloudv project name is ' + str(oname))
+ print('New Open Galaxy project name is ' + str(pname))
+
+ os.makedirs(ppath + '/verilog', exist_ok=True)
+
+ vfile = None
+ isfullchip = False
+ ipname = oname
+
+ # First check for single synthesized projects, or all synthesized
+ # digital sub-blocks within a full-chip project.
+
+ os.makedirs(ppath + '/verilog/source', exist_ok=True)
+ bfiles = glob.glob(opath + '/build/*.netlist.v')
+ for bfile in bfiles:
+ tname = os.path.split(bfile)[1]
+ vname = os.path.splitext(os.path.splitext(tname)[0])[0]
+ tfile = ppath + '/verilog/' + vname + '/' + vname + '.vgl'
+ print('Making qflow sub-project ' + vname)
+ os.makedirs(ppath + '/verilog/' + vname, exist_ok=True)
+ shutil.copy(bfile, tfile)
+ if vname == oname:
+ vfile = tfile
+
+ # Each build project gets its own qflow directory. Create the
+ # source/ subdirectory and make a link back to the .vgl file.
+ # qflow prep should do the rest.
+
+ os.makedirs(ppath + '/qflow', exist_ok=True)
+ os.makedirs(ppath + '/qflow/' + vname)
+ os.makedirs(ppath + '/qflow/' + vname + '/source')
+
+ # Make sure the symbolic link is relative, so that it is portable
+ # through a shared project.
+ curdir = os.getcwd()
+ os.chdir(ppath + '/qflow/' + vname + '/source')
+ os.symlink('../../../verilog/' + vname + '/' + vname + '.vgl', vname + '.v')
+ os.chdir(curdir)
+
+ # Create a simple qflow_vars.sh file so that the project manager
+ # qflow launcher will see it as a qflow sub-project. If the meta.yaml
+ # file has a "stdcell" entry for the subproject, then add the line
+ # "techname=" with the name of the standard cell library as pulled
+ # from meta.yaml.
+
+ stdcell = None
+ buildname = 'build/' + vname + '.netlist.v'
+ for ydict in ydicts:
+ if buildname in ydict:
+ yentry = ydict[buildname]
+ if 'stdcell' in yentry:
+ stdcell = yentry['stdcell']
+
+ with open(ppath + '/qflow/' + vname + '/qflow_vars.sh', 'w') as ofile:
+ print('#!/bin/tcsh -f', file=ofile)
+ if stdcell:
+ print('set techname=' + stdcell, file=ofile)
+
+ # Now check for a full-chip verilog SoC (from CloudV)
+
+ modrex = re.compile('[ \t]*module[ \t]+[^ \t(]*_?soc[ \t]*\(')
+ genmodrex = re.compile('[ \t]*module[ \t]+([^ \t(]+)[ \t]*\(')
+
+ bfiles = glob.glob(opath + '/*.model/*.v')
+ for bfile in bfiles:
+ tname = os.path.split(bfile)[1]
+ vpath = os.path.split(bfile)[0]
+ ipname = os.path.splitext(tname)[0]
+ tfile = ppath + '/verilog/' + ipname + '.v'
+ isfullchip = True
+ break
+
+ if isfullchip:
+ print('Cloudv project IP name is ' + str(ipname))
+
+ # All files in */ paths should be copied to project verilog/source/,
+ # except for the module containing the SoC itself. Note that the actual
+ # verilog source goes here, not the synthesized netlist, although that is
+ # mainly for efficiency of the simulation, which would normally be done in
+ # cloudV and not in Open Galaxy. For Open Galaxy, what is needed is the
+ # existence of a verilog file containing a module name, which is used to
+ # track down the various files (LEF, DEF, etc.) that are needed for full-
+ # chip layout.
+ #
+ # (Sept. 2019) Added copying of files in /SW/ -> /sw/ and /Verify/ ->
+ # /verify/ for running full-chip simulations on the Open Galaxy side.
+
+ os.makedirs(ppath + '/verilog', exist_ok=True)
+
+ cfiles = glob.glob(vpath + '/source/*')
+ for cfile in cfiles:
+ cname = os.path.split(cfile)[1]
+ if cname != tname:
+ tpath = ppath + '/verilog/source/' + cname
+ os.makedirs(ppath + '/verilog/source', exist_ok=True)
+ shutil.copy(cfile, tpath)
+
+ cfiles = glob.glob(vpath + '/verify/*')
+ for cfile in cfiles:
+ cname = os.path.split(cfile)[1]
+ tpath = ppath + '/verilog/verify/' + cname
+ os.makedirs(ppath + '/verilog/verify', exist_ok=True)
+ shutil.copy(cfile, tpath)
+
+ cfiles = glob.glob(vpath + '/sw/*')
+ for cfile in cfiles:
+ cname = os.path.split(cfile)[1]
+ tpath = ppath + '/verilog/sw/' + cname
+ os.makedirs(ppath + '/verilog/sw', exist_ok=True)
+ shutil.copy(cfile, tpath)
+
+ # Read the top-level SoC verilog and recast it for OpenGalaxy.
+ with open(bfile, 'r') as ifile:
+ chiplines = ifile.read().splitlines()
+
+ # Find the modules used, track them down, and add the source location
+ # in the Open Galaxy environment as an "include" line in the top level
+ # verilog.
+
+ parentdir = os.path.split(bfile)[0]
+ modfile = parentdir + '/docs/modules.txt'
+
+ modules = []
+ if os.path.isfile(modfile):
+ with open(modfile, 'r') as ifile:
+ modules = ifile.read().splitlines()
+ else:
+ print("Warning: No modules.txt file for the chip top level module in "
+ + parentdir + "/docs/.\n")
+
+ # Get the names of verilog libraries in this PDK.
+ pdkdir = os.path.realpath(ppath + '/.ef-config/techdir')
+ pdkvlog = pdkdir + '/libs.ref/verilog'
+ pdkvlogfiles = glob.glob(pdkvlog + '/*/*.v')
+
+ # Read the verilog libraries and create a dictionary mapping each
+ # module name to a location of the verilog file where it is located.
+ moddict = {}
+ for vlogfile in pdkvlogfiles:
+ with open(vlogfile, 'r') as ifile:
+ for line in ifile.read().splitlines():
+ mmatch = genmodrex.match(line)
+ if mmatch:
+ modname = mmatch.group(1)
+ moddict[modname] = vlogfile
+
+ # Get the names of verilog libraries in the user IP space.
+ # (TO DO: Need to know the IP version being used!)
+ designdir = os.path.split(ppath)[0]
+ ipdir = designdir + '/ip/'
+ uservlogfiles = glob.glob(ipdir + '/*/*/verilog/*.v')
+ for vlogfile in uservlogfiles:
+ # Strip ipdir from the front
+ vlogpath = vlogfile.replace(ipdir, '', 1)
+ with open(vlogfile, 'r') as ifile:
+ for line in ifile.read().splitlines():
+ mmatch = genmodrex.match(line)
+ if mmatch:
+ modname = mmatch.group(1)
+ moddict[modname] = vlogpath
+
+ # Find all netlist builds from the project (those that were copied above)
+ buildfiles = glob.glob(ppath + '/verilog/source/*.v')
+ for vlogfile in buildfiles:
+ # Strip ipdir from the front
+ vlogpath = vlogfile.replace(ppath + '/verilog/source/', '', 1)
+ with open(vlogfile, 'r') as ifile:
+ for line in ifile.read().splitlines():
+ mmatch = genmodrex.match(line)
+ if mmatch:
+ modname = mmatch.group(1)
+ moddict[modname] = vlogpath
+
+ # (NOTE: removing 'ifndef LVS' as netgen should be able to handle
+ # the contents of included files, and they are preferred since any
+ # arrays are declared in each module I/O)
+ # chiplines.insert(0, '`endif')
+ chiplines.insert(0, '//--- End of list of included module dependencies ---')
+ includedfiles = []
+ for module in modules:
+ # Determine where this module comes from. Look in the PDK, then in
+ # the user ip/ directory, then in the local hierarchy. Note that
+ # the local hierarchy expects layouts from synthesized netlists that
+ # have not yet been created, so determine the expected location.
+
+ if module in moddict:
+ if moddict[module] not in includedfiles:
+ chiplines.insert(0, '`include "' + moddict[module] + '"')
+ includedfiles.append(moddict[module])
+
+ # chiplines.insert(0, '`ifndef LVS')
+ chiplines.insert(0, '//--- List of included module dependencies ---')
+ chiplines.insert(0, '// iverilog simulation requires the use of -I source -I ~/design/ip')
+ chiplines.insert(0, '// NOTE: Includes may be rooted at ~/design/ip/ or at ./source')
+ chiplines.insert(0, '// SoC top level verilog copied and modified by project manager')
+
+ # Copy file, but replace the module name "soc" with the ip-name
+ with open(tfile, 'w') as ofile:
+ for chipline in chiplines:
+ print(modrex.sub('module ' + ipname + ' (', chipline), file=ofile)
+
+ # Need to define behavior: What if there is more than one netlist?
+ # Which one is to be imported? For now, ad-hoc behavior is to select
+ # the last netlist file in the list if no file matches the ip-name.
+
+ # Note that for full-chip projects, the full chip verilog file is always
+ # the last one set.
+
+ if not vfile:
+ try:
+ vfile = tfile
+ except:
+ pass
+
+ # NOTE: vfile was being used to create a symbol, but not any more;
+ # see below. All the above code referencing vfile can probably be
+ # removed.
+
+ try:
+ sfiles = glob.glob(vpath + '/source/*')
+ sfiles.extend(glob.glob(vpath + '/*/source/*'))
+ except:
+ sfiles = glob.glob(opath + '/*.v')
+ sfiles.extend(glob.glob(opath + '/*.sv'))
+ sfiles.extend(glob.glob(opath + '/local/*'))
+
+ for fname in sfiles:
+ sname = os.path.split(fname)[1]
+ tfile = ppath + '/verilog/source/' + sname
+ # Reject '.model' and '.soc" files (these are meaningful only to CloudV)
+ fileext = os.path.splitext(fname)[1]
+ if fileext == '.model' or fileext == '.soc':
+ continue
+ if os.path.isfile(fname):
+ # Check if /verilog/source/ has been created
+ if not os.path.isdir(ppath + '/verilog/source'):
+ os.makedirs(ppath + '/verilog/source')
+ shutil.copy(fname, tfile)
+
+ # Add standard cell library name to project.json
+ pjsonfile = ppath + '/project.json'
+ if os.path.exists(pjsonfile):
+ with open(pjsonfile, 'r') as ifile:
+ datatop = json.load(ifile)
+ else:
+ datatop = self.create_ad_hoc_json(ipname, ppath)
+
+ # Generate a symbol in electric for the verilog top module
+ iconfile = ppath + '/elec/' + ipname + '.delib/' + ipname + '.ic'
+ if not os.path.exists(iconfile):
+ # NOTE: Symbols are created by qflow migration for project
+ # builds. Only the chip top-level needs to run create_symbol
+ # here.
+
+ if isfullchip:
+ print("Creating symbol for module " + ipname + " automatically from verilog source.")
+ create_symbol(ppath, vfile, ipname, iconfile, False)
+ # Add header file
+ self.create_electric_header_file(ppath, ipname)
+
+ dsheet = datatop['data-sheet']
+ if not stdcellname or stdcellname == "":
+ dsheet['standard-cell'] = 'default'
+ else:
+ dsheet['standard-cell'] = stdcellname
+
+ with open(pjsonfile, 'w') as ofile:
+ json.dump(datatop, ofile, indent = 4)
+
+ return 0
+
+ #------------------------------------------------------------------------
+ # Import vgl-netlist AS new project.
+ # The importfile can be a .v; or a .json-with-tar that embeds a .v.
+ # What is newfile? not used here.
+ #
+ # PROMPT to select an create new project is within importvgl.
+ #------------------------------------------------------------------------
+
+ def importvglas(self, newfile, importfile, seedname):
+ print('importvglas: seedname is ' + str(seedname))
+ return self.importvgl(newfile, importfile, newname=None, seedname=seedname)
+
+ #------------------------------------------------------------------------
+ # Utility shared/used by both: Import vgl-netlist file AS or INTO a project.
+ # Called directly for AS. Called via importvglinto for INTO.
+ # importfile : source of .v to import, actual .v or json-with-tar that embeds a .v
+ # newfile : not used
+ # newname : target project-name (INTO), or None (AS: i.e. prompt to create one).
+ # Either newname is given: we PROMPT to pick an existing elecLib;
+ # Else PROMPT for new projectName and CREATE it (and use elecLib of same name).
+ #------------------------------------------------------------------------
+
+ def importvgl(self, newfile, importfile, newname=None, seedname=None):
+ elecLib = None
+ isnew = not newname
+
+ # Up front: Determine if this import has a .json file associated
+ # with it. If so, then parse the JSON data to find if there is a
+ # foundry and node set for the project. If so, then the foundry
+ # node is not selectable at time of import. Likewise, if "isnew"
+ # is false, then we need to check if there is a directory called
+ # "newname" and if it is set to the same foundry node. If not,
+ # then the import must be rejected.
+
+ tarVfile, jName, importnode = self.jsonTarVglImportable(importfile)
+
+ if isnew:
+ print('importvgl: seedname is ' + str(seedname))
+ # Use create project code first to generate a valid project space.
+ newname = self.createproject(None, seedname, importnode)
+ if not newname: return 0 # Canceled in dialog, no action.
+ print("Importing as new project " + newname + ".")
+ elecLib = newname
+
+ ppath = self.projectdir + '/' + newname
+ if not elecLib:
+ choices = self.get_elecLib_list(newname)
+ if not choices:
+ print( "Aborted: No existing electric libraries found to import into.")
+ return 0
+
+ elecLib = ExistingElecLibDialog(self, choices).result
+ if not elecLib:
+ # Never a just-created project to delete here: We only PROMPT to pick elecLib in non-new case.
+ return 0 # Canceled in dialog, no action.
+
+ # Isolate just electric lib name without extension. ../a/b.delib -> b
+ elecLib = os.path.splitext(os.path.split(elecLib)[-1])[0]
+ print("Importing to project: %s, elecLib: %s" % (newname, elecLib))
+
+ # Determine isolated *.v as importactual. May be importfile or tar-member (as temp-file).
+ importactual = importfile
+ if tarVfile:
+ importactual = self.jsonTarMember2tempfile(importfile, tarVfile)
+ print("importing json-with-tar's member: %s" % (tarVfile))
+
+ if not os.path.isfile(importactual):
+ # TODO: should this be a raise instead?
+ print('Error determining *.v to import')
+ return None
+
+ result = self.vgl_install(importactual, newname, elecLib, newfile, isnew=isnew)
+ if result == None:
+ print('Error during install')
+ return None
+ elif result == 0:
+ # Canceled, so do not remove the import
+ return 0
+ else:
+ # If jName is non-NULL then there is a JSON file in the tarball. This is
+ # to be used as the project JSON file. Contents of file coming from
+ # CloudV are correct as of 12/8/2017.
+ pname = os.path.expanduser('~/design/' + newname)
+ legacyjname = pname + '/' + newname + '.json'
+ # New behavior 12/2018: Project JSON file always named 'project.json'
+ jname = pname + '/project.json'
+
+ # Do not overwrite an existing JSON file. Overwriting is a problem for
+ # "import into", as the files go into an existing project, which would
+ # normally have its own JSON file.
+
+ if not os.path.exists(jname) and not os.path.exists(legacyjname):
+ try:
+ tarJfile = os.path.split(tarVfile)[0] + '/' + jName + '.json'
+ importjson = self.jsonTarMember2tempfile(importfile, tarJfile)
+ except:
+ jData = self.create_ad_hoc_json(newname, pname)
+
+ with open(jname, 'w') as ofile:
+ json.dump(jData, ofile, indent = 4)
+
+ else:
+ # Copy the temporary file pulled from the tarball and
+ # remove the temporary file.
+ shutil.copy(importjson, jname)
+ os.remove(importjson)
+
+ # For time-being, if a tar.gz & json: archive them in the target project, also as extracted.
+ # Remove original file from imports area (either .v; or .json plus tar)
+ # plus temp-file if extracted from the tar.
+ if importactual != importfile:
+ os.remove(importactual)
+ pname = self.projectdir + '/' + newname
+ importd = pname + '/' + archiveimportdir # global: archiveimportdir
+ os.makedirs(importd, exist_ok=True)
+ # Dirnames to embed a VISIBLE date (UTC) of when populated.
+ # TODO: improve dir naming or better way to store & understand later when it was processed (a log?),
+ # without relying on file-system mtime.
+ archived = tempfile.mkdtemp( dir=importd, prefix='{:%Y-%m-%d.%H:%M:%S}-'.format(datetime.datetime.utcnow()))
+ tarname = self.json2targz(importfile)
+ if tarname:
+ with tarfile.open(tarname, mode='r:gz') as archive:
+ for member in archive:
+ archive.extract(member, archived)
+ self.moveJsonPlus(importfile, archived)
+ else:
+ self.removeJsonPlus(importfile)
+ return 1 # Success
+
+ #------------------------------------------------------------------------
+ # Prepare multiline "warning" indicating which files to install already exist.
+ # TODO: ugly, don't use a simple confirmation dialogue: present a proper table.
+ #------------------------------------------------------------------------
+ def installsConfirmMarkOverwrite(self, module, files):
+ warning = [ "For import of module: %s," % module ]
+ anyExists = False
+ for i in files:
+ exists = os.path.isfile(os.path.expanduser(i))
+ if exists: anyExists = True
+ warning += [ (" * " if exists else " ") + i ]
+ if anyExists:
+ titleSuffix = "\nCONFIRM installation of (*: OVERWRITE existing):"
+ else:
+ titleSuffix = "\nCONFIRM installation of:"
+ warning[0] += titleSuffix
+ return ConfirmInstallDialog(self, "\n".join(warning)).result
+
+ def vgl_install(self, importfile, pname, elecLib, newfile, isnew=True):
+ #--------------------------------------------------------------------
+ # Convert the in .v to: spi, cdl, elec-icon, elec-text-view forms.
+ # TODO: Prompt to confirm final install of 5 files in dir-structure.
+ #
+ # newfile: argument is not used. What is it for?
+ # Target project AND electricLib MAY BE same (pname) or different.
+ # Rest of the filenames are determined by the module name in the source .v.
+ #--------------------------------------------------------------------
+
+ newproject = self.projectdir + '/' + pname
+ try:
+ p = subprocess.run(['/ef/apps/bin/vglImport', importfile, pname, elecLib],
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+ check=True, universal_newlines=True)
+ except subprocess.CalledProcessError as e:
+ if hasattr(e, 'stdout') and e.stdout: print(e.stdout)
+ if hasattr(e, 'stderr') and e.stderr: print(e.stderr)
+ print('Error running vglImport: ' + str(e))
+ if isnew == True: shutil.rmtree(newproject)
+ return None
+ else:
+ dataLines = p.stdout.splitlines()
+ if p.stderr:
+ # Print error messages to console
+ for i in p.stderr.splitlines(): print(i)
+ if not dataLines or len(dataLines) != 11:
+ print('Error: vglImport has no output, or wrong #outputs (%d vs 11)' % len(dataLines))
+ if isnew == True: shutil.rmtree(newproject)
+ return None
+ else:
+ module = dataLines[0]
+ confirm = self.installsConfirmMarkOverwrite(module, dataLines[2::2])
+ if not confirm:
+ print("Cancelled")
+ if isnew == True: shutil.rmtree(newproject)
+ return 0
+ # print("Proceed")
+ clean = dataLines[1:]
+ nbr = len(dataLines)
+ ndx = 1
+ # trap I/O errors and clean-up if any
+ try:
+ while ndx+1 < nbr:
+ trg = os.path.expanduser(dataLines[ndx+1])
+ os.makedirs(os.path.dirname(trg), exist_ok=True)
+ shutil.move(dataLines[ndx], trg)
+ ndx += 2
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ for i in clean:
+ with contextlib.suppress(FileNotFoundError): os.remove(i)
+ if isnew == True: shutil.rmtree(newproject)
+ return 0
+ print( "For import of module %s installed: %s" % (module, " ".join(dataLines[2::2])))
+ return 1 # Success
+
+
+ #------------------------------------------------------------------------
+ # Callback function from "Import Into" button on imports list box.
+ #------------------------------------------------------------------------
+
+ def importintodesign(self, value):
+ if not value['values']:
+ print('No import selected.')
+ return
+
+ # Stop the watchdog timer while this is going on
+ self.watchclock.stop()
+ newname = value['text']
+ importfile = value['values'][0]
+ print('Import project name: ' + newname + '')
+ print('Import file name: ' + importfile + '')
+
+ # Behavior depends on what kind of file is being imported.
+ # Tarballs are entire projects. Other files are individual
+ # files and may be imported into new or existing projects
+
+ if os.path.isdir(importfile):
+ print('File is a project, must import as new project.')
+ result = self.import2project(importfile, addWarn='Redirected: A projectDir must Import-As new project.')
+ else:
+ ext = os.path.splitext(importfile)[1]
+ vFile, jName, importnode = self.jsonTarVglImportable(importfile)
+ if ((ext == '.json' and vFile) or ext == '.v'):
+ result = self.importvglinto(newname, importfile)
+ elif ext == '.json':
+ # Same behavior as "Import As", at least for now
+ print('File is a project, must import as new project.')
+ result = self.importjson(newname, importfile)
+ else:
+ result = self.importspiceinto(newname, importfile)
+
+ if result:
+ self.update_project_views(force=True)
+ self.watchclock.restart()
+
+ #------------------------------------------------------------------------
+ # Callback function from "Import As" button on imports list box.
+ #------------------------------------------------------------------------
+
+ def importdesign(self, value):
+ if not value['values']:
+ print('No import selected.')
+ return
+
+ # Stop the watchdog timer while this is going on
+ self.watchclock.stop()
+ newname = value['text']
+ importfile = value['values'][0]
+ print('Import project name: ' + newname)
+ print('Import file name: ' + importfile)
+
+ # Behavior depends on what kind of file is being imported.
+ # Tarballs are entire projects. Other files are individual
+ # files and may be imported into new or existing projects
+
+ if os.path.isdir(importfile):
+ result = self.import2project(importfile)
+ else:
+ pathext = os.path.splitext(importfile)
+ vfile, seedname, importnode = self.jsonTarVglImportable(importfile)
+ if ((pathext[1] == '.json' and seedname) or pathext[1] == '.v'):
+ result = self.importvglas(newname, importfile, seedname)
+ elif pathext[1] == '.json':
+ result = self.importjson(newname, importfile)
+ else:
+ result = self.importspice(newname, importfile)
+
+ if result:
+ self.update_project_views(force=True)
+ self.watchclock.restart()
+
+ def deleteimport(self, value):
+ if not value['values']:
+ print('No import selected.')
+ return
+
+ print("Delete import " + value['text'] + ' ' + value['values'][0] + " !")
+ # Require confirmation
+ warning = 'Confirm delete import ' + value['text'] + '?'
+ confirm = ProtectedConfirmDialog(self, warning).result
+ if not confirm == 'okay':
+ return
+ print('Delete confirmed!')
+ item = value['values'][0]
+
+ if not os.path.islink(item) and os.path.isdir(item):
+ shutil.rmtree(item)
+ return
+
+ os.remove(item)
+ ext = os.path.splitext(item)
+ # Where import is a pair of .json and .tar.gz files, remove both.
+ if ext[1] == '.json':
+ if os.path.exists(ext[0] + '.tar.gz'):
+ os.remove(ext[0] + '.tar.gz')
+ elif os.path.exists(ext[0] + '.tgz'):
+ os.remove(ext[0] + '.tgz')
+
+ def update_project_views(self, force=False):
+ # More than updating project views, this updates projects, imports, and
+ # IP libraries.
+
+ projectlist = self.get_project_list()
+ self.projectselect.repopulate(projectlist)
+ pdklist = self.get_pdk_list(projectlist)
+ self.projectselect.populate2("PDK", projectlist, pdklist)
+
+ old_imports = self.number_of_imports
+ importlist = self.get_import_list()
+ self.importselect.repopulate(importlist)
+ valuelist = self.importselect.getvaluelist()
+ datelist = self.get_date_list(valuelist)
+ itemlist = self.importselect.getlist()
+ self.importselect.populate2("date", itemlist, datelist)
+
+ # To do: Check if itemlist in imports changed, and open if a new import
+ # has arrived.
+
+ if force or (old_imports != None) and (old_imports < self.number_of_imports):
+ self.import_open()
+
+ iplist = self.get_library_list()
+ self.ipselect.repopulate(iplist, versioning=True)
+ valuelist = self.ipselect.getvaluelist()
+ datelist = self.get_date_list(valuelist)
+ itemlist = self.ipselect.getlist()
+ self.ipselect.populate2("date", itemlist, datelist)
+
+ def update_alert(self):
+ # Project manager has been updated. Generate an alert window and
+ # provide option to restart the project manager.
+
+ warning = 'Project manager app has been updated. Restart now?'
+ confirm = ConfirmDialog(self, warning).result
+ if not confirm == 'okay':
+ print('Warning: Must quit and restart to get any fixes or updates.')
+ return
+ os.execl('/ef/efabless/opengalaxy/og_gui_manager.py', 'appsel_zenity.sh')
+ # Does not return; replaces existing process.
+
+ #----------------------------------------------------------------------
+ # Delete a project from the design folder.
+ #----------------------------------------------------------------------
+
+ def deleteproject(self, value):
+ if not value['values']:
+ print('No project selected.')
+ return
+ print('Delete project ' + value['values'][0])
+ # Require confirmation
+ warning = 'Confirm delete entire project ' + value['text'] + '?'
+ confirm = ProtectedConfirmDialog(self, warning).result
+ if not confirm == 'okay':
+ return
+ shutil.rmtree(value['values'][0])
+
+ #----------------------------------------------------------------------
+ # Clean out the simulation folder. Traditionally this was named
+ # 'ngspice', so this is checked for backward-compatibility. The
+ # proper name of the simulation directory is 'simulation'.
+ #----------------------------------------------------------------------
+
+ def cleanproject(self, value):
+ if not value['values']:
+ print('No project selected.')
+ return
+ ppath = value['values'][0]
+ print('Clean simulation raw data from directory ' + ppath)
+ # Require confirmation
+ warning = 'Confirm clean project ' + value['text'] + ' contents?'
+ confirm = ConfirmDialog(self, warning).result
+ if not confirm == 'okay':
+ return
+ if os.path.isdir(ppath + '/simulation'):
+ simpath = 'simulation'
+ elif os.path.isdir(ppath + '/ngspice'):
+ simpath = 'ngspice'
+ else:
+ print('Project has no simulation folder.')
+ return
+
+ filelist = os.listdir(ppath + '/' + simpath)
+ for sfile in filelist:
+ if os.path.splitext(sfile)[1] == '.raw':
+ os.remove(ppath + '/ngspice/' + sfile)
+ print('Project simulation folder cleaned.')
+
+ # Also clean the log file
+ filelist = os.listdir(ppath)
+ for sfile in filelist:
+ if os.path.splitext(sfile)[1] == '.log':
+ os.remove(ppath + '/' + sfile)
+
+ #---------------------------------------------------------------------------------------
+ # Determine which schematic editors are compatible with the PDK, and return a list of them.
+ #---------------------------------------------------------------------------------------
+
+ def list_valid_schematic_editors(self, pdktechdir):
+ # Check PDK technology directory for xcircuit, xschem, and electric
+ applist = []
+ if os.path.exists(pdktechdir + '/elec'):
+ applist.append('electric')
+ if os.path.exists(pdktechdir + '/xschem'):
+ applist.append('xschem')
+ if os.path.exists(pdktechdir + '/xcircuit'):
+ applist.append('xcircuit')
+
+ return applist
+
+ #------------------------------------------------------------------------------------------
+ # Determine which layout editors are compatible with the PDK, and return a list of them.
+ #------------------------------------------------------------------------------------------
+
+ def list_valid_layout_editors(self, pdktechdir):
+ # Check PDK technology directory for magic and klayout
+ applist = []
+ if os.path.exists(pdktechdir + '/magic'):
+ applist.append('magic')
+ if os.path.exists(pdktechdir + '/klayout'):
+ applist.append('klayout')
+ return applist
+
+ #----------------------------------------------------------------------
+ # Create a new project folder and initialize it (see below for steps)
+ #----------------------------------------------------------------------
+
+ def createproject(self, value, seedname=None, importnode=None):
+ # Note: value is current selection, if any, and is ignored
+ # Require new project location and confirmation
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[/ \t\n\\\><\*\?].*")
+ warning = 'Create new project:'
+ print(warning)
+ development = self.prefs['development']
+ while True:
+ try:
+ if seedname:
+ newname, newpdk = NewProjectDialog(self, warning, seed=seedname, importnode=importnode, development=development).result
+ else:
+ newname, newpdk = NewProjectDialog(self, warning, seed='', importnode=importnode, development=development).result
+ except TypeError:
+ # TypeError occurs when "Cancel" is pressed, just handle exception.
+ return None
+ if not newname:
+ return None # Canceled, no action.
+
+ newproject = self.projectdir + '/' + newname
+ if self.blacklisted(newname):
+ warning = newname + ' is not allowed for a project name.'
+ elif badrex1.match(newname):
+ warning = 'project name may not start with "."'
+ elif badrex2.match(newname):
+ warning = 'project name contains illegal characters or whitespace.'
+ elif os.path.exists(newproject):
+ warning = newname + ' is already a project name.'
+ else:
+ break
+
+ try:
+
+ subprocess.Popen([og_config.apps_path + '/create_project.py', newproject, newpdk])
+
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ return None
+
+ except:
+ print('Error making project.')
+ return None
+
+ return newname
+ '''
+ # Find what tools are compatible with the given PDK
+ schemapps = self.list_valid_schematic_editors(newpdk + '/libs.tech')
+ layoutapps = self.list_valid_layout_editors(newpdk + '/libs.tech')
+
+ print('New project name will be ' + newname + '.')
+ print('Associated project PDK is ' + newpdk + '.')
+ try:
+ os.makedirs(newproject)
+
+ # Make standard folders
+ if 'magic' in layoutapps:
+ os.makedirs(newproject + '/mag')
+
+ os.makedirs(newproject + '/spi')
+ os.makedirs(newproject + '/spi/pex')
+ os.makedirs(newproject + '/spi/lvs')
+ if 'electric' in layoutapps or 'electric' in schemapps:
+ os.makedirs(newproject + '/elec')
+ if 'xcircuit' in schemapps:
+ os.makedirs(newproject + '/xcirc')
+ if 'klayout' in schemapps:
+ os.makedirs(newproject + '/klayout')
+ os.makedirs(newproject + '/ngspice')
+ os.makedirs(newproject + '/ngspice/run')
+ if 'electric' in schemapps:
+ os.makedirs(newproject + '/ngspice/run/.allwaves')
+ os.makedirs(newproject + '/testbench')
+ os.makedirs(newproject + '/verilog')
+ os.makedirs(newproject + '/verilog/source')
+ os.makedirs(newproject + '/.ef-config')
+ if 'xschem' in schemapps:
+ os.makedirs(newproject + '/xschem')
+
+ pdkname = os.path.split(newpdk)[1]
+
+ # Symbolic links
+ os.symlink(newpdk, newproject + '/.ef-config/techdir')
+
+ # Copy preferences
+ # deskel = '/ef/efabless/deskel'
+ #
+ # Copy examples (disabled; this is too confusing to the end user. Also, they
+ # should not be in user space at all, as they are not user editable.
+ #
+ # for item in os.listdir(deskel + '/exlibs'):
+ # shutil.copytree(deskel + '/exlibs/' + item, newproject + '/elec/' + item)
+ # for item in os.listdir(deskel + '/exmag'):
+ # if os.path.splitext(item)[1] == '.mag':
+ # shutil.copy(deskel + '/exmag/' + item, newproject + '/mag/' + item)
+
+ # Put tool-specific startup files into the appropriate user directories.
+ if 'electric' in layoutapps or 'electric' in schemapps:
+ self.reinitElec(newproject) # [re]install elec/.java, elec/LIBDIRS if needed, from pdk-specific if-any
+ # Set up electric
+ self.create_electric_header_file(newproject, newname)
+
+ if 'magic' in layoutapps:
+ shutil.copy(newpdk + '/libs.tech/magic/current/' + pdkname + '.magicrc', newproject + '/mag/.magicrc')
+
+ if 'xcircuit' in schemapps:
+ xcircrc = newpdk + '/libs.tech/xcircuit/' + pdkname + '.' + 'xcircuitrc'
+ xcircrc2 = newpdk + '/libs.tech/xcircuit/xcircuitrc'
+ if os.path.exists(xcircrc):
+ shutil.copy(xcircrc, newproject + '/xcirc/.xcircuitrc')
+ elif os.path.exists(xcircrc2):
+ shutil.copy(xcircrc2, newproject + '/xcirc/.xcircuitrc')
+
+ if 'xschem' in schemapps:
+ xschemrc = newpdk + '/libs.tech/xschem/xschemrc'
+ if os.path.exists(xschemrc):
+ shutil.copy(xschemrc, newproject + '/xschem/xschemrc')
+
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ return None
+
+ return newname
+ '''
+ #----------------------------------------------------------------------
+ # Import a CloudV project from ~/cloudv/<project_name>
+ #----------------------------------------------------------------------
+
+ def cloudvimport(self, value):
+
+ # Require existing project location
+ clist = self.get_cloudv_project_list()
+ if not clist:
+ return 0 # No projects to import
+ ppath = ExistingProjectDialog(self, clist, warning="Enter name of cloudV project to import:").result
+ if not ppath:
+ return 0 # Canceled in dialog, no action.
+ pname = os.path.split(ppath)[1]
+ print("Importing CloudV project " + pname)
+
+ importnode = None
+ stdcell = None
+ netlistfile = None
+
+ # Pull process and standard cell library from the YAML file created by
+ # CloudV. NOTE: YAML file has multiple documents, so must use
+ # yaml.load_all(), not yaml.load(). If there are refinements of this
+ # process for individual build files, they will override (see further down).
+
+ # To do: Check entries for SoC builds. If there are multiple SoC builds,
+ # then create an additional drop-down selection to choose one, since only
+ # one SoC build can exist as a single Open Galaxy project. Get the name
+ # of the top-level module for the SoC. (NOTE: It may not be intended
+ # that there can be multiple SoC builds in the project, so for now retaining
+ # the existing parsing assuming default names.)
+
+ if os.path.exists(ppath + '/.ef-config/meta.yaml'):
+ print("Reading YAML file:")
+ ydicts = []
+ with open(ppath + '/.ef-config/meta.yaml', 'r') as ifile:
+ yalldata = yaml.load_all(ifile, Loader=yaml.Loader)
+ for ydict in yalldata:
+ ydicts.append(ydict)
+
+ for ydict in ydicts:
+ for yentry in ydict.values():
+ if 'process' in yentry:
+ importnode = yentry['process']
+
+ # If there is a file ().soc and a directory ().model, then pull the file
+ # ().model/().model.v, which is a chip top-level netlist.
+
+ ydicts = []
+ has_soc = False
+ save_vdir = None
+ vdirs = glob.glob(ppath + '/*')
+ for vdir in vdirs:
+ vnameparts = vdir.split('.')
+ if len(vnameparts) > 1 and vnameparts[-1] == 'soc' and os.path.isdir(vdir):
+ has_soc = True
+ if len(vnameparts) > 1 and vnameparts[-1] == 'model':
+ save_vdir = vdir
+
+ if has_soc:
+ if save_vdir:
+ vdir = save_vdir
+ print("INFO: CloudV project " + vdir + " is a full chip SoC project.")
+
+ vroot = os.path.split(vdir)[1]
+ netlistfile = vdir + '/' + vroot + '.v'
+ if os.path.exists(netlistfile):
+ print("INFO: CloudV chip top level verilog is " + netlistfile + ".")
+ else:
+ print("ERROR: Expected SoC .model directory not found.")
+
+ # Otherwise, if the project has a build/ directory and a netlist.v file,
+ # then set the foundry node accordingly.
+
+ elif os.path.exists(ppath + '/build'):
+ vfiles = glob.glob(ppath + '/build/*.v')
+ for vfile in vfiles:
+ vroot = os.path.splitext(vfile)[0]
+ if os.path.splitext(vroot)[1] == '.netlist':
+ netlistfile = ppath + '/build/' + vfile
+
+ # Pull process and standard cell library from the YAML file
+ # created by CloudV
+ # Use yaml.load_all(), not yaml.load() (see above)
+
+ if os.path.exists(ppath + '/.ef-config/meta.yaml'):
+ print("Reading YAML file:")
+ ydicts = []
+ with open(ppath + '/.ef-config/meta.yaml', 'r') as ifile:
+ yalldata = yaml.load_all(ifile, Loader=yaml.Loader)
+ for ydict in yalldata:
+ ydicts.append(ydict)
+
+ for ydict in ydicts:
+ for yentry in ydict.values():
+ if 'process' in yentry:
+ importnode = yentry['process']
+ if 'stdcell' in yentry:
+ stdcell = yentry['stdcell']
+ break
+
+ if importnode:
+ print("INFO: Project targets foundry process " + importnode + ".")
+ else:
+ print("WARNING: Project does not target any foundry process.")
+
+ newname = self.createproject(value, seedname=pname, importnode=importnode)
+ if not newname: return 0 # Canceled in dialog, no action.
+ newpath = self.projectdir + '/' + newname
+
+ result = self.install_from_cloudv(ppath, newpath, importnode, stdcell, ydicts)
+ if result == None:
+ print('Error during import.')
+ return None
+ elif result == 0:
+ return 0 # Canceled
+ else:
+ return 1 # Success
+
+ #----------------------------------------------------------------------
+ # Make a copy of a project in the design folder.
+ #----------------------------------------------------------------------
+
+ def copyproject(self, value):
+ if not value['values']:
+ print('No project selected.')
+ return
+ # Require copy-to location and confirmation
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[/ \t\n\\\><\*\?].*")
+ warning = 'Copy project ' + value['text'] + ' to new project.'
+ print('Copy project directory ' + value['values'][0])
+ newname = ''
+ copylist = []
+ elprefs = False
+ spprefs = False
+ while True:
+ copylist = CopyProjectDialog(self, warning, seed=newname).result
+ if not copylist:
+ return # Canceled, no action.
+ else:
+ newname = copylist[0]
+ elprefs = copylist[1]
+ spprefs = copylist[2]
+ newproject = self.projectdir + '/' + newname
+ if self.blacklisted(newname):
+ warning = newname + ' is not allowed for a project name.'
+ elif badrex1.match(newname):
+ warning = 'project name may not start with "."'
+ elif badrex2.match(newname):
+ warning = 'project name contains illegal characters or whitespace.'
+ elif os.path.exists(newproject):
+ warning = newname + ' is already a project name.'
+ else:
+ break
+
+ oldpath = value['values'][0]
+ oldname = os.path.split(oldpath)[1]
+ patterns = [oldname + '.log']
+ if not elprefs:
+ patterns.append('.java')
+ if not spprefs:
+ patterns.append('ngspice')
+ patterns.append('pv')
+
+ print("New project name will be " + newname)
+ try:
+ shutil.copytree(oldpath, newproject, symlinks = True,
+ ignore = shutil.ignore_patterns(*patterns))
+ except IOError as e:
+ print('Error copying files: ' + str(e))
+ return
+
+ # NOTE: Behavior is for project files to depend on "ip-name". Using
+ # the project filename as a project name is a fallback behavior. If
+ # there is a project.json file, and it defines an ip-name entry, then
+ # there is no need to make changes within the project. If there is
+ # no project.json file, then create one and set the ip-name entry to
+ # the old project name, which avoids the need to make changes within
+ # the project.
+
+ else:
+ # Check project.json
+ jsonname = newproject + '/project.json'
+ legacyname = newproject + '/' + oldname + '.json'
+ if not os.path.isfile(jsonname):
+ if os.path.isfile(legacyname):
+ jsonname = legacyname
+
+ found = False
+ if os.path.isfile(jsonname):
+ # Pull the ipname into local store (may want to do this with the
+ # datasheet as well)
+ with open(jsonname, 'r') as f:
+ datatop = json.load(f)
+ dsheet = datatop['data-sheet']
+ if 'ip-name' in dsheet:
+ found = True
+
+ if not found:
+ jData = self.create_ad_hoc_json(oldname, newproject)
+ with open(newproject + '/project.json', 'w') as ofile:
+ json.dump(jData, ofile, indent = 4)
+
+ # If ngspice and electric prefs were not copied from the source
+ # to the target, as recommended, then copy these from the
+ # skeleton repository as is done when creating a new project.
+
+ if not spprefs:
+ try:
+ os.makedirs(newproject + '/ngspice')
+ os.makedirs(newproject + '/ngspice/run')
+ os.makedirs(newproject + '/ngspice/run/.allwaves')
+ except FileExistsError:
+ pass
+ if not elprefs:
+ # Copy preferences
+ deskel = '/ef/efabless/deskel'
+ try:
+ shutil.copytree(deskel + '/dotjava', newproject + '/elec/.java', symlinks = True)
+ except IOError as e:
+ print('Error copying files: ' + e)
+
+ #----------------------------------------------------------------------
+ # Change a project IP to a different name.
+ #----------------------------------------------------------------------
+
+ def renameproject(self, value):
+ if not value['values']:
+ print('No project selected.')
+ return
+
+ # Require new project name and confirmation
+ badrex1 = re.compile("^\.")
+ badrex2 = re.compile(".*[/ \t\n\\\><\*\?].*")
+ projname = value['text']
+
+ # Find the IP name for project projname. If it has a JSON file, then
+ # read it and pull the ip-name record. If not, the fallback position
+ # is to assume that the project filename is the project name.
+
+ # Check project.json
+ projectpath = self.projectdir + '/' + projname
+ jsonname = projectpath + '/project.json'
+ legacyname = projectpath + '/' + projname + '.json'
+ if not os.path.isfile(jsonname):
+ if os.path.isfile(legacyname):
+ jsonname = legacyname
+
+ oldname = projname
+ if os.path.isfile(jsonname):
+ # Pull the ipname into local store (may want to do this with the
+ # datasheet as well)
+ with open(jsonname, 'r') as f:
+ datatop = json.load(f)
+ dsheet = datatop['data-sheet']
+ if 'ip-name' in dsheet:
+ oldname = dsheet['ip-name']
+
+ warning = 'Rename IP "' + oldname + '" for project ' + projname + ':'
+ print(warning)
+ newname = projname
+ while True:
+ try:
+ newname = ProjectNameDialog(self, warning, seed=oldname + '_1').result
+ except TypeError:
+ # TypeError occurs when "Cancel" is pressed, just handle exception.
+ return None
+ if not newname:
+ return None # Canceled, no action.
+
+ if self.blacklisted(newname):
+ warning = newname + ' is not allowed for an IP name.'
+ elif badrex1.match(newname):
+ warning = 'IP name may not start with "."'
+ elif badrex2.match(newname):
+ warning = 'IP name contains illegal characters or whitespace.'
+ else:
+ break
+
+ # Update everything, including schematic, symbol, layout, JSON file, etc.
+ print('New project IP name will be ' + newname + '.')
+ rename_project_all(projectpath, newname)
+
+ # class vars: one-time compile of regulare expressions for life of the process
+ projNameBadrex1 = re.compile("^[-.]")
+ projNameBadrex2 = re.compile(".*[][{}()!/ \t\n\\\><#$\*\?\"'|`~]")
+ importProjNameBadrex1 = re.compile(".*[.]bak$")
+
+ # centralize legal projectName check.
+ # TODO: Several code sections are not yet converted to use this.
+ # TODO: Extend to explain to the user the reason why.
+ def validProjectName(self, name):
+ return not (self.blacklisted(name) or
+ self.projNameBadrex1.match(name) or
+ self.projNameBadrex2.match(name))
+
+ #----------------------------------------------------------------------
+ # "Import As" a dir in import/ as a project. based on renameproject().
+ # addWarn is used to augment confirm-dialogue if redirected here via erroneous ImportInto
+ #----------------------------------------------------------------------
+
+ def import2project(self, importfile, addWarn=None):
+ name = os.path.split(importfile)[1]
+ projpath = self.projectdir + '/' + name
+
+ bakname = name + '.bak'
+ bakpath = self.projectdir + '/' + bakname
+ warns = []
+ if addWarn:
+ warns += [ addWarn ]
+
+ # Require new project name and confirmation
+ confirmPrompt = None # use default: I am sure I want to do this.
+ if os.path.isdir(projpath):
+ if warns:
+ warns += [ '' ] # blank line between addWarn and below two Warnings:
+ if os.path.isdir(bakpath):
+ warns += [ 'Warning: Replacing EXISTING: ' + name + ' AND ' + bakname + '!' ]
+ else:
+ warns += [ 'Warning: Replacing EXISTING: ' + name + '!' ]
+ warns += [ 'Warning: Check for & exit any Electric,magic,qflow... for above project(s)!\n' ]
+ confirmPrompt = 'I checked & exited apps and am sure I want to do this.'
+
+ warns += [ 'Confirm import-as new project: ' + name + '?' ]
+ warning = '\n'.join(warns)
+ confirm = ProtectedConfirmDialog(self, warning, confirmPrompt=confirmPrompt).result
+ if not confirm == 'okay':
+ return
+
+ print('New project name will be ' + name + '.')
+ try:
+ if os.path.isdir(projpath):
+ if os.path.isdir(bakpath):
+ print('Deleting old project: ' + bakpath);
+ shutil.rmtree(bakpath)
+ print('Moving old project ' + name + ' to ' + bakname)
+ os.rename( projpath, bakpath)
+ print("Importing as new project " + name)
+ os.rename(importfile, projpath)
+ return True
+ except IOError as e:
+ print("Error importing-as project: " + str(e))
+ return None
+
+ #----------------------------------------------------------------------
+ # Helper subroutine:
+ # Check if a project is a valid project. Return the name of the
+ # datasheet if the project has a valid one in the project top level
+ # path.
+ #----------------------------------------------------------------------
+
+ def get_datasheet_name(self, dpath):
+ if not os.path.isdir(dpath):
+ print('Error: Project is not a folder!')
+ return
+ # Check for valid datasheet name in the following order:
+ # (1) project.json (Legacy)
+ # (2) <name of directory>.json (Legacy)
+ # (3) not "datasheet.json" or "datasheet_anno.json"
+ # (4) "datasheet.json"
+ # (5) "datasheet_anno.json"
+
+ dsname = os.path.split(dpath)[1]
+ if os.path.isfile(dpath + '/project.json'):
+ datasheet = dpath + '/project.json'
+ elif os.path.isfile(dpath + '/' + dsname + '.json'):
+ datasheet = dpath + '/' + dsname + '.json'
+ else:
+ has_generic = False
+ has_generic_anno = False
+ filelist = os.listdir(dpath)
+ for file in filelist[:]:
+ if os.path.splitext(file)[1] != '.json':
+ filelist.remove(file)
+ if 'datasheet.json' in filelist:
+ has_generic = True
+ filelist.remove('datasheet.json')
+ if 'datasheet_anno.json' in filelist:
+ has_generic_anno = True
+ filelist.remove('datasheet_anno.json')
+ if len(filelist) == 1:
+ print('Trying ' + dpath + '/' + filelist[0])
+ datasheet = dpath + '/' + filelist[0]
+ elif has_generic:
+ datasheet + dpath + '/datasheet.json'
+ elif has_generic_anno:
+ datasheet + dpath + '/datasheet_anno.json'
+ else:
+ if len(filelist) > 1:
+ print('Error: Path ' + dpath + ' has ' + str(len(filelist)) +
+ ' valid datasheets.')
+ else:
+ print('Error: Path ' + dpath + ' has no valid datasheets.')
+ return None
+
+ if not os.path.isfile(datasheet):
+ print('Error: File ' + datasheet + ' not found.')
+ return None
+ else:
+ return datasheet
+
+ #----------------------------------------------------------------------
+ # Run the LVS manager
+ #----------------------------------------------------------------------
+
+ def run_lvs(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ designname = self.project_name
+ print('Run LVS on design ' + designname + ' (' + design + ')')
+ # use Popen, not run, so that application does not wait for it to exit.
+ subprocess.Popen([og_config.apps_path + '/lvs_manager.py', design, designname])
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the local characterization checker
+ #----------------------------------------------------------------------
+
+ def characterize(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ designname = self.project_name
+ datasheet = self.get_datasheet_name(design)
+ print('Characterize design ' + designname + ' (' + datasheet + ' )')
+ if datasheet:
+ # use Popen, not run, so that application does not wait for it to exit.
+ dsheetroot = os.path.splitext(datasheet)[0]
+ subprocess.Popen([og_config.apps_path + '/og_gui_characterize.py',
+ datasheet])
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the local synthesis tool (qflow)
+ #----------------------------------------------------------------------
+
+ def synthesize(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ designname = self.project_name
+ development = self.prefs['devstdcells']
+ if not designname:
+ # A project without a datasheet has no designname (which comes from
+ # the 'ip-name' record in the datasheet JSON) but can still be
+ # synthesized.
+ designname = design
+
+ # Normally there is one digital design in a project. However, full-chip
+ # designs (in particular) may have multiple sub-projects that are
+ # independently synthesized digital blocks. Find all subdirectories of
+ # the top level or subdirectories of qflow that contain a 'qflow_vars.sh'
+ # file. If there is more than one, then present a list. If there is
+ # only one but it is not in 'qflow/', then be sure to pass the actual
+ # directory name to the qflow manager.
+
+ qvlist = glob.glob(design + '/*/qflow_vars.sh')
+ qvlist.extend(glob.glob(design + '/qflow/*/qflow_vars.sh'))
+ if len(qvlist) > 1 or (len(qvlist) == 1 and not os.path.exists(design + '/qflow/qflow_vars.sh')):
+ # Generate selection menu
+ if len(qvlist) > 1:
+ clist = list(os.path.split(item)[0] for item in qvlist)
+ ppath = ExistingProjectDialog(self, clist, warning="Enter name of qflow project to open:").result
+ if not ppath:
+ return 0 # Canceled in dialog, no action.
+ else:
+ ppath = os.path.split(qvlist[0])[0]
+
+ # pname is everything in ppath after matching design:
+ pname = ppath.replace(design + '/', '')
+
+ print('Synthesize design in qflow project directory ' + pname)
+ if development:
+ subprocess.Popen([og_config.apps_path + '/qflow_manager.py',
+ design, '-development', '-subproject=' + pname])
+ else:
+ subprocess.Popen([og_config.apps_path + '/qflow_manager.py',
+ design, '-subproject=' + pname])
+ else:
+ print('Synthesize design ' + designname + ' (' + design + ')')
+ # use Popen, not run, so that application does not wait for it to exit.
+ if development:
+ subprocess.Popen([og_config.apps_path + '/qflow_manager.py',
+ design, designname, '-development'])
+ else:
+ subprocess.Popen([og_config.apps_path + '/qflow_manager.py',
+ design, designname])
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Switch between showing and hiding the import list (default hidden)
+ #----------------------------------------------------------------------
+
+ def import_toggle(self):
+ import_state = self.toppane.import_frame.import_header3.cget('text')
+ if import_state == '+':
+ self.importselect.grid(row = 11, sticky = 'news')
+ self.toppane.import_frame.import_header3.config(text='-')
+ else:
+ self.importselect.grid_forget()
+ self.toppane.import_frame.import_header3.config(text='+')
+
+ def import_open(self):
+ self.importselect.grid(row = 11, sticky = 'news')
+ self.toppane.import_frame.import_header3.config(text='-')
+
+ #----------------------------------------------------------------------
+ # Switch between showing and hiding the IP library list (default hidden)
+ #----------------------------------------------------------------------
+
+ def library_toggle(self):
+ library_state = self.toppane.library_frame.library_header3.cget('text')
+ if library_state == '+':
+ self.ipselect.grid(row = 8, sticky = 'news')
+ self.toppane.library_frame.library_header3.config(text='-')
+ else:
+ self.ipselect.grid_forget()
+ self.toppane.library_frame.library_header3.config(text='+')
+
+ def library_open(self):
+ self.ipselect.grid(row = 8, sticky = 'news')
+ self.toppane.library_frame.library_header3.config(text='-')
+
+ #----------------------------------------------------------------------
+ # Run padframe-calc (today internally invokes libreoffice, we only need cwd set to design project)
+ #----------------------------------------------------------------------
+ def padframe_calc(self):
+ value = self.projectselect.selected()
+ if value:
+ designname = self.project_name
+ self.padframe_calc_work(newname=designname)
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #------------------------------------------------------------------------
+ # Run padframe-calc (today internally invokes libreoffice, we set cwd to design project)
+ # Modelled somewhat after 'def importvgl':
+ # Prompt for an existing electric lib.
+ # Prompt for a target cellname (for both mag and electric icon).
+ # (The AS vs INTO behavior is incomplete as yet. Used so far with current-project as newname arg).
+ # newname : target project-name (INTO), or None (AS: i.e. prompt to create one).
+ # Either newname is given: we PROMPT to pick an existing elecLib;
+ # Else PROMPT for new projectName and CREATE it (and use elecLib of same name).
+ #------------------------------------------------------------------------
+ def padframe_calc_work(self, newname=None):
+ elecLib = newname
+ isnew = not newname
+ if isnew:
+ # Use create project code first to generate a valid project space.
+ newname = self.createproject(None)
+ if not newname: return 0 # Canceled in dialog, no action.
+ # print("padframe-calc in new project " + newname + ".")
+ elecLib = newname
+
+ # For life of this projectManager process, store/recall last PadFrame Settings per project
+ global project2pfd
+ try:
+ project2pfd
+ except:
+ project2pfd = {}
+ if newname not in project2pfd:
+ project2pfd[newname] = {"libEntry": None, "cellName": None}
+
+ ppath = self.projectdir + '/' + newname
+ choices = self.get_elecLib_list(newname)
+ if not choices:
+ print( "Aborted: No existing electric libraries found to write symbol into.")
+ return 0
+
+ elecLib = newname + '/elec/' + elecLib + '.delib'
+ elecLib = project2pfd[newname]["libEntry"] or elecLib
+ cellname = project2pfd[newname]["cellName"] or "padframe"
+ libAndCell = ExistingElecLibCellDialog(self, None, title="PadFrame Settings", plist=choices, descPost="of icon&layout", seedLibNm=elecLib, seedCellNm=cellname).result
+ if not libAndCell:
+ return 0 # Canceled in dialog, no action.
+
+ (elecLib, cellname) = libAndCell
+ if not cellname:
+ return 0 # empty cellname, no action.
+
+ project2pfd[newname]["libEntry"] = elecLib
+ project2pfd[newname]["cellName"] = cellname
+
+ # Isolate just electric lib name without extension. ../a/b.delib -> b
+ elecLib = os.path.splitext(os.path.split(elecLib)[-1])[0]
+ print("padframe-calc in project: %s, elecLib: %s, cellName: %s" % (newname, elecLib, cellname))
+
+ export = dict(os.environ)
+ export['EF_DESIGNDIR'] = ppath
+ subprocess.Popen(['/ef/apps/bin/padframe-calc', elecLib, cellname], cwd = ppath, env = export)
+
+ # not yet any useful return value or reporting of results here in projectManager...
+ return 1
+
+ #----------------------------------------------------------------------
+ # Run the schematic editor (tool as given by user preference)
+ #----------------------------------------------------------------------
+
+ def edit_schematic(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+
+ pdktechdir = design + self.config_path(design)+'/techdir/libs.tech'
+
+ applist = self.list_valid_schematic_editors(pdktechdir)
+
+ if len(applist)==0:
+ print("Unable to find a valid schematic editor.")
+ return
+
+ # If the preferred app is in the list, then use it.
+
+ if self.prefs['schemeditor'] in applist:
+ appused = self.prefs['schemeditor']
+ else:
+ appused = applist[0]
+
+ if appused == 'xcircuit':
+ return self.edit_schematic_with_xcircuit()
+ elif appused == 'xschem':
+ return self.edit_schematic_with_xschem()
+ elif appused == 'electric':
+ return self.edit_schematic_with_electric()
+ else:
+ print("Unknown/unsupported schematic editor " + appused + ".", file=sys.stderr)
+
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the schematic editor (electric)
+ #----------------------------------------------------------------------
+
+ def edit_schematic_with_electric(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ # self.project_name set by setcurrent. This is the true project
+ # name, as opposed to the directory name.
+ designname = self.project_name
+ print('Edit schematic ' + designname + ' (' + design + ' )')
+ # Collect libs on command-line; electric opens these in Explorer
+ libs = []
+ ellibrex = re.compile(r'^(tech_.*|ef_examples)\.[dj]elib$', re.IGNORECASE)
+
+ self.reinitElec(design)
+
+ # /elec and /.java are prerequisites for running electric
+ if not os.path.exists(design + '/elec'):
+ print("No path to electric design folder.")
+ return
+
+ if not os.path.exists(design + '/elec/.java'):
+ print("No path to electric .java folder.")
+ return
+
+ # Fix the LIBDIRS file if needed
+ #fix_libdirs(design, create = True)
+
+ # Check for legacy directory (missing .ef-config and/or .ef-config/techdir);
+ # Handle as necessary.
+
+ # don't sometimes yield pdkdir as some subdir of techdir
+ pdkdir = design + self.config_path(design) + '/techdir/'
+ if not os.path.exists(pdkdir):
+ export = dict(os.environ)
+ export['EF_DESIGNDIR'] = design
+ '''
+ p = subprocess.run(['/ef/efabless/bin/ef-config', '-sh', '-t'],
+ stdout = subprocess.PIPE, env = export)
+ config_out = p.stdout.splitlines()
+ for line in config_out:
+ setline = line.decode('utf-8').split('=')
+ if setline[0] == 'EF_TECHDIR':
+ pdkdir = re.sub("[';]", "", setline[1])
+ '''
+
+ for subpath in ('libs.tech/elec/', 'libs.ref/elec/'):
+ pdkelec = os.path.join(pdkdir, subpath)
+ if os.path.exists(pdkelec) and os.path.isdir(pdkelec):
+ # don't use os.walk(), it is recursive, wastes time
+ for entry in os.scandir(pdkelec):
+ if ellibrex.match(entry.name):
+ libs.append(entry.path)
+
+ # Locate most useful project-local elec-lib to open on electric cmd-line.
+ designroot = os.path.split(design)[1]
+ finalInDesDirLibAdded = False
+ if os.path.exists(design + '/elec/' + designname + '.jelib'):
+ libs.append(design + '/elec/' + designname + '.jelib')
+ finalInDesDirLibAdded = True
+ elif os.path.isdir(design + '/elec/' + designname + '.delib'):
+ libs.append(design + '/elec/' + designname + '.delib')
+ finalInDesDirLibAdded = True
+ else:
+ # Alternative path is the project name + .delib
+ if os.path.isdir(design + '/elec/' + designroot + '.delib'):
+ libs.append(design + '/elec/' + designroot + '.delib')
+ finalInDesDirLibAdded = True
+
+ # Finally, check for the one absolute requirement for a project,
+ # which is that there must be a symbol designname + .ic in the
+ # last directory. If not, then do a search for it.
+ if not finalInDesDirLibAdded or not os.path.isfile(libs[-1] + '/' + designname + '.ic'):
+ delibdirs = os.listdir(design + '/elec')
+ for delibdir in delibdirs:
+ if os.path.splitext(delibdir)[1] == '.delib':
+ iconfiles = os.listdir(design + '/elec/' + delibdir)
+ for iconfile in iconfiles:
+ if iconfile == designname + '.ic':
+ libs.append(design + '/elec/' + delibdir)
+ finalInDesDirLibAdded = True
+ break
+
+ # Above project-local lib-adds are all conditional on finding some lib
+ # with an expected name or content: all of which may fail.
+ # Force last item ALWAYS to be 'a path' in the project's elec/ dir.
+ # Usually it's a real library (found above). (If lib does not exist the messages
+ # window does get an error message). But the purpose is for the universal side-effect:
+ # To EVERY TIME reseed the File/OpenLibrary dialogue WorkDir to start in
+ # project's elec/ dir; avoid it starting somewhere in the PDK, which
+ # is what will happen if last actual cmd-line arg is a lib in the PDK, and
+ # about which users have complained. (Optimal fix needs electric enhancement).
+ if not finalInDesDirLibAdded:
+ libs.append(design + '/elec/' + designroot + '.delib')
+
+ # Pull last item from libs and make it a command-line argument.
+ # All other libraries become part of the EOPENARGS environment variable,
+ # and electric is called with the elecOpen.bsh script.
+ indirectlibs = libs[:-1]
+ export = dict(os.environ)
+ arguments = []
+ if indirectlibs:
+ export['EOPENARGS'] = ' '.join(indirectlibs)
+ arguments.append('-s')
+ arguments.append('/ef/efabless/lib/elec/elecOpen.bsh')
+
+ try:
+ arguments.append(libs[-1])
+ except IndexError:
+ print('Error: Electric project directories not set up correctly?')
+ else:
+ subprocess.Popen(['electric', *arguments], cwd = design + '/elec',
+ env = export)
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the schematic editor (xcircuit)
+ #----------------------------------------------------------------------
+
+ def edit_schematic_with_xcircuit(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ # self.project_name set by setcurrent. This is the true project
+ # name, as opposed to the directory name.
+ designname = self.project_name
+ print('Edit schematic ' + designname + ' (' + design + ' )')
+ xcircdirpath = design + '/xcirc'
+ pdkdir = design + self.config_path(design) + '/techdir/libs.tech/xcircuit'
+
+ # /xcirc directory is a prerequisite for running xcircuit. If it doesn't
+ # exist, create it and seed it with .xcircuitrc from the tech directory
+ if not os.path.exists(xcircdirpath):
+ os.makedirs(xcircdirpath)
+
+ # Copy xcircuit startup file from tech directory
+ hasxcircrcfile = os.path.exists(xcircdirpath + '/.xcircuitrc')
+ if not hasxcircrcfile:
+ if os.path.exists(pdkdir + '/xcircuitrc'):
+ shutil.copy(pdkdir + '/xcircuitrc', xcircdirpath + '/.xcircuitrc')
+
+ # Command line argument is the project name
+ arguments = [design + '/xcirc' + designname]
+ subprocess.Popen(['xcircuit', *arguments])
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the schematic editor (xschem)
+ #----------------------------------------------------------------------
+
+ def edit_schematic_with_xschem(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # self.project_name set by setcurrent. This is the true project
+ # name, as opposed to the directory name.
+ designname = self.project_name
+ print('Edit schematic ' + designname + ' (' + design + ' )')
+ xschemdirpath = design + '/xschem'
+
+ pdkdir = design + self.config_path(design) + '/techdir/libs.tech/xschem'
+
+
+ # /xschem directory is a prerequisite for running xschem. If it doesn't
+ # exist, create it and seed it with xschemrc from the tech directory
+ if not os.path.exists(xschemdirpath):
+ os.makedirs(xschemdirpath)
+
+ # Copy xschem startup file from tech directory
+ hasxschemrcfile = os.path.exists(xschemdirpath + '/xschemrc')
+ if not hasxschemrcfile:
+ if os.path.exists(pdkdir + '/xschemrc'):
+ shutil.copy(pdkdir + '/xschemrc', xschemdirpath + '/xschemrc')
+
+ # Command line argument is the project name. The "-r" option is recommended if there
+ # is no stdin/stdout piping.
+
+ arguments = ['-r', design + '/xschem/' + designname]
+ subprocess.Popen(['xschem', *arguments])
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the layout editor (magic or klayout)
+ #----------------------------------------------------------------------
+
+ def edit_layout(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ pdktechdir = design + self.config_path(design) + '/techdir/libs.tech'
+
+ applist = self.list_valid_layout_editors(pdktechdir)
+
+ if len(applist)==0:
+ print("Unable to find a valid layout editor.")
+ return
+
+ # If the preferred app is in the list, then use it.
+ if self.prefs['layouteditor'] in applist:
+ appused = self.prefs['layouteditor']
+ else:
+ appused = applist[0]
+
+ if appused == 'magic':
+ return self.edit_layout_with_magic()
+ elif appused == 'klayout':
+ return self.edit_layout_with_klayout()
+ elif appused == 'electric':
+ return self.edit_layout_with_electric()
+ else:
+ print("Unknown/unsupported layout editor " + appused + ".", file=sys.stderr)
+
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the magic layout editor
+ #----------------------------------------------------------------------
+
+ def edit_layout_with_magic(self):
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ designname = self.project_name
+
+ pdkdir = ''
+ pdkname = ''
+
+ if os.path.exists(design + '/.ef-config/techdir/libs.tech'):
+ pdkdir = design + '/.ef-config/techdir/libs.tech/magic/current'
+ pdkname = os.path.split(os.path.realpath(design + '/.ef-config/techdir'))[1]
+ elif os.path.exists(design + '/.config/techdir/libs.tech'):
+ pdkdir = design + '/.config/techdir/libs.tech/magic'
+ pdkname = os.path.split(os.path.realpath(design + '/.config/techdir'))[1]
+
+
+ # Check if the project has a /mag directory. Create it and
+ # put the correct .magicrc file in it, if it doesn't.
+ magdirpath = design + '/mag'
+ hasmagdir = os.path.exists(magdirpath)
+ if not hasmagdir:
+ os.makedirs(magdirpath)
+
+ hasmagrcfile = os.path.exists(magdirpath + '/.magicrc')
+ if not hasmagrcfile:
+ shutil.copy(pdkdir + '/' + pdkname + '.magicrc', magdirpath + '/.magicrc')
+
+ # Check if the .mag file exists for the project. If not,
+ # generate a dialog.
+ magpath = design + '/mag/' + designname + '.mag'
+ netpath = design + '/spi/' + designname + '.spi'
+ # print("magpath is " + magpath)
+ hasmag = os.path.exists(magpath)
+ hasnet = os.path.exists(netpath)
+ if hasmag:
+ if hasnet:
+ statbuf1 = os.stat(magpath)
+ statbuf2 = os.stat(netpath)
+ # No specific action for out-of-date layout. To be done:
+ # Check contents and determine if additional devices need to
+ # be added to the layout. This may be more trouble than it's
+ # worth.
+ #
+ # if statbuf2.st_mtime > statbuf1.st_mtime:
+ # hasmag = False
+
+ if not hasmag:
+ # Does the project have any .mag files at all? If so, the project
+ # layout may be under a name different than the project name. If
+ # so, present the user with a selectable list of layout names,
+ # with the option to start a new layout or import from schematic.
+
+ maglist = os.listdir(design + '/mag/')
+ if len(maglist) > 1:
+ # Generate selection menu
+ warning = 'No layout matches IP name ' + designname + '.'
+ maglist = list(item for item in maglist if os.path.splitext(item)[1] == '.mag')
+ clist = list(os.path.splitext(item)[0] for item in maglist)
+ ppath = EditLayoutDialog(self, clist, ppath=design,
+ pname=designname, warning=warning,
+ hasnet=hasnet).result
+ if not ppath:
+ return 0 # Canceled in dialog, no action.
+ elif ppath != '(New layout)':
+ hasmag = True
+ designname = ppath
+ elif len(maglist) == 1:
+ # Only one magic file, no selection, just bring it up.
+ designname = os.path.split(maglist[0])[1]
+ hasmag = True
+
+ if not hasmag:
+ populate = NewLayoutDialog(self, "No layout for project.").result
+ if not populate:
+ return 0 # Canceled, no action.
+ elif populate():
+ # Name of PDK deprecated. The .magicrc file in the /mag directory
+ # will load the correct PDK and specify the proper library for the
+ # low-level device namespace, which may not be the same as techdir.
+ # NOTE: netlist_to_layout script will attempt to generate a
+ # schematic netlist if one does not exist.
+
+ print('Running /ef/efabless/bin/netlist_to_layout.py ../spi/' + designname + '.spi')
+ try:
+ p = subprocess.run(['/ef/efabless/bin/netlist_to_layout.py',
+ '../spi/' + designname + '.spi'],
+ stdin = subprocess.PIPE, stdout = subprocess.PIPE,
+ stderr = subprocess.PIPE, cwd = design + '/mag')
+ if p.stderr:
+ err_string = p.stderr.splitlines()[0].decode('utf-8')
+ # Print error messages to console
+ print(err_string)
+
+ except subprocess.CalledProcessError as e:
+ print('Error running netlist_to_layout.py: ' + e.output.decode('utf-8'))
+ else:
+ if os.path.exists(design + '/mag/create_script.tcl'):
+ with open(design + '/mag/create_script.tcl', 'r') as infile:
+ magproc = subprocess.run(['/ef/apps/bin/magic',
+ '-dnull', '-noconsole', '-rcfile ',
+ pdkdir + '/' + pdkname + '.magicrc', designname],
+ stdin = infile, stdout = subprocess.PIPE,
+ stderr = subprocess.PIPE, cwd = design + '/mag')
+ print("Populated layout cell")
+ # os.remove(design + '/mag/create_script.tcl')
+ else:
+ print("No device generating script was created.", file=sys.stderr)
+
+ print('Edit layout ' + designname + ' (' + design + ' )')
+
+ magiccommand = ['magic']
+ # Select the graphics package used by magic from the profile settings.
+ if 'magic-graphics' in self.prefs:
+ magiccommand.extend(['-d', self.prefs['magic-graphics']])
+ # Check if .magicrc predates the latest and warn if so.
+ statbuf1 = os.stat(design + '/mag/.magicrc')
+ statbuf2 = os.stat(pdkdir + '/' + pdkname + '.magicrc')
+ if statbuf2.st_mtime > statbuf1.st_mtime:
+ print('NOTE: File .magicrc predates technology startup file. Using default instead.')
+ magiccommand.extend(['-rcfile', pdkdir + '/' + pdkname + '.magicrc'])
+ magiccommand.append(designname)
+
+ # Run magic and don't wait for it to finish
+ subprocess.Popen(magiccommand, cwd = design + '/mag')
+ else:
+ print("You must first select a project.", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the klayout layout editor
+ #----------------------------------------------------------------------
+
+ def edit_layout_with_klayout(self):
+ value = self.projectselect.selected()
+ print("Klayout unsupported from project manager (work in progress); run manually", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Run the electric layout editor
+ #----------------------------------------------------------------------
+
+ def edit_layout_with_electric(self):
+ value = self.projectselect.selected()
+ print("Electric layout editing unsupported from project manager (work in progress); run manually", file=sys.stderr)
+
+ #----------------------------------------------------------------------
+ # Upload design to the marketplace
+ # NOTE: This is not being called by anything. Use version in the
+ # characterization script, which can check for local results before
+ # approving (or forcing) an upload.
+ #----------------------------------------------------------------------
+
+ def upload(self):
+ '''
+ value = self.projectselect.selected()
+ if value:
+ design = value['values'][0]
+ # designname = value['text']
+ designname = self.project_name
+ print('Upload design ' + designname + ' (' + design + ' )')
+ subprocess.run(['/ef/apps/bin/withnet',
+ og_config.apps_path + '/cace_design_upload.py',
+ design, '-test'])
+ '''
+
+ #--------------------------------------------------------------------------
+ # Upload a datasheet to the marketplace (Administrative use only, for now)
+ #--------------------------------------------------------------------------
+
+ # def make_challenge(self):
+ # importp = self.cur_import
+ # print("Make a Challenge from import " + importp + "!")
+ # # subprocess.run([og_config.apps_path + '/cace_import_upload.py', importp, '-test'])
+
+ def setcurrent(self, value):
+ global currdesign
+ treeview = value.widget
+ selection = treeview.item(treeview.selection())
+ pname = selection['text']
+ #print("setcurrent returned value " + pname)
+ efmetapath = os.path.expanduser(currdesign)
+ if not os.path.exists(efmetapath):
+ os.makedirs(os.path.split(efmetapath)[0], exist_ok=True)
+ with open(efmetapath, 'w') as f:
+ f.write(pname + '\n')
+
+ # Pick up the PDK from "values", use it to find the PDK folder, determine
+ # if it has a "magic" subfolder, and enable/disable the "Edit Layout"
+ # button accordingly
+
+ svalues = selection['values']
+ pdkitems = svalues[1].split()
+ pdkdir = ''
+
+ ef_style=False
+
+ if os.path.exists(svalues[0] + '/.config'):
+ pdkdir = svalues[0] + '/.config/techdir'
+ elif os.path.exists(svalues[0] + '/.ef-config'):
+ pdkdir = svalues[0] + '/.ef-config/techdir'
+ ef_style=True
+
+ if pdkdir == '':
+ print('No pdkname found; layout editing disabled')
+ self.toppane.appbar.layout_button.config(state='disabled')
+ else:
+ try:
+ if ef_style:
+ subf = os.listdir(pdkdir + '/libs.tech/magic/current')
+ else:
+ subf = os.listdir(pdkdir + '/libs.tech/magic')
+ except:
+ print('PDK ' + pdkname + ' has no layout setup; layout editing disabled')
+ self.toppane.appbar.layout_button.config(state='disabled')
+ '''
+ svalues = selection['values'][1]
+ print('selection: '+str(selection))
+ pdkitems = svalues.split()
+ print('Contents of pdkitems: '+str(pdkitems))
+ pdkname = ''
+ if ':' in pdkitems:
+ pdkitems.remove(':')
+ if len(pdkitems) == 2:
+ # New behavior Sept. 2017, have to cope with <foundry>.<N> directories, ugh.
+ pdkdirs = os.listdir('/usr/share/pdk/')
+ #TODO: pdkdirs = os.listdir('PREFIX/pdk/')
+
+ for pdkdir in pdkdirs:
+ if pdkitems[0] == pdkdir:
+ pdkname = pdkdir
+ #TODO: PREFIX
+ if os.path.exists('/usr/share/pdk/' + pdkname + '/' + pdkitems[1]):
+ break
+ else:
+ pdkpair = pdkdir.split('.')
+ if pdkpair[0] == pdkitems[0]:
+ pdkname = pdkdir
+ #TODO: PREFIX
+ if os.path.exists('/usr/share/pdk/' + pdkname + '/' + pdkitems[1]):
+ break
+ if pdkname == '':
+ print('No pdkname found; layout editing disabled')
+ self.toppane.appbar.layout_button.config(state='disabled')
+ else:
+ try:
+ subf = os.listdir('/ef/tech/' + pdkname + '/' + pdkitems[1] + '/libs.tech/magic/current')
+ except:
+ print('PDK ' + pdkname + ' has no layout setup; layout editing disabled')
+ self.toppane.appbar.layout_button.config(state='disabled')
+ else:
+ self.toppane.appbar.layout_button.config(state='enabled')
+ else:
+ print('No PDK returned in project selection data; layout editing disabled.')
+ self.toppane.appbar.layout_button.config(state='disabled')
+ '''
+ # If the selected project directory has a JSON file and netlists in the "spi"
+ # and "testbench" folders, then enable the "Characterize" button; else disable
+ # it.
+ # NOTE: project.json is the preferred name for the datasheet
+ # file. However, the .spi file, .delib file, etc., all have the name of the
+ # project from "ip-name" in the datasheet.
+ # "<project_folder_name>.json" is the legacy name for the datasheet, deprecated.
+
+ found = False
+ ppath = selection['values'][0]
+ jsonname = ppath + '/project.json'
+ legacyname = ppath + '/' + pname + '.json'
+ if not os.path.isfile(jsonname):
+ if os.path.isfile(legacyname):
+ jsonname = legacyname
+
+ if os.path.isfile(jsonname):
+ # Pull the ipname into local store (may want to do this with the
+ # datasheet as well)
+ with open(jsonname, 'r') as f:
+ datatop = json.load(f)
+ dsheet = datatop['data-sheet']
+ ipname = dsheet['ip-name']
+ self.project_name = ipname
+ found = True
+
+ # Do not specifically prohibit opening the characterization app if
+ # there is no schematic or netlist. Otherwise the user is prevented
+ # even from seeing the electrical parameters. Let the characterization
+ # tool allow or prohibit simulation based on this.
+ # if os.path.exists(ppath + '/spi'):
+ # if os.path.isfile(ppath + '/spi/' + ipname + '.spi'):
+ # found = True
+ #
+ # if found == False and os.path.exists(ppath + '/elec'):
+ # if os.path.isdir(ppath + '/elec/' + ipname + '.delib'):
+ # if os.path.isfile(ppath + '/elec/' + ipname + '.delib/' + ipname + '.sch'):
+ # found = True
+ else:
+ # Use 'pname' as the default project name.
+ print('No characterization file ' + jsonname)
+ print('Setting project ip-name from the project folder name.')
+ self.project_name = pname
+
+ # If datasheet has physical parameters but not electrical parameters, then it's okay
+ # for it not to have a testbench directory; it's still valid. However, having
+ # neither physical nor electrical parameters means there's nothing to characterize.
+ if found and 'electrical-params' in dsheet and len(dsheet['electrical-params']) > 0:
+ if not os.path.isdir(ppath + '/testbench'):
+ print('No testbench directory for eletrical parameter simulation methods.', file=sys.stderr)
+ found = False
+ elif found and not 'physical-params' in dsheet:
+ print('Characterization file defines no characterization tests.', file=sys.stderr)
+ found = False
+ elif found and 'physical-params' in dsheet and len(dsheet['physical-params']) == 0:
+ print('Characterization file defines no characterization tests.', file=sys.stderr)
+ found = False
+
+ if found == True:
+ self.toppane.appbar.char_button.config(state='enabled')
+ else:
+ self.toppane.appbar.char_button.config(state='disabled')
+
+ # Warning: temporary hack (Tim, 1/9/2018)
+ # Pad frame generator is currently limited to the XH035 cells, so if the
+ # project PDK is not XH035, disable the pad frame button
+
+ if len(pdkitems) > 1 and pdkitems[1] == 'EFXH035B':
+ self.toppane.appbar.padframeCalc_button.config(state='enabled')
+ else:
+ self.toppane.appbar.padframeCalc_button.config(state='disabled')
+
+# main app. fyi: there's a 2nd/earlier __main__ section for splashscreen
+if __name__ == '__main__':
+ OpenGalaxyManager(root)
+ if deferLoad:
+ # Without this, mainloop may find&run very short clock-delayed events BEFORE main form display.
+ # With it 1st project-load can be scheduled using after-time=0 (needn't tune a delay like 100ms).
+ root.update_idletasks()
+ root.mainloop()
diff --git a/common/profile.py b/common/profile.py
new file mode 100755
index 0000000..83a8dc1
--- /dev/null
+++ b/common/profile.py
@@ -0,0 +1,281 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#------------------------------------------------------------
+# Profile settings window for the Open Galaxy project manager
+#
+#------------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# July 21, 2017
+# Version 0.1
+#--------------------------------------------------------
+
+import os
+import re
+import json
+import tkinter
+import subprocess
+from tkinter import ttk
+
+import og_config
+
+class Profile(tkinter.Toplevel):
+ """Open Galaxy project manager profile settings management."""
+
+ def __init__(self, parent=None, fontsize = 11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ self.protocol("WM_DELETE_WINDOW", self.close)
+ self.parent = parent
+ self.withdraw()
+ self.title('Open Galaxy Project Manager Profile Settings')
+ self.sframe = tkinter.Frame(self)
+ self.sframe.grid(column = 0, row = 0, sticky = "news")
+
+ self.sframe.stitle = ttk.Label(self.sframe,
+ style='title.TLabel', text = 'Profile')
+ self.sframe.stitle.grid(column = 0, row = 0, sticky = 'news', padx = 5, pady = 5, columnspan = 2)
+ self.sframe.sbar = ttk.Separator(self.sframe, orient='horizontal')
+ self.sframe.sbar.grid(column = 0, row = 1, sticky = 'news', padx = 5, pady = 5, columnspan = 2)
+
+ # Read profile JSON file
+ self.prefsfile = os.path.expanduser('~/.open_pdks/prefs.json')
+
+ if os.path.exists(self.prefsfile):
+ with open(self.prefsfile, 'r') as f:
+ prefs = json.load(f)
+ else:
+ prefs = {}
+
+ # Default font size preference
+
+ self.fontsize = tkinter.IntVar(self.sframe)
+ self.sframe.lfsize = ttk.Label(self.sframe, text='Font size', style='blue.TLabel', anchor='e')
+ self.sframe.fsize = ttk.Entry(self.sframe, textvariable=self.fontsize)
+ self.sframe.lfsize.grid(column = 0, row = 2, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.fsize.grid(column = 1, row = 2, sticky = 'news', padx = 5, pady = 5)
+
+ if 'fontsize' in prefs:
+ self.fontsize.set(int(prefs['fontsize']))
+ else:
+ self.fontsize.set(11)
+
+ # User name as written at the top of the project manager and characterization tools
+
+ self.username = tkinter.StringVar(self.sframe)
+ self.sframe.luser = ttk.Label(self.sframe, text='User name', style='blue.TLabel', anchor='e')
+ self.sframe.user = ttk.Entry(self.sframe, textvariable=self.username)
+ self.sframe.luser.grid(column = 0, row = 3, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.user.grid(column = 1, row = 3, sticky = 'news', padx = 5, pady = 5)
+
+ if 'username' in prefs:
+ self.username.set(prefs['username'])
+ else:
+ userid = os.environ['USER']
+ '''
+ p = subprocess.run(['/ef/apps/bin/withnet',
+ og_config.apps_path + '/og_uid_service.py', userid],
+ stdout = subprocess.PIPE)
+
+ if p.stdout:
+ uid_string = p.stdout.splitlines()[0].decode('utf-8')
+ userspec = re.findall(r'[^"\s]\S*|".+?"', uid_string)
+ if len(userspec) > 0:
+ username = userspec[0].strip('"')
+ # Note userspec[1] = UID and userspec[2] = role, useful
+ # for future applications.
+ else:
+ username = userid
+ else:
+ username = userid
+ '''
+ username=userid
+
+ self.username.set(username)
+
+ # Graphics format for magic
+ magicgraphics = ['X11', 'CAIRO', 'OPENGL']
+
+ self.maggraph = tkinter.StringVar(self.sframe)
+ self.maggraph.set(0)
+ self.sframe.lmaggraph = ttk.Label(self.sframe, text='Layout editor graphics format', style='blue.TLabel', anchor='e')
+ self.sframe.maggraph = ttk.OptionMenu(self.sframe, self.maggraph,
+ self.maggraph.get(), *magicgraphics)
+
+ self.sframe.lmaggraph.grid(column = 0, row = 4, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.maggraph.grid(column = 1, row = 4, sticky = 'news', padx = 5, pady = 5)
+
+ if 'magic-graphics' in prefs:
+ self.maggraph.set(prefs['magic-graphics'])
+ else:
+ self.maggraph.set('X11')
+
+ # Choice of layout editor
+ layouteditors = ['magic', 'klayout', 'electric']
+
+ self.layouteditor = tkinter.StringVar(self.sframe)
+ self.layouteditor.set(0)
+ self.sframe.llayouteditor = ttk.Label(self.sframe, text='Layout editor', style='blue.TLabel', anchor='e')
+ self.sframe.layouteditor = ttk.OptionMenu(self.sframe, self.layouteditor,
+ self.layouteditor.get(), *layouteditors)
+
+ self.sframe.llayouteditor.grid(column = 0, row = 5, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.layouteditor.grid(column = 1, row = 5, sticky = 'news', padx = 5, pady = 5)
+
+ if 'layout-editor' in prefs:
+ self.layouteditor.set(prefs['layout-editor'])
+ else:
+ self.layouteditor.set('magic')
+
+ # Choice of schematic editor
+ schemeditors = ['electric', 'xschem', 'xcircuit']
+
+ self.schemeditor = tkinter.StringVar(self.sframe)
+ self.schemeditor.set(0)
+ self.sframe.lschemeditor = ttk.Label(self.sframe, text='Schematic editor', style='blue.TLabel', anchor='e')
+ self.sframe.schemeditor = ttk.OptionMenu(self.sframe, self.schemeditor,
+ self.schemeditor.get(), *schemeditors)
+
+ self.sframe.lschemeditor.grid(column = 0, row = 6, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.schemeditor.grid(column = 1, row = 6, sticky = 'news', padx = 5, pady = 5)
+
+
+ if 'schemeditor' in prefs:
+ self.schemeditor.set(prefs['schemeditor'])
+ else:
+ self.schemeditor.set('electric')
+
+ # Allow the project manager to list development PDKs and create projects
+ # using them.
+
+ self.development = tkinter.IntVar(self.sframe)
+ self.sframe.ldev = ttk.Label(self.sframe, text='Create projects with development PDKs', style='blue.TLabel', anchor='e')
+ self.sframe.dev = ttk.Checkbutton(self.sframe, variable=self.development)
+ self.sframe.ldev.grid(column = 0, row = 7, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.dev.grid(column = 1, row = 7, sticky = 'news', padx = 5, pady = 5)
+
+ if 'development' in prefs:
+ self.development.set(True)
+ else:
+ self.development.set(False)
+
+ # Allow the synthesis tool to list PDK development standard cell sets
+
+ self.devstdcells = tkinter.IntVar(self.sframe)
+ self.sframe.ldev = ttk.Label(self.sframe, text='Use development libraries for digital synthesis', style='blue.TLabel', anchor='e')
+ self.sframe.dev = ttk.Checkbutton(self.sframe, variable=self.devstdcells)
+ self.sframe.ldev.grid(column = 0, row = 8, sticky = 'news', padx = 5, pady = 5)
+ self.sframe.dev.grid(column = 1, row = 8, sticky = 'news', padx = 5, pady = 5)
+
+ if 'devstdcells' in prefs:
+ self.devstdcells.set(True)
+ else:
+ self.devstdcells.set(False)
+
+ # Button bar
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 1, sticky = "news")
+
+ self.bbar.save_button = ttk.Button(self.bbar, text='Save',
+ command=self.save, style = 'normal.TButton')
+ self.bbar.save_button.grid(column=0, row=0, padx = 5)
+
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=1, row=0, padx = 5)
+
+ def save(self):
+ # Create JSON record of options and write them to prefs.json
+ with open(self.prefsfile, 'w') as f:
+ prefs = {}
+ prefs['fontsize'] = self.get_fontsize()
+ prefs['username'] = self.get_username()
+ prefs['schemeditor'] = self.get_schemeditor()
+ prefs['magic-graphics'] = self.get_magic_graphics()
+ prefs['development'] = self.get_development()
+ prefs['devstdcells'] = self.get_devstdcells()
+ json.dump(prefs, f, indent = 4)
+ # Live-updates where easy. Due read_prefs, a magic-graphics takes effect immediately.
+ self.parent.read_prefs()
+ self.parent.refreshToolTips()
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def redisplay(self):
+ pass
+
+ def get_fontsize(self):
+ # return the fontsize value
+ return self.fontsize.get()
+
+ def get_username(self):
+ # return the username
+ return self.username.get()
+
+ def get_schemeditor(self):
+ # return the state of the "keep simulation files" checkbox
+ return self.schemeditor.get()
+
+ def get_magic_graphics(self):
+ # return the format of graphics to use in Magic
+ return self.maggraph.get()
+
+ def get_development(self):
+ # return the T/F value for creating projects with development PDKs
+ return self.development.get()
+
+ def get_devstdcells(self):
+ # return the T/F value for synthesizing projects with development standard cells
+ return self.devstdcells.get()
+
+ def refresh(self):
+ self.prefsfile = os.path.expanduser('~/.open_pdks/prefs.json')
+
+ if os.path.exists(self.prefsfile):
+ with open(self.prefsfile, 'r') as f:
+ prefs = json.load(f)
+ else:
+ prefs = {}
+ if 'fontsize' in prefs:
+ self.fontsize.set(int(prefs['fontsize']))
+ else:
+ self.fontsize.set(11)
+ if 'username' in prefs:
+ self.username.set(prefs['username'])
+ else:
+ userid = os.environ['USER']
+ if 'magic-graphics' in prefs:
+ self.maggraph.set(prefs['magic-graphics'])
+ else:
+ self.maggraph.set('X11')
+ if 'layout-editor' in prefs:
+ self.layouteditor.set(prefs['layout-editor'])
+ else:
+ self.layouteditor.set('magic')
+ if 'schemeditor' in prefs:
+ self.schemeditor.set(prefs['schemeditor'])
+ else:
+ self.schemeditor.set('electric')
+ if 'development' in prefs:
+ self.development.set(True)
+ else:
+ self.development.set(False)
+ if 'devstdcells' in prefs:
+ self.devstdcells.set(True)
+ else:
+ self.devstdcells.set(False)
+
+ def close(self):
+ # pop down profile settings window
+ self.withdraw()
+
+ def open(self):
+ # pop up profile settings window
+ self.refresh()
+ self.deiconify()
+ self.lift()
diff --git a/common/rename_project.py b/common/rename_project.py
new file mode 100755
index 0000000..8c06c8b
--- /dev/null
+++ b/common/rename_project.py
@@ -0,0 +1,291 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3 -B
+#
+# rename_project.py --- Perform all tasks required for renaming a project.
+#
+# In the context of this script, "renaming" a project means changing the
+# 'ip-name' entry in the JSON file and all that that implies. To create a
+# new project with an existing ip-name is essentially a trivial process of
+# renaming the parent directory.
+#
+# Note that when a catalog entry is generated in the marketplace, the entry's
+# default name is taken from the parent directory name, not the ip-name. The
+# resulting entry name is irrelevant to most everything except how and where
+# the IP is listed in the catalog. The read-only IP version has the name of
+# the ip-name. Implies it is important that ip-name does not collide with
+# the ip-name of anything else in the marketplace catalog (but this is not
+# currently enforced).
+#
+# Modified 12/20/2018: New protocol is that the .json file is always called
+# 'project.json' and does not take the name of the parent directory. This
+# makes projects more portable.
+#
+import shutil
+import json
+import stat
+import sys
+import os
+import re
+
+"""
+ This module converts an entire project from one ip-name to another, making
+ sure that all filenames and file contents are updated.
+"""
+
+def copy_meta_with_ownership(src, dst, follow_symlinks=False):
+ # Copy file metadata using copystat() and preserve ownership through stat calls.
+ file_stat = os.stat(src)
+ owner = file_stat[stat.ST_UID]
+ group = file_stat[stat.ST_GID]
+ shutil.copystat(src, dst)
+ os.chown(dst, owner, group, follow_symlinks=follow_symlinks)
+
+def rename_json(project_path, json_file, new_name, orig_name = ''):
+ # Make sure we have the full absolute path to the project
+ fullpath = os.path.abspath(project_path)
+ # Project directory name is the last component of the full path
+ dirname = os.path.split(fullpath)[1]
+ # Get contents of the file, then recast the ip-name and rewrite it.
+ with open(json_file, 'r') as ifile:
+ datatop = json.load(ifile)
+
+ # Find ip-name and replace it
+ if 'data-sheet' in datatop:
+ dsheet = datatop['data-sheet']
+ if 'ip-name' in dsheet:
+ ipname = dsheet['ip-name']
+ if ipname == orig_name:
+ dsheet['ip-name'] = new_name
+ elif orig_name == '':
+ dsheet['ip-name'] = new_name
+ else:
+ print('Error: original name ' + orig_name + ' specified in command line,')
+ print('but ip-name is ' + ipname + ' in the datasheet.')
+ return ipname
+
+ # Change name of file. This must match the name of the directory whether
+ # or not the directory name matches the IP name.
+ # (New protocol from Dec. 2018: JSON file is now always named 'project.json')
+
+ opath = os.path.split(json_file)[0]
+ # oname = opath + '/' + dirname + '.json'
+ oname = opath + '/project.json'
+
+ with open(oname, 'w') as ofile:
+ json.dump(datatop, ofile, indent = 4)
+
+ # Remove original file. Avoid destroying the file if rename_project happens
+ # to be called with the same name for old and new.
+ if (json_file != oname):
+ copy_meta_with_ownership(json_file, oname)
+ os.remove(json_file)
+
+ # Return the original IP name
+ return ipname
+
+def rename_netlist(netlist_path, orig_name, new_name):
+ # All netlists can be regenerated on the fly, so remove any that are
+ # from orig_name
+ if not os.path.exists(netlist_path):
+ return
+
+ filelist = os.listdir(netlist_path)
+ for file in filelist:
+ rootname = os.path.splitext(file)[0]
+ fullpath = netlist_path + '/' + file
+ if rootname == orig_name:
+ if os.path.isdir(fullpath):
+ rename_netlist(fullpath, orig_name, new_name);
+ else:
+ print('Removing netlist file ' + file)
+ os.remove(fullpath)
+
+def rename_magic(magic_path, orig_name, new_name):
+ # remove old files that will get regenerated: comp.out, comp.json, any *.log
+ # move any file beginnng with orig_name to the same file with new_name
+ filelist = os.listdir(magic_path)
+
+ # All netlists can be regenerated on the fly, so remove any that are
+ # from orig_name
+ for file in filelist:
+ rootname, fext = os.path.splitext(file)
+
+ if file == 'comp.out' or file == 'comp.json':
+ os.remove(magic_path + '/' + file)
+ elif rootname == orig_name:
+ if fext == '.spc' or fext == '.spice':
+ print('Removing netlist file ' + file)
+ os.remove(magic_path + '/' + file)
+ elif fext == '.ext' or fext == '.lef':
+ os.remove(magic_path + '/' + file)
+ else:
+ shutil.move(magic_path + '/' + file, magic_path + '/' + new_name + fext)
+
+ elif fext == '.log':
+ os.remove(magic_path + '/' + file)
+
+def rename_verilog(verilog_path, orig_name, new_name):
+ filelist = os.listdir(verilog_path)
+
+ # The root module name can remain as the original (may not match orig_name
+ # anyway), but the verilog file containing it gets renamed.
+ # To be done: Any file (e.g., simulation testbenches, makefiles) referencing
+ # the file must be modified to match. These may be in subdirectories, so
+ # walk the filesystem from verilog_path.
+
+ for file in filelist:
+ rootname, fext = os.path.splitext(file)
+ if rootname == orig_name:
+ if fext == '.v' or fext == '.sv':
+ shutil.move(verilog_path + '/' + file, verilog_path + '/' + new_name + fext)
+
+def rename_electric(electric_path, orig_name, new_name):
+ # <project_name>.delib gets renamed
+
+ filelist = os.listdir(electric_path)
+ for file in filelist:
+ rootname, fext = os.path.splitext(file)
+ if rootname == orig_name:
+ shutil.move(electric_path + '/' + file, electric_path + '/' + new_name + fext)
+
+ delib_path = electric_path + '/' + new_name + '.delib'
+ if os.path.exists(delib_path):
+ filelist = os.listdir(delib_path)
+ for file in filelist:
+ if os.path.isdir(file):
+ continue
+ rootname, fext = os.path.splitext(file)
+ if rootname == orig_name:
+ # Read and do name substitution where orig_name occurs
+ # in 'H', 'C', and 'L' statements. The top-level should not appear in
+ # an 'I' (instance) statement.
+ with open(delib_path + '/' + file, 'r') as ifile:
+ contents = ifile.read()
+ contents = re.sub('H' + orig_name + '\|', 'H' + new_name + '|', contents)
+ contents = re.sub('C' + orig_name + ';', 'C' + new_name + ';', contents)
+ contents = re.sub('L' + orig_name + '\|' + orig_name, 'L' + new_name + '|' + new_name, contents)
+
+ oname = new_name + fext
+ with open(delib_path + '/' + oname, 'w') as ofile:
+ ofile.write(contents)
+
+ # Copy ownership and permissions from the old file
+ # Remove the original file
+ copy_meta_with_ownership(delib_path + '/' + file, delib_path + '/' + oname)
+ os.remove(delib_path + '/' + file)
+
+ elif rootname == 'header':
+ # Read and do name substitution where orig_name occurs in 'H' statements.
+ with open(delib_path + '/' + file, 'r') as ifile:
+ contents = ifile.read()
+ contents = re.sub('H' + orig_name + '\|', 'H' + new_name + '|', contents)
+
+ with open(delib_path + '/' + file + '.tmp', 'w') as ofile:
+ ofile.write(contents)
+
+ copy_meta_with_ownership(delib_path + '/' + file, delib_path + '/' + file + '.tmp')
+ os.remove(delib_path + '/' + file)
+ shutil.move(delib_path + '/' + file + '.tmp', delib_path + '/' + file)
+
+# Top level routine (call this one)
+
+def rename_project_all(project_path, new_name, orig_name=''):
+ # project_path is the original full path to the project in the user's design space.
+ #
+ # new_name is the new name to give to the project. It is assumed to have been
+ # already checked for uniqueness against existing names
+
+ # Original name is determined from the 'ip-name' field in the JSON file
+ # unless it is specified as a separate argument.
+
+ proj_name = os.path.split(project_path)[1]
+ json_path = project_path + '/project.json'
+
+ # The JSON file is assumed to have the name "project.json" always.
+ # However, if the project directory just got named, or if the project pre-dates
+ # December 2018, then that may not be true. If json_path does not exist, look
+ # for any JSON file containing a data-sheet entry.
+
+ if not os.path.exists(json_path):
+ json_path = ''
+ filelist = os.listdir(project_path)
+ for file in filelist:
+ if os.path.splitext(file)[1] == '.json':
+ with open(project_path + '/' + file) as ifile:
+ datatop = json.load(ifile)
+ if 'data-sheet' in datatop:
+ json_path = project_path + '/' + file
+ break
+
+ if os.path.exists(json_path):
+ if (orig_name == ''):
+ orig_name = rename_json(project_path, json_path, new_name)
+ else:
+ test_name = rename_json(project_path, json_path, new_name, orig_name)
+ if test_name != orig_name:
+ # Refusing to make a change because the orig_name didn't match ip-name
+ return
+ else:
+ if (orig_name == ''):
+ orig_name = proj_name
+
+ if orig_name == new_name:
+ print('Warning: project old and new names are the same; nothing to change.', file=sys.stderr)
+ return
+
+ # Each subroutine renames a specific group of files.
+ electric_path = project_path + '/elec'
+ if os.path.exists(electric_path):
+ rename_electric(electric_path, orig_name, new_name)
+
+ magic_path = project_path + '/mag'
+ if os.path.exists(magic_path):
+ rename_magic(magic_path, orig_name, new_name)
+
+ verilog_path = project_path + '/verilog'
+ if os.path.exists(verilog_path):
+ rename_verilog(verilog_path, orig_name, new_name)
+
+ # Maglef is deprecated in anything but readonly IP and PDKs, but
+ # handle for backwards compatibility.
+ maglef_path = project_path + '/maglef'
+ if os.path.exists(maglef_path):
+ rename_magic(maglef_path, orig_name, new_name)
+
+ netlist_path = project_path + '/spi'
+ if os.path.exists(netlist_path):
+ rename_netlist(netlist_path, orig_name, new_name)
+ rename_netlist(netlist_path + '/pex', orig_name, new_name)
+ rename_netlist(netlist_path + '/cdl', orig_name, new_name)
+ rename_netlist(netlist_path + '/lvs', orig_name, new_name)
+
+ # To be done: handle qflow directory if it exists.
+
+ print('Renamed project ' + orig_name + ' to ' + new_name + '; done.')
+
+# If called as main, run rename_project_all.
+
+if __name__ == '__main__':
+
+ # Divide up command line into options and arguments
+ options = []
+ arguments = []
+ for item in sys.argv[1:]:
+ if item.find('-', 0) == 0:
+ options.append(item)
+ else:
+ arguments.append(item)
+
+ # Need two arguments: path to directory, and new project name.
+
+ if len(arguments) < 2:
+ print("Usage: rename_project.py <project_path> <new_name> [<orig_name>]")
+ elif len(arguments) >= 2:
+ project_path = arguments[0]
+ new_name = arguments[1]
+
+ if len(arguments) == 3:
+ orig_name = arguments[2]
+ rename_project_all(project_path, new_name, orig_name)
+ else:
+ rename_project_all(project_path, new_name)
+
diff --git a/common/settings.py b/common/settings.py
new file mode 100755
index 0000000..f25c107
--- /dev/null
+++ b/common/settings.py
@@ -0,0 +1,158 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#-----------------------------------------------------------
+# Settings window for the Open Galaxy characterization tool
+#
+#-----------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# March 17, 2017
+# Version 0.1
+#--------------------------------------------------------
+
+import re
+import tkinter
+from tkinter import ttk
+
+class Settings(tkinter.Toplevel):
+ """Open Galaxy characterization tool settings management."""
+
+ def __init__(self, parent=None, fontsize = 11, callback = None, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ self.protocol("WM_DELETE_WINDOW", self.close)
+ self.parent = parent
+ self.withdraw()
+ self.title('Open Galaxy Characterization Tool Settings')
+ self.sframe = tkinter.Frame(self)
+ self.sframe.grid(column = 0, row = 0, sticky = "news")
+
+ self.sframe.stitle = ttk.Label(self.sframe,
+ style='title.TLabel', text = 'Settings')
+ self.sframe.stitle.pack(side = 'top', fill = 'x', expand = 'true')
+ self.sframe.sbar = ttk.Separator(self.sframe, orient='horizontal')
+ self.sframe.sbar.pack(side = 'top', fill = 'x', expand = 'true')
+
+ self.doforce = tkinter.IntVar(self.sframe)
+ self.doforce.set(0)
+ self.sframe.force = ttk.Checkbutton(self.sframe, text='Force netlist regeneration',
+ variable = self.doforce)
+ self.sframe.force.pack(side = 'top', anchor = 'w')
+
+ self.doedit = tkinter.IntVar(self.sframe)
+ self.doedit.set(0)
+ self.sframe.edit = ttk.Checkbutton(self.sframe, text='Allow edit of all parameters',
+ variable = self.doedit)
+ self.sframe.edit.pack(side = 'top', anchor = 'w')
+
+ self.dokeep = tkinter.IntVar(self.sframe)
+ self.dokeep.set(0)
+ self.sframe.keep = ttk.Checkbutton(self.sframe, text='Keep simulation files',
+ variable = self.dokeep)
+ self.sframe.keep.pack(side = 'top', anchor = 'w')
+
+ self.doplot = tkinter.IntVar(self.sframe)
+ self.doplot.set(1)
+ self.sframe.plot = ttk.Checkbutton(self.sframe, text='Create plot files locally',
+ variable = self.doplot)
+ self.sframe.plot.pack(side = 'top', anchor = 'w')
+
+ self.dotest = tkinter.IntVar(self.sframe)
+ self.dotest.set(0)
+ self.sframe.test = ttk.Checkbutton(self.sframe, text='Submission test-only mode',
+ variable = self.dotest)
+ self.sframe.test.pack(side = 'top', anchor = 'w')
+
+ self.doschem = tkinter.IntVar(self.sframe)
+ self.doschem.set(0)
+ self.sframe.schem = ttk.Checkbutton(self.sframe,
+ text='Force submit as schematic only',
+ variable = self.doschem)
+ self.sframe.schem.pack(side = 'top', anchor = 'w')
+
+ self.dosubmitfailed = tkinter.IntVar(self.sframe)
+ self.dosubmitfailed.set(0)
+ self.sframe.submitfailed = ttk.Checkbutton(self.sframe,
+ text='Allow submission of unsimulated/failing design',
+ variable = self.dosubmitfailed)
+ self.sframe.submitfailed.pack(side = 'top', anchor = 'w')
+
+ self.dolog = tkinter.IntVar(self.sframe)
+ self.dolog.set(0)
+ self.sframe.log = ttk.Checkbutton(self.sframe, text='Log simulation output',
+ variable = self.dolog)
+ self.sframe.log.pack(side = 'top', anchor = 'w')
+
+ self.loadsave = tkinter.IntVar(self.sframe)
+ self.loadsave.set(0)
+ self.sframe.loadsave = ttk.Checkbutton(self.sframe, text='Unlimited loads/saves',
+ variable = self.loadsave)
+ self.sframe.loadsave.pack(side = 'top', anchor = 'w')
+
+ # self.sframe.sdisplay.sopts(side = 'top', fill = 'x', expand = 'true')
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 1, sticky = "news")
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=0, row=0, padx = 5)
+
+ # Callback-on-close
+ self.callback = callback
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def redisplay(self):
+ pass
+
+ def get_force(self):
+ # return the state of the "force netlist regeneration" checkbox
+ return False if self.doforce.get() == 0 else True
+
+ def get_edit(self):
+ # return the state of the "edit all parameters" checkbox
+ return False if self.doedit.get() == 0 else True
+
+ def get_keep(self):
+ # return the state of the "keep simulation files" checkbox
+ return False if self.dokeep.get() == 0 else True
+
+ def get_plot(self):
+ # return the state of the "create plot files locally" checkbox
+ return False if self.doplot.get() == 0 else True
+
+ def get_test(self):
+ # return the state of the "submit test mode" checkbox
+ return False if self.dotest.get() == 0 else True
+
+ def get_schem(self):
+ # return the state of the "submit as schematic" checkbox
+ return False if self.doschem.get() == 0 else True
+
+ def get_submitfailed(self):
+ # return the state of the "submit failed" checkbox
+ return False if self.dosubmitfailed.get() == 0 else True
+
+ def get_log(self):
+ # return the state of the "log simulation output" checkbox
+ return False if self.dolog.get() == 0 else True
+
+ def get_loadsave(self):
+ # return the state of the "unlimited loads/saves" checkbox
+ return False if self.loadsave.get() == 0 else True
+
+ def close(self):
+ # pop down settings window
+ self.withdraw()
+ # execute the callback function, if one is given
+ if self.callback:
+ self.callback()
+
+ def open(self):
+ # pop up settings window
+ self.deiconify()
+ self.lift()
diff --git a/common/simhints.py b/common/simhints.py
new file mode 100755
index 0000000..3dbe48f
--- /dev/null
+++ b/common/simhints.py
@@ -0,0 +1,372 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#-----------------------------------------------------------
+# Simulation hints management for the Open Galaxy
+# characterization tool
+#-----------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# March 21, 2017
+# Version 0.1
+#--------------------------------------------------------
+
+import re
+import tkinter
+from tkinter import ttk
+
+class SimHints(tkinter.Toplevel):
+ """Characterization tool simulation hints management."""
+
+ def __init__(self, parent=None, fontsize = 11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+ self.protocol("WM_DELETE_WINDOW", self.close)
+ self.parent = parent
+ self.withdraw()
+ self.title('Simulation hints management')
+ self.sframe = tkinter.Frame(self)
+ self.sframe.grid(column = 0, row = 0, sticky = "news")
+
+ self.sframe.stitle = ttk.Label(self.sframe,
+ style='title.TLabel', text = 'Hints')
+ self.sframe.stitle.pack(side = 'top', fill = 'x', expand = 'true')
+ self.sframe.sbar = ttk.Separator(self.sframe, orient='horizontal')
+ self.sframe.sbar.pack(side = 'top', fill = 'x', expand = 'true')
+
+ self.sframe.curparam = ttk.Label(self.sframe,
+ style='title.TLabel', text = 'None')
+ self.sframe.curparam.pack(side = 'top', fill = 'x', expand = 'true')
+ self.sframe.sbar2 = ttk.Separator(self.sframe, orient='horizontal')
+ self.sframe.sbar2.pack(side = 'top', fill = 'x', expand = 'true')
+
+ # Keep current parameter
+ self.param = None
+
+ #--------------------------------------------------------
+ # reltol option
+ #--------------------------------------------------------
+
+ self.sframe.do_reltol = tkinter.Frame(self.sframe)
+ self.sframe.do_reltol.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_reltol = tkinter.IntVar(self.sframe)
+ self.do_reltol.set(0)
+ self.sframe.do_reltol.enable = ttk.Checkbutton(self.sframe.do_reltol,
+ text='Set reltol', variable = self.do_reltol,
+ command=self.apply_reltol)
+ self.sframe.do_reltol.value = ttk.Entry(self.sframe.do_reltol)
+ self.sframe.do_reltol.value.delete(0, 'end')
+ self.sframe.do_reltol.value.insert(0, '1.0E-3')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_reltol.value.bind('<Return>', self.apply_reltol)
+ self.sframe.do_reltol.value.bind('<Leave>', self.apply_reltol)
+ self.sframe.do_reltol.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_reltol.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+ # rshunt option
+ #--------------------------------------------------------
+
+ self.sframe.do_rshunt = tkinter.Frame(self.sframe)
+ self.sframe.do_rshunt.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_rshunt = tkinter.IntVar(self.sframe)
+ self.do_rshunt.set(0)
+ self.sframe.do_rshunt.enable = ttk.Checkbutton(self.sframe.do_rshunt,
+ text='Use shunt resistance', variable = self.do_rshunt,
+ command=self.apply_rshunt)
+ self.sframe.do_rshunt.value = ttk.Entry(self.sframe.do_rshunt)
+ self.sframe.do_rshunt.value.delete(0, 'end')
+ self.sframe.do_rshunt.value.insert(0, '1.0E20')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_rshunt.value.bind('<Return>', self.apply_rshunt)
+ self.sframe.do_rshunt.value.bind('<Leave>', self.apply_rshunt)
+ self.sframe.do_rshunt.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_rshunt.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+ # nodeset option
+ #--------------------------------------------------------
+
+ self.sframe.do_nodeset = tkinter.Frame(self.sframe)
+ self.sframe.do_nodeset.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_nodeset = tkinter.IntVar(self.sframe)
+ self.do_nodeset.set(0)
+ self.sframe.do_nodeset.enable = ttk.Checkbutton(self.sframe.do_nodeset,
+ text='Use nodeset', variable = self.do_nodeset,
+ command=self.apply_nodeset)
+ self.sframe.do_nodeset.value = ttk.Entry(self.sframe.do_nodeset)
+ self.sframe.do_nodeset.value.delete(0, 'end')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_nodeset.value.bind('<Return>', self.apply_nodeset)
+ self.sframe.do_nodeset.value.bind('<Leave>', self.apply_nodeset)
+ self.sframe.do_nodeset.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_nodeset.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+ # itl1 option
+ #--------------------------------------------------------
+
+ self.sframe.do_itl1 = tkinter.Frame(self.sframe)
+ self.sframe.do_itl1.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_itl1 = tkinter.IntVar(self.sframe)
+ self.do_itl1.set(0)
+ self.sframe.do_itl1.enable = ttk.Checkbutton(self.sframe.do_itl1,
+ text='Set gmin iterations', variable = self.do_itl1,
+ command=self.apply_itl1)
+ self.sframe.do_itl1.value = ttk.Entry(self.sframe.do_itl1)
+ self.sframe.do_itl1.value.delete(0, 'end')
+ self.sframe.do_itl1.value.insert(0, '100')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_itl1.value.bind('<Return>', self.apply_itl1)
+ self.sframe.do_itl1.value.bind('<Leave>', self.apply_itl1)
+ self.sframe.do_itl1.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_itl1.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+ # include option
+ # Disabled for now. This needs to limit the selection of
+ # files to include to a drop-down selection list.
+ #--------------------------------------------------------
+ self.sframe.do_include = tkinter.Frame(self.sframe)
+ # self.sframe.do_include.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_include = tkinter.IntVar(self.sframe)
+ self.do_include.set(0)
+ self.sframe.do_include.enable = ttk.Checkbutton(self.sframe.do_include,
+ text='Include netlist', variable = self.do_include,
+ command=self.apply_include)
+ self.sframe.do_include.value = ttk.Entry(self.sframe.do_include)
+ self.sframe.do_include.value.delete(0, 'end')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_include.value.bind('<Return>', self.apply_include)
+ self.sframe.do_include.value.bind('<Leave>', self.apply_include)
+ self.sframe.do_include.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_include.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+ # alternative method option
+ #--------------------------------------------------------
+
+ self.sframe.do_method = tkinter.Frame(self.sframe)
+ self.sframe.do_method.pack(side = 'top', anchor = 'w', fill = 'x', expand = 'true')
+
+ self.do_method = tkinter.IntVar(self.sframe)
+ self.do_method.set(0)
+ self.sframe.do_method.enable = ttk.Checkbutton(self.sframe.do_method,
+ text='Use alternate method', variable = self.do_method,
+ command=self.apply_method)
+ self.sframe.do_method.value = ttk.Entry(self.sframe.do_method)
+ self.sframe.do_method.value.delete(0, 'end')
+ self.sframe.do_method.value.insert(0, '0')
+ # Return or leave window applies hint, if enabled
+ self.sframe.do_method.value.bind('<Return>', self.apply_method)
+ self.sframe.do_method.value.bind('<Leave>', self.apply_method)
+ self.sframe.do_method.enable.pack(side = 'left', anchor = 'w')
+ self.sframe.do_method.value.pack(side = 'left', anchor = 'w', fill='x', expand='true')
+
+ #--------------------------------------------------------
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 1, sticky = "news")
+
+ self.bbar.apply_button = ttk.Button(self.bbar, text='Apply',
+ command=self.apply_hints, style = 'normal.TButton')
+ self.bbar.apply_button.grid(column=0, row=0, padx = 5)
+
+ self.bbar.close_button = ttk.Button(self.bbar, text='Close',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.close_button.grid(column=1, row=0, padx = 5)
+
+ def apply_reltol(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_reltol = self.do_reltol.get()
+ if have_reltol:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['reltol'] = self.sframe.do_reltol.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('reltol', None)
+
+ def apply_rshunt(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_rshunt = self.do_rshunt.get()
+ if have_rshunt:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['rshunt'] = self.sframe.do_rshunt.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('rshunt', None)
+
+ def apply_itl1(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_itl1 = self.do_itl1.get()
+ if have_itl1:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['itl1'] = self.sframe.do_itl1.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('itl1', None)
+
+
+ def apply_nodeset(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_nodeset = self.do_nodeset.get()
+ if have_nodeset:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['nodeset'] = self.sframe.do_nodeset.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('nodeset', None)
+
+ def apply_include(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_include = self.do_include.get()
+ if have_include:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['include'] = self.sframe.do_include.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('include', None)
+
+ def apply_method(self, value = ''):
+ # "value" is passed from binding callback but is not used
+ have_method = self.do_method.get()
+ if have_method:
+ if not 'hints' in self.param:
+ phints = {}
+ else:
+ phints = self.param['hints']
+ phints['method'] = self.sframe.do_method.value.get()
+ self.param['hints'] = phints
+ else:
+ if 'hints' in self.param:
+ self.param['hints'].pop('method', None)
+
+ def apply_hints(self, value = ''):
+ self.apply_reltol(value)
+ self.apply_rshunt(value)
+ self.apply_itl1(value)
+ self.apply_nodeset(value)
+ self.apply_include(value)
+ self.apply_method(value)
+
+ # Update 'Simulate' button in characterization tool with a mark
+ # indicating hints are present. Also remove the hints record
+ # from the parameter dictionary if it is empty.
+ if 'method' in self.param:
+ if 'hints' in self.param:
+ if self.param['hints'] == {}:
+ self.param.pop('hints', None)
+ simtext = 'Simulate'
+ else:
+ simtext = '\u2022Simulate'
+ else:
+ simtext = 'Simulate'
+ self.simbutton.config(text=simtext)
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def redisplay(self):
+ pass
+
+ def populate(self, param, simbutton = False):
+ if 'display' in param:
+ self.sframe.curparam.config(text=param['display'])
+ else:
+ self.sframe.curparam.config(text=param['method'])
+
+ # Set the current parameter
+ self.param = param
+
+ # Remember the simulate button so we can mark or unmark hints
+ self.simbutton = simbutton
+
+ # Regenerate view and update for the indicated param.
+ if 'hints' in param:
+ phints = param['hints']
+ if 'reltol' in phints:
+ # (1) Reltol adjustment
+ self.do_reltol.set(1)
+ self.sframe.do_reltol.value.delete(0, 'end')
+ self.sframe.do_reltol.value.insert(0, phints['reltol'])
+ else:
+ self.do_reltol.set(0)
+ if 'rshunt' in phints:
+ # (2) Gshunt option
+ self.do_rshunt.set(1)
+ self.sframe.do_rshunt.value.delete(0, 'end')
+ self.sframe.do_rshunt.value.insert(0, phints['rshunt'])
+ else:
+ self.do_rshunt.set(0)
+ if 'nodeset' in phints:
+ # (3) Nodeset
+ self.do_nodeset.set(1)
+ self.sframe.do_nodeset.value.delete(0, 'end')
+ self.sframe.do_nodeset.value.insert(0, phints['nodeset'])
+ else:
+ self.do_nodeset.set(0)
+ if 'itl1' in phints:
+ # (4) Gmin iterations (ITL1)
+ self.do_itl1.set(1)
+ self.sframe.do_itl1.value.delete(0, 'end')
+ self.sframe.do_itl1.value.insert(0, phints['itl1'])
+ else:
+ self.do_itl1.set(0)
+ if 'include' in phints:
+ # (5) Include library (from dropdown list)
+ self.do_include.set(1)
+ self.sframe.do_include.value.delete(0, 'end')
+ self.sframe.do_include.value.insert(0, phints['include'])
+ else:
+ self.do_include.set(0)
+ if 'method' in phints:
+ # (6) Alternative method (where indicated)
+ self.do_method.set(1)
+ self.sframe.do_method.value.delete(0, 'end')
+ self.sframe.do_method.value.insert(0, phints['method'])
+ else:
+ self.do_method.set(0)
+ else:
+ # No hints, so set everything to unchecked
+ self.do_reltol.set(0)
+ self.do_rshunt.set(0)
+ self.do_nodeset.set(0)
+ self.do_itl1.set(0)
+ self.do_include.set(0)
+ self.do_method.set(0)
+
+ def close(self):
+ # pop down settings window
+ self.withdraw()
+
+ def open(self):
+ # pop up settings window
+ self.deiconify()
+ self.lift()
diff --git a/common/symbolbuilder.py b/common/symbolbuilder.py
new file mode 100755
index 0000000..7a38781
--- /dev/null
+++ b/common/symbolbuilder.py
@@ -0,0 +1,103 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+#--------------------------------------------------------
+# Symbol Builder for the Open Galaxy project manager
+#
+#--------------------------------------------------------
+# Written by Tim Edwards
+# efabless, inc.
+# September 21, 2016
+# Version 0.1
+#--------------------------------------------------------
+
+import tkinter
+from tkinter import ttk
+
+class SymbolBuilder(tkinter.Toplevel):
+ """Open Galaxy symbol builder."""
+
+ def __init__(self, parent = None, pinlist = None, fontsize = 11, *args, **kwargs):
+ '''See the __init__ for Tkinter.Toplevel.'''
+ tkinter.Toplevel.__init__(self, parent, *args, **kwargs)
+ self.transient(parent)
+ self.parent = parent
+
+ s = ttk.Style()
+ s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised')
+
+ self.title('Open Galaxy Symbol Builder')
+ self.pframe = tkinter.Frame(self)
+ self.pframe.grid(column = 0, row = 0, sticky = "news")
+
+ self.pframe.pindisplay = tkinter.Text(self.pframe)
+ self.pframe.pindisplay.pack(side = 'left', fill = 'y')
+ # Add scrollbar to symbol builder window
+ self.pframe.scrollbar = ttk.Scrollbar(self.pframe)
+ self.pframe.scrollbar.pack(side='right', fill='y')
+ # attach symbol builder window to scrollbar
+ self.pframe.pindisplay.config(yscrollcommand = self.pframe.scrollbar.set)
+ self.pframe.scrollbar.config(command = self.pframe.pindisplay.yview)
+
+ self.bbar = ttk.Frame(self)
+ self.bbar.grid(column = 0, row = 1, sticky = "news")
+ self.bbar.cancel_button = ttk.Button(self.bbar, text='Cancel',
+ command=self.close, style = 'normal.TButton')
+ self.bbar.cancel_button.grid(column=0, row=0, padx = 5)
+
+ self.bbar.okay_button = ttk.Button(self.bbar, text='Okay',
+ command=self.okay, style = 'normal.TButton')
+ self.bbar.okay_button.grid(column=1, row=0, padx = 5)
+
+ typelist = ['input', 'output', 'inout', 'power', 'gnd']
+ self.pinlist = []
+ self.pvar = []
+ self.result = None
+
+ # Each pinlist entry is in the form <pin_name>:<type>
+ # where <type> is one of "input", "output", "inout",
+ # "power", or "gnd".
+
+ n = 0
+ for pin in pinlist:
+ p = pin.split(':')
+ pinname = p[0]
+ pintype = p[1]
+
+ newpvar = tkinter.StringVar(self.pframe.pindisplay)
+ self.pinlist.append(pinname)
+ self.pvar.append(newpvar)
+ newpvar.set(pintype)
+ ttk.Label(self.pframe.pindisplay, text=pinname,
+ style = 'normal.TButton').grid(row = n,
+ column = 0, padx = 5, sticky = 'nsew')
+ ttk.OptionMenu(self.pframe.pindisplay, newpvar,
+ pintype, *typelist, style = 'blue.TMenubutton').grid(row = n,
+ column = 1, padx = 5, sticky = 'nswe')
+ n += 1
+
+ self.grab_set()
+ self.initial_focus = self
+ self.protocol("WM_DELETE_WINDOW", self.close)
+ self.initial_focus.focus_set()
+ self.wait_window(self)
+
+ def grid_configure(self, padx, pady):
+ pass
+
+ def okay(self):
+ # return the new pin list.
+ pinlist = []
+ n = 0
+ for p in self.pinlist:
+ pinlist.append(p + ':' + str(self.pvar[n].get()))
+ n += 1
+
+ self.withdraw()
+ self.update_idletasks()
+ self.result = pinlist
+ self.close()
+
+ def close(self):
+ # remove symbol builder window
+ self.parent.focus_set()
+ self.destroy()
diff --git a/common/tksimpledialog.py b/common/tksimpledialog.py
index 4734291..f11bbfa 100755
--- a/common/tksimpledialog.py
+++ b/common/tksimpledialog.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/ef/efabless/opengalaxy/venv/bin/python3
#
# Dialog class for tkinter
diff --git a/common/tooltip.py b/common/tooltip.py
new file mode 100755
index 0000000..4423bb9
--- /dev/null
+++ b/common/tooltip.py
@@ -0,0 +1,158 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+'''Michael Lange <klappnase (at) freakmail (dot) de>
+The ToolTip class provides a flexible tooltip widget for tkinter; it is based on IDLE's ToolTip
+module which unfortunately seems to be broken (at least the version I saw).
+INITIALIZATION OPTIONS:
+anchor : where the text should be positioned inside the widget, must be on of "n", "s", "e", "w", "nw" and so on;
+ default is "center"
+bd : borderwidth of the widget; default is 1 (NOTE: don't use "borderwidth" here)
+bg : background color to use for the widget; default is "lightyellow" (NOTE: don't use "background")
+delay : time in ms that it takes for the widget to appear on the screen when the mouse pointer has
+ entered the parent widget; default is 1500
+fg : foreground (i.e. text) color to use; default is "black" (NOTE: don't use "foreground")
+follow_mouse : if set to 1 the tooltip will follow the mouse pointer instead of being displayed
+ outside of the parent widget; this may be useful if you want to use tooltips for
+ large widgets like listboxes or canvases; default is 0
+font : font to use for the widget; default is system specific
+justify : how multiple lines of text will be aligned, must be "left", "right" or "center"; default is "left"
+padx : extra space added to the left and right within the widget; default is 4
+pady : extra space above and below the text; default is 2
+relief : one of "flat", "ridge", "groove", "raised", "sunken" or "solid"; default is "solid"
+state : must be "normal" or "disabled"; if set to "disabled" the tooltip will not appear; default is "normal"
+text : the text that is displayed inside the widget
+textvariable : if set to an instance of tkinter.StringVar() the variable's value will be used as text for the widget
+width : width of the widget; the default is 0, which means that "wraplength" will be used to limit the widgets width
+wraplength : limits the number of characters in each line; default is 150
+
+WIDGET METHODS:
+configure(**opts) : change one or more of the widget's options as described above; the changes will take effect the
+ next time the tooltip shows up; NOTE: follow_mouse cannot be changed after widget initialization
+
+Other widget methods that might be useful if you want to subclass ToolTip:
+enter() : callback when the mouse pointer enters the parent widget
+leave() : called when the mouse pointer leaves the parent widget
+motion() : is called when the mouse pointer moves inside the parent widget if follow_mouse is set to 1 and the
+ tooltip has shown up to continually update the coordinates of the tooltip window
+coords() : calculates the screen coordinates of the tooltip window
+create_contents() : creates the contents of the tooltip window (by default a tkinter.Label)
+'''
+# Ideas gleaned from PySol
+
+import tkinter
+
+class ToolTip:
+ def __init__(self, master, text='Your text here', delay=1500, **opts):
+ self.master = master
+ self._opts = {'anchor':'center', 'bd':1, 'bg':'lightyellow', 'delay':delay, 'fg':'black',\
+ 'follow_mouse':0, 'font':None, 'justify':'left', 'padx':4, 'pady':2,\
+ 'relief':'solid', 'state':'normal', 'text':text, 'textvariable':None,\
+ 'width':0, 'wraplength':150}
+ self.configure(**opts)
+ self._tipwindow = None
+ self._id = None
+ self._id1 = self.master.bind("<Enter>", self.enter, '+')
+ self._id2 = self.master.bind("<Leave>", self.leave, '+')
+ self._id3 = self.master.bind("<ButtonPress>", self.leave, '+')
+ self._follow_mouse = 0
+ if self._opts['follow_mouse']:
+ self._id4 = self.master.bind("<Motion>", self.motion, '+')
+ self._follow_mouse = 1
+
+ def configure(self, **opts):
+ for key in opts:
+ if key in self._opts:
+ self._opts[key] = opts[key]
+ else:
+ KeyError = 'KeyError: Unknown option: "%s"' %key
+ raise KeyError
+
+ ##----these methods handle the callbacks on "<Enter>", "<Leave>" and "<Motion>"---------------##
+ ##----events on the parent widget; override them if you want to change the widget's behavior--##
+
+ def enter(self, event=None):
+ self._schedule()
+
+ def leave(self, event=None):
+ self._unschedule()
+ self._hide()
+
+ def motion(self, event=None):
+ if self._tipwindow and self._follow_mouse:
+ x, y = self.coords()
+ self._tipwindow.wm_geometry("+%d+%d" % (x, y))
+
+ ##------the methods that do the work:---------------------------------------------------------##
+
+ def _schedule(self):
+ self._unschedule()
+ if self._opts['state'] == 'disabled':
+ return
+ self._id = self.master.after(self._opts['delay'], self._show)
+
+ def _unschedule(self):
+ id = self._id
+ self._id = None
+ if id:
+ self.master.after_cancel(id)
+
+ def _show(self):
+ if self._opts['state'] == 'disabled':
+ self._unschedule()
+ return
+ if not self._tipwindow:
+ self._tipwindow = tw = tkinter.Toplevel(self.master)
+ # hide the window until we know the geometry
+ tw.withdraw()
+ tw.wm_overrideredirect(1)
+
+ if tw.tk.call("tk", "windowingsystem") == 'aqua':
+ tw.tk.call("::tk::unsupported::MacWindowStyle", "style", tw._w, "help", "none")
+
+ self.create_contents()
+ tw.update_idletasks()
+ x, y = self.coords()
+ tw.wm_geometry("+%d+%d" % (x, y))
+ tw.deiconify()
+ tw.lift()
+
+ def _hide(self):
+ tw = self._tipwindow
+ self._tipwindow = None
+ if tw:
+ tw.destroy()
+
+ ##----these methods might be overridden in derived classes:----------------------------------##
+
+ def coords(self):
+ # The tip window must be completely outside the master widget;
+ # otherwise when the mouse enters the tip window we get
+ # a leave event and it disappears, and then we get an enter
+ # event and it reappears, and so on forever :-(
+ # or we take care that the mouse pointer is always outside the tipwindow :-)
+ tw = self._tipwindow
+ twx, twy = tw.winfo_reqwidth(), tw.winfo_reqheight()
+ w, h = tw.winfo_screenwidth(), tw.winfo_screenheight()
+ # calculate the y coordinate:
+ if self._follow_mouse:
+ y = tw.winfo_pointery() + 20
+ # make sure the tipwindow is never outside the screen:
+ if y + twy > h:
+ y = y - twy - 30
+ else:
+ y = self.master.winfo_rooty() + self.master.winfo_height() + 3
+ if y + twy > h:
+ y = self.master.winfo_rooty() - twy - 3
+ # we can use the same x coord in both cases:
+ x = tw.winfo_pointerx() - twx / 2
+ if x < 0:
+ x = 0
+ elif x + twx > w:
+ x = w - twx
+ return x, y
+
+ def create_contents(self):
+ opts = self._opts.copy()
+ for opt in ('delay', 'follow_mouse', 'state'):
+ del opts[opt]
+ label = tkinter.Label(self._tipwindow, **opts)
+ label.pack()
diff --git a/common/treeviewchoice.py b/common/treeviewchoice.py
new file mode 100755
index 0000000..dba0f26
--- /dev/null
+++ b/common/treeviewchoice.py
@@ -0,0 +1,227 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+# Simple ttk treeview with scrollbar and select button
+
+import os
+import json
+
+import tkinter
+from tkinter import ttk
+import natsort
+#------------------------------------------------------
+# Tree view used as a multi-column list box
+#------------------------------------------------------
+
+class TreeViewChoice(ttk.Frame):
+ def __init__(self, parent, fontsize=11, markDir=False, deferLoad=False, selectVal=None, natSort=False, *args, **kwargs):
+ ttk.Frame.__init__(self, parent, *args, **kwargs)
+ s = ttk.Style()
+ s.configure('normal.TLabel', font=('Helvetica', fontsize))
+ s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold'))
+ s.configure('normal.TButton', font=('Helvetica', fontsize),
+ border = 3, relief = 'raised')
+ s.configure('Treeview.Heading', font=('Helvetica', fontsize, 'bold'))
+ s.configure('Treeview.Column', font=('Helvetica', fontsize))
+ self.markDir = markDir
+ self.initSelected = selectVal
+ self.natSort = natSort
+ self.emptyMessage1 = '(no items)'
+ self.emptyMessage = '(loading...)' if deferLoad else self.emptyMessage1
+
+ # Last item is a list of 2-item lists, each containing the name of a button
+ # to place along the button bar at the bottom, and a callback function to
+ # run when the button is pressed.
+
+ def populate(self, title, itemlist=[], buttons=[], height=10, columns=[0],
+ versioning=False):
+ self.itemlist = itemlist[:]
+
+ treeFrame = ttk.Frame(self)
+ treeFrame.pack(side='top', padx=5, pady=5, fill='both', expand='true')
+
+ scrollBar = ttk.Scrollbar(treeFrame)
+ scrollBar.pack(side='right', fill='y')
+ self.treeView = ttk.Treeview(treeFrame, selectmode='browse', columns=columns, height=height)
+ self.treeView.pack(side='left', fill='both', expand='true')
+ scrollBar.config(command=self.treeView.yview)
+ self.treeView.config(yscrollcommand=scrollBar.set)
+ self.treeView.heading('#0', text=title, anchor='w')
+ buttonFrame = ttk.Frame(self)
+ buttonFrame.pack(side='bottom', fill='x')
+
+ self.treeView.tag_configure('odd',background='white',foreground='black')
+ self.treeView.tag_configure('even',background='gray90',foreground='black')
+ self.treeView.tag_configure('select',background='darkslategray',foreground='white')
+
+ self.func_buttons = []
+ for button in buttons:
+ func = button[2]
+ # Each func_buttons entry is a list of two items; first is the
+ # button widget, and the second is a boolean that is True if the
+ # button is to be present always, False if the button is only
+ # present when there are entries in the itemlist.
+ self.func_buttons.append([ttk.Button(buttonFrame, text=button[0],
+ style = 'normal.TButton',
+ command = lambda func=func: self.func_callback(func)),
+ button[1]])
+
+ self.selectcallback = None
+ self.lastselected = None
+ self.lasttag = None
+ self.treeView.bind('<<TreeviewSelect>>', self.retag)
+ self.repopulate(itemlist, versioning)
+
+ def get_button(self, index):
+ if index >= 0 and index < len(self.func_buttons):
+ return self.func_buttons[index][0]
+ else:
+ return None
+
+ def retag(self, value):
+ treeview = value.widget
+ try:
+ selection = treeview.selection()[0]
+ oldtag = self.treeView.item(selection, 'tag')[0]
+ except IndexError:
+ # No items in view; can't select the "(no items)" line.
+ return
+
+ self.treeView.item(selection, tag='selected')
+ if self.lastselected:
+ try:
+ self.treeView.item(self.lastselected, tag=self.lasttag)
+ except:
+ # Last selected item got deleted. Ignore this.
+ pass
+ if self.selectcallback:
+ self.selectcallback(value)
+ self.lastselected = selection
+ self.lasttag = oldtag
+
+ def repopulate(self, itemlist=[], versioning=False):
+
+ # Remove all children of treeview
+ self.treeView.delete(*self.treeView.get_children())
+
+ if self.natSort:
+ self.itemlist = natsort.natsorted( itemlist,
+ alg=natsort.ns.INT |
+ natsort.ns.UNSIGNED |
+ natsort.ns.IGNORECASE )
+ else:
+ self.itemlist = itemlist[:]
+ self.itemlist.sort()
+
+ mode = 'even'
+ for item in self.itemlist:
+ # Special handling of JSON files. The following reads a JSON file and
+ # finds key 'ip-name' in dictionary 'data-sheet', if such exists. If
+ # not, it looks for key 'project' in the top level. Failing that, it
+ # lists the name of the JSON file (which is probably an ungainly hash
+ # name).
+
+ fileext = os.path.splitext(item)
+ if fileext[1] == '.json':
+ # Read contents of JSON file
+ with open(item, 'r') as f:
+ try:
+ datatop = json.load(f)
+ except json.decoder.JSONDecodeError:
+ name = os.path.split(item)[1]
+ else:
+ name = []
+ if 'data-sheet' in datatop:
+ dsheet = datatop['data-sheet']
+ if 'ip-name' in dsheet:
+ name = dsheet['ip-name']
+ if not name and 'project' in datatop:
+ name = datatop['project']
+ if not name:
+ name = os.path.split(item)[1]
+ elif versioning == True:
+ # If versioning is true, then the last path component is the
+ # version number, and the penultimate path component is the
+ # name.
+ version = os.path.split(item)[1]
+ name = os.path.split(os.path.split(item)[0])[1] + ' (v' + version + ')'
+ else:
+ name = os.path.split(item)[1]
+
+ # Watch for duplicate items!
+ n = 0
+ origname = name
+ while self.treeView.exists(name):
+ n += 1
+ name = origname + '(' + str(n) + ')'
+ mode = 'even' if mode == 'odd' else 'odd'
+ # Note: iid value with spaces in it is a bad idea.
+ if ' ' in name:
+ name = name.replace(' ', '_')
+
+ # optionally: Mark directories with trailing slash
+ if self.markDir and os.path.isdir(item):
+ origname += "/"
+
+ self.treeView.insert('', 'end', text=origname, iid=name, value=item, tag=mode)
+ if self.initSelected and self.treeView.exists(self.initSelected):
+ self.setselect(self.initSelected)
+ self.initSelected = None
+
+ for button in self.func_buttons:
+ button[0].pack_forget()
+
+ if len(self.itemlist) == 0:
+ self.treeView.insert('', 'end', text=self.emptyMessage)
+ self.emptyMessage = self.emptyMessage1 # discard optional special 1st loading... message
+ for button in self.func_buttons:
+ if button[1]:
+ button[0].pack(side='left', padx = 5)
+ else:
+ for button in self.func_buttons:
+ button[0].pack(side='left', padx = 5)
+
+ # Return values from the treeview
+ def getvaluelist(self):
+ valuelist = []
+ itemlist = self.treeView.get_children()
+ for item in itemlist:
+ value = self.treeView.item(item, 'values')
+ valuelist.append(value)
+ return valuelist
+
+ # Return items from the treeview
+ def getlist(self):
+ return self.treeView.get_children()
+
+ # This is a bit of a hack way to populate a second column,
+ # but it works. It only works for one additional column,
+ # though, or else tuples will have to be generated differently.
+
+ def populate2(self, title, itemlist=[], valuelist=[]):
+ # Populate another column
+ self.treeView.heading(1, text = title)
+ self.treeView.column(1, anchor='center')
+ n = 0
+ for item in valuelist:
+ child = os.path.split(itemlist[n])[1]
+ # Get the item at this index
+ oldvalue = self.treeView.item(child, 'values')
+ newvalue = (oldvalue, item)
+ self.treeView.item(child, values = newvalue)
+ n += 1
+
+ def func_callback(self, callback, event=None):
+ callback(self.treeView.item(self.treeView.selection()))
+
+ def bindselect(self, callback):
+ self.selectcallback = callback
+
+ def setselect(self, value):
+ self.treeView.selection_set(value)
+
+ def selected(self):
+ value = self.treeView.item(self.treeView.selection())
+ if value['values']:
+ return value
+ else:
+ return None
diff --git a/common/treeviewsplit.py b/common/treeviewsplit.py
new file mode 100755
index 0000000..0435d7b
--- /dev/null
+++ b/common/treeviewsplit.py
@@ -0,0 +1,649 @@
+#!/ef/efabless/opengalaxy/venv/bin/python3
+#
+# Simple ttk treeview with split view, scrollbar, and
+# row of callback buttons
+
+import os
+import re
+import itertools
+
+import tkinter
+from tkinter import ttk
+
+#------------------------------------------------------
+# Tree view used as a multi-column list box
+#------------------------------------------------------
+
+class TreeViewSplit(ttk.Frame):
+ def __init__(self, parent, fontsize=11, *args, **kwargs):
+ ttk.Frame.__init__(self, parent, *args, **kwargs)
+ s = ttk.Style()
+ s.configure('normal.TLabel', font=('Helvetica', fontsize))
+ s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold'))
+ s.configure('normal.TButton', font=('Helvetica', fontsize),
+ border = 3, relief = 'raised')
+ s.configure('Treeview.Heading', font=('Helvetica', fontsize, 'bold'))
+ s.configure('Treeview.Column', font=('Helvetica', fontsize))
+ self.fontsize = fontsize
+
+ # Last item is a list of 2-item lists, each containing the name of a button
+ # to place along the button bar at the bottom, and a callback function to
+ # run when the button is pressed.
+
+ def populate(self, title1="", item1list=[], title2="", item2list=[], buttons=[], height=10):
+ self.item1list = item1list[:]
+ self.item2list = item2list[:]
+ columns = [0, 1]
+
+ treeFrame = ttk.Frame(self)
+ treeFrame.pack(side='top', padx=5, pady=5, fill='both', expand='true')
+
+ scrollBar = ttk.Scrollbar(treeFrame)
+ scrollBar.pack(side='right', fill='y')
+ self.treeView = ttk.Treeview(treeFrame, selectmode='browse', columns=columns, height=height)
+ self.treeView.pack(side='left', fill='both', expand='true')
+ scrollBar.config(command=self.treeView.yview)
+ self.treeView.config(yscrollcommand=scrollBar.set)
+ self.treeView.column('#0', width=120, stretch='false')
+ self.treeView.heading(0, text=title1, anchor='w')
+ self.treeView.heading(1, text=title2, anchor='w')
+ buttonFrame = ttk.Frame(self)
+ buttonFrame.pack(side='bottom', fill='x')
+
+ self.treeView.tag_configure('select',background='darkslategray',foreground='white')
+
+ # Test type tags
+ self.treeView.tag_configure('error', font=('Helvetica', self.fontsize - 1), foreground = 'red')
+ self.treeView.tag_configure('clean', font=('Helvetica', self.fontsize - 1), foreground = 'green3')
+ self.treeView.tag_configure('normal', font=('Helvetica', self.fontsize - 1), foreground = 'black')
+ self.treeView.tag_configure('prep', font=('Helvetica', self.fontsize, 'bold italic'),
+ foreground = 'black', anchor = 'center')
+ self.treeView.tag_configure('header1', font=('Helvetica', self.fontsize, 'bold italic'),
+ foreground = 'brown', anchor = 'center')
+ self.treeView.tag_configure('header2', font=('Helvetica', self.fontsize - 1, 'bold'),
+ foreground = 'blue', anchor = 'center')
+ self.treeView.tag_configure('header3', font=('Helvetica', self.fontsize - 1, 'bold'),
+ foreground = 'green2', anchor = 'center')
+ self.treeView.tag_configure('header4', font=('Helvetica', self.fontsize - 1),
+ foreground = 'purple', anchor = 'center')
+
+
+ self.func_buttons = []
+ for button in buttons:
+ func = button[2]
+ # Each func_buttons entry is a list of two items; first is the
+ # button widget, and the second is a boolean that is True if the
+ # button is to be present always, False if the button is only
+ # present when there are entries in the itemlists.
+ self.func_buttons.append([ttk.Button(buttonFrame, text=button[0],
+ style = 'normal.TButton',
+ command = lambda func=func: self.func_callback(func)),
+ button[1]])
+
+ self.selectcallback = None
+ self.lastselected = None
+ self.lasttag = None
+ self.repopulate(item1list, item2list)
+
+ def get_button(self, index):
+ if index >= 0 and index < len(self.func_buttons):
+ return self.func_buttons[index][0]
+ else:
+ return None
+
+ def set_title(self, title):
+ self.treeView.heading('#0', text=title, anchor='w')
+
+ def repopulate(self, item1list=[], item2list=[]):
+
+ # Remove all children of treeview
+ self.treeView.delete(*self.treeView.get_children())
+
+ self.item1list = item1list[:]
+ self.item2list = item2list[:]
+ lines = max(len(self.item1list), len(self.item2list))
+
+ # Parse the information coming from comp.out. This is preferably
+ # handled from inside netgen, but that requires development in netgen.
+ # Note: A top-level group is denoted by an empty string.
+
+ nested = ['']
+ if lines > 0:
+ # print("Create item ID 0 parent = ''")
+ self.treeView.insert(nested[-1], 'end', text='-', iid='0',
+ value=['Initialize', 'Initialize'], tags=['prep'])
+ nested.append('0')
+ tagstyle = 'header1'
+
+ emptyrec = re.compile('^[\t ]*$')
+ subrex = re.compile('Subcircuit summary')
+ cktrex = re.compile('Circuit[\t ]+[12]:[\t ]+([^ \t]+)')
+ netrex = re.compile('NET mismatches')
+ devrex = re.compile('DEVICE mismatches')
+ seprex = re.compile('-----')
+ sumrex = re.compile('Netlists ')
+ matchrex = re.compile('.*\*\*Mismatch\*\*')
+ incircuit = False
+ watchgroup = False
+ groupnum = 0
+
+ for item1, item2, index in zip(self.item1list, self.item2list, range(lines)):
+ # Remove blank lines from the display
+ lmatch = emptyrec.match(item1)
+ if lmatch:
+ lmatch = emptyrec.match(item2)
+ if lmatch:
+ continue
+ index = str(index + 1)
+ # Parse text to determine how to structure and display it.
+ tagstyle = 'normal'
+ nextnest = None
+ lmatch = subrex.match(item1)
+ if lmatch:
+ nested = [''] # pop back to topmost level
+ nextnest = index
+ tagstyle = 'header1'
+ incircuit = False
+ watchgroup = False
+ groupnum = 0
+ item1 = 'Layout compare'
+ item2 = 'Schematic compare'
+ cname1 = 'Layout' # Placeholder
+ cname2 = 'Schematic' # Placeholder
+ else:
+ lmatch = cktrex.match(item1)
+ if lmatch and not incircuit:
+ # Pick up circuit names and replace them in the title, then use them
+ # for all following titles.
+ cname1 = lmatch.group(1)
+ lmatch = cktrex.match(item2)
+ cname2 = lmatch.group(1)
+ print("Circuit names " + cname1 + " " + cname2)
+ # Rewrite title
+ cktitem = self.treeView.item(nested[-1], values=[cname1 + ' compare',
+ cname2 + ' compare'])
+ nextnest = index
+ tagstyle = 'header2'
+ incircuit = True
+ item1 = cname1 + ' Summary'
+ item2 = cname2 + ' Summary'
+ elif lmatch:
+ continue
+ else:
+ lmatch = netrex.match(item1)
+ if lmatch:
+ if watchgroup:
+ nested = nested[0:-1]
+ nested = nested[0:-1]
+ nextnest = index
+ tagstyle = 'header2'
+ groupnum = 1
+ watchgroup = True
+ item1 = cname1 + ' Net mismatches'
+ item2 = cname2 + ' Net mismatches'
+ else:
+ lmatch = devrex.match(item1)
+ if lmatch:
+ if watchgroup:
+ nested = nested[0:-1]
+ nested = nested[0:-1]
+ nextnest = index
+ tagstyle = 'header2'
+ groupnum = 1
+ watchgroup = True
+ item1 = cname1 + ' Device mismatches'
+ item2 = cname2 + ' Device mismatches'
+ else:
+ lmatch = seprex.match(item1)
+ if lmatch:
+ if watchgroup:
+ tagstyle = 'header3'
+ item1 = 'Group ' + str(groupnum)
+ item2 = 'Group ' + str(groupnum)
+ if groupnum > 1:
+ nested = nested[0:-1]
+ groupnum += 1
+ nextnest = index
+ watchgroup = False
+ else:
+ if groupnum > 0:
+ watchgroup = True
+ continue
+ else:
+ lmatch = sumrex.match(item1)
+ if lmatch:
+ if watchgroup:
+ nested = nested[0:-1]
+ nested = nested[0:-1]
+ watchgroup = False
+ tagstyle = 'header2'
+ groupnum = 0
+
+ lmatch1 = matchrex.match(item1)
+ lmatch2 = matchrex.match(item2)
+ if lmatch1 or lmatch2:
+ tagstyle='error'
+
+ # print("Create item ID " + str(index) + " parent = " + str(nested[-1]))
+ self.treeView.insert(nested[-1], 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ if nextnest:
+ nested.append(nextnest)
+
+ for button in self.func_buttons:
+ button[0].pack_forget()
+
+ if lines == 0:
+ self.treeView.insert('', 'end', text='-', value=['(no items)', '(no items)'])
+ for button in self.func_buttons:
+ if button[1]:
+ button[0].pack(side='left', padx = 5)
+ else:
+ for button in self.func_buttons:
+ button[0].pack(side='left', padx = 5)
+
+ # Special routine to pull in the JSON file data produced by netgen-1.5.72
+ def json_repopulate(self, lvsdata):
+
+ # Remove all children of treeview
+ self.treeView.delete(*self.treeView.get_children())
+
+ # Parse the information coming from comp.out. This is preferably
+ # handled from inside netgen, but that requires development in netgen.
+ # Note: A top-level group is denoted by an empty string.
+
+ index = 0
+ errtotal = {}
+ errtotal['net'] = 0
+ errtotal['netmatch'] = 0
+ errtotal['device'] = 0
+ errtotal['devmatch'] = 0
+ errtotal['property'] = 0
+ errtotal['pin'] = 0
+ ncells = len(lvsdata)
+ for c in range(0, ncells):
+ cellrec = lvsdata[c]
+ if c == ncells - 1:
+ topcell = True
+ else:
+ topcell = False
+
+ errcell = {}
+ errcell['net'] = 0
+ errcell['netmatch'] = 0
+ errcell['device'] = 0
+ errcell['devmatch'] = 0
+ errcell['property'] = 0
+ errcell['pin'] = 0;
+
+ # cellrec is a dictionary. Parse the cell summary, then failing nets,
+ # devices, and properties, and finally pins.
+
+ if 'name' in cellrec:
+ names = cellrec['name']
+ cname1 = names[0]
+ cname2 = names[1]
+
+ item1 = cname1
+ item2 = cname2
+ tagstyle = 'header1'
+ index += 1
+ nest0 = index
+ self.treeView.insert('', 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+ else:
+ # Some cells have pin comparison but are missing names (needs to be
+ # fixed in netgen. Regardless, if there's no name, then ignore.
+ continue
+
+ if 'devices' in cellrec or 'nets' in cellrec:
+ item1 = cname1 + " Summary"
+ item2 = cname2 + " Summary"
+ tagstyle = 'header2'
+ index += 1
+ nest1 = index
+ self.treeView.insert(nest0, 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ if 'devices' in cellrec:
+ item1 = cname1 + " Devices"
+ item2 = cname2 + " Devices"
+ tagstyle = 'header3'
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ devices = cellrec['devices']
+ devlist = [val for pair in zip(devices[0], devices[1]) for val in pair]
+ devpair = list(devlist[p:p + 2] for p in range(0, len(devlist), 2))
+ for dev in devpair:
+ c1dev = dev[0]
+ c2dev = dev[1]
+
+ item1 = c1dev[0] + "(" + str(c1dev[1]) + ")"
+ item2 = c2dev[0] + "(" + str(c2dev[1]) + ")"
+
+ diffdevs = abs(c1dev[1] - c2dev[1])
+ if diffdevs == 0:
+ tagstyle = 'normal'
+ else:
+ tagstyle = 'error'
+ errcell['device'] += diffdevs
+ if topcell:
+ errtotal['device'] += diffdevs
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ if 'nets' in cellrec:
+ item1 = cname1 + " Nets"
+ item2 = cname2 + " Nets"
+ tagstyle = 'header3'
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ nets = cellrec['nets']
+
+ item1 = nets[0]
+ item2 = nets[1]
+ diffnets = abs(nets[0] - nets[1])
+ if diffnets == 0:
+ tagstyle = 'normal'
+ else:
+ tagstyle = 'error'
+ errcell['net'] = diffnets
+ if topcell:
+ errtotal['net'] += diffnets
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ if 'badnets' in cellrec:
+ badnets = cellrec['badnets']
+
+ if len(badnets) > 0:
+ item1 = cname1 + " Net Mismatches"
+ item2 = cname2 + " Net Mismatches"
+ tagstyle = 'header2'
+ index += 1
+ nest1 = index
+ self.treeView.insert(nest0, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ groupnum = 0
+ for group in badnets:
+ groupc1 = group[0]
+ groupc2 = group[1]
+ nnets = len(groupc1)
+
+ groupnum += 1
+ tagstyle = 'header3'
+ index += 1
+ nest2 = index
+ item1 = "Group " + str(groupnum) + ' (' + str(nnets) + ' nets)'
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item1], tags=[tagstyle])
+
+ tagstyle = 'error'
+ errcell['netmatch'] += nnets
+ if topcell:
+ errtotal['netmatch'] += nnets
+
+ for netnum in range(0, nnets):
+ if netnum > 0:
+ item1 = ""
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item1], tags=[tagstyle])
+
+ net1 = groupc1[netnum]
+ net2 = groupc2[netnum]
+ tagstyle = 'header4'
+ item1 = net1[0]
+ item2 = net2[0]
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ # Pad shorter device list to the length of the longer one
+ netdevs = list(itertools.zip_longest(net1[1], net2[1]))
+ for devpair in netdevs:
+ devc1 = devpair[0]
+ devc2 = devpair[1]
+ tagstyle = 'normal'
+ if devc1 and devc1[0] != "":
+ item1 = devc1[0] + '/' + devc1[1] + ' = ' + str(devc1[2])
+ else:
+ item1 = ""
+ if devc2 and devc2[0] != "":
+ item2 = devc2[0] + '/' + devc2[1] + ' = ' + str(devc2[2])
+ else:
+ item2 = ""
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ if 'badelements' in cellrec:
+ badelements = cellrec['badelements']
+
+ if len(badelements) > 0:
+ item1 = cname1 + " Device Mismatches"
+ item2 = cname2 + " Device Mismatches"
+ tagstyle = 'header2'
+ index += 1
+ nest1 = index
+ self.treeView.insert(nest0, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ groupnum = 0
+ for group in badelements:
+ groupc1 = group[0]
+ groupc2 = group[1]
+ ndevs = len(groupc1)
+
+ groupnum += 1
+ tagstyle = 'header3'
+ index += 1
+ nest2 = index
+ item1 = "Group " + str(groupnum) + ' (' + str(ndevs) + ' devices)'
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item1], tags=[tagstyle])
+
+ tagstyle = 'error'
+ errcell['devmatch'] += ndevs
+ if topcell:
+ errtotal['devmatch'] += ndevs
+
+ for elemnum in range(0, ndevs):
+ if elemnum > 0:
+ item1 = ""
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item1], tags=[tagstyle])
+
+ elem1 = groupc1[elemnum]
+ elem2 = groupc2[elemnum]
+ tagstyle = 'header4'
+ item1 = elem1[0]
+ item2 = elem2[0]
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ # Pad shorter pin list to the length of the longer one
+ elempins = list(itertools.zip_longest(elem1[1], elem2[1]))
+ for pinpair in elempins:
+ pinc1 = pinpair[0]
+ pinc2 = pinpair[1]
+ tagstyle = 'normal'
+ if pinc1 and pinc1[0] != "":
+ item1 = pinc1[0] + ' = ' + str(pinc1[1])
+ else:
+ item1 = ""
+ if pinc2 and pinc2[0] != "":
+ item2 = pinc2[0] + ' = ' + str(pinc2[1])
+ else:
+ item2 = ""
+ index += 1
+ nest3 = index
+ self.treeView.insert(nest2, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ if 'properties' in cellrec:
+ properties = cellrec['properties']
+ numproperr = len(properties)
+ if numproperr > 0:
+ item1 = cname1 + " Properties"
+ item2 = cname2 + " Properties"
+ tagstyle = 'header2'
+ index += 1
+ nest1 = index
+ self.treeView.insert(nest0, 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+ errcell['property'] = numproperr
+ errtotal['property'] += numproperr
+
+ for prop in properties:
+
+ if prop != properties[0]:
+ item1 = ""
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item1], tags=[tagstyle])
+
+ propc1 = prop[0]
+ propc2 = prop[1]
+
+ tagstyle = 'header3'
+ item1 = propc1[0]
+ item2 = propc2[0]
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ # Pad shorter property list to the length of the longer one
+ elemprops = list(itertools.zip_longest(propc1[1], propc2[1]))
+ for proppair in elemprops:
+ perrc1 = proppair[0]
+ perrc2 = proppair[1]
+ tagstyle = 'normal'
+ if perrc1 and perrc1[0] != "":
+ item1 = perrc1[0] + ' = ' + str(perrc1[1])
+ else:
+ item1 = ""
+ if perrc2 and perrc2[0] != "":
+ item2 = perrc2[0] + ' = ' + str(perrc2[1])
+ else:
+ item2 = ""
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ if 'pins' in cellrec:
+ item1 = cname1 + " Pins"
+ item2 = cname2 + " Pins"
+ tagstyle = 'header2'
+ index += 1
+ nest1 = index
+ self.treeView.insert(nest0, 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ pins = cellrec['pins']
+ pinlist = [val for pair in zip(pins[0], pins[1]) for val in pair]
+ pinpair = list(pinlist[p:p + 2] for p in range(0, len(pinlist), 2))
+ for pin in pinpair:
+ item1 = re.sub('!$', '', pin[0].lower())
+ item2 = re.sub('!$', '', pin[1].lower())
+ if item1 == item2:
+ tagstyle = 'header4'
+ else:
+ tagstyle = 'error'
+ errcell['pin'] += 1
+ if topcell:
+ errtotal['pin'] += 1
+ index += 1
+ nest2 = index
+ self.treeView.insert(nest1, 'end', text=index, iid=index,
+ value=[item1, item2], tags=[tagstyle])
+
+ allcellerror = errcell['net'] + errcell['device'] + errcell['property'] + errcell['pin'] + errcell['netmatch'] + errcell['devmatch']
+ if allcellerror > 0:
+ item1 = 'Errors: Net = ' + str(errcell['net']) + ', Device = ' + str(errcell['device']) + ', Property = ' + str(errcell['property']) + ', Pin = ' + str(errcell['pin']) + ', Net match = ' + str(errcell['netmatch']) + ', Device match = ' + str(errcell['devmatch'])
+ tagstyle = 'error'
+ else:
+ item1 = 'LVS Clean'
+ tagstyle = 'clean'
+
+ item2 = ""
+ index += 1
+ nest0 = index
+ self.treeView.insert('', 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ item1 = "Final LVS result:"
+ item2 = ""
+ tagstyle = 'header1'
+ index += 1
+ nest0 = index
+ self.treeView.insert('', 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ allerror = errtotal['net'] + errtotal['device'] + errtotal['property'] + errtotal['pin'] + errtotal['netmatch'] + errtotal['devmatch']
+ if allerror > 0:
+ item1 = 'Errors: Net = ' + str(errtotal['net']) + ', Device = ' + str(errtotal['device']) + ', Property = ' + str(errtotal['property']) + ', Pin = ' + str(errtotal['pin']) + ', Net match = ' + str(errtotal['netmatch']) + ', Device match = ' + str(errtotal['devmatch'])
+ tagstyle = 'error'
+ else:
+ item1 = 'LVS Clean'
+ tagstyle = 'clean'
+
+ item2 = ""
+ index += 1
+ nest0 = index
+ self.treeView.insert('', 'end', text=index, iid=index, value=[item1, item2],
+ tags=[tagstyle])
+
+ for button in self.func_buttons:
+ button[0].pack_forget()
+
+ if index == 0:
+ self.treeView.insert('', 'end', text='-', value=['(no items)', '(no items)'])
+ for button in self.func_buttons:
+ if button[1]:
+ button[0].pack(side='left', padx = 5)
+ else:
+ for button in self.func_buttons:
+ button[0].pack(side='left', padx = 5)
+
+ # Return values from the treeview
+ def getlist(self):
+ return self.treeView.get_children()
+
+ def func_callback(self, callback, event=None):
+ callback(self.treeView.item(self.treeView.selection()))
+
+ def bindselect(self, callback):
+ self.selectcallback = callback
+
+ def setselect(self, value):
+ self.treeView.selection_set(value)
+
+ def selected(self):
+ value = self.treeView.item(self.treeView.selection())
+ if value['values']:
+ return value
+ else:
+ return None
