| #!/usr/bin/env python3 |
| # Copyright 2020 The Skywater PDK Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| |
| import csv |
| from pathlib import Path |
| import argparse |
| from collections import defaultdict |
| import shlex |
| import re |
| from termcolor import colored |
| import sys |
| from prettytable import PrettyTable |
| import json |
| import clean_spice_files |
| |
| copyright = [ |
| '* Copyright 2020 The Skywater PDK Authors', |
| '*', |
| '* Licensed under the Apache License, Version 2.0 (the "License");', |
| '* you may not use this file except in compliance with the License.', |
| '* You may obtain a copy of the License at', |
| '*', |
| '* https://www.apache.org/licenses/LICENSE-2.0', |
| '*', |
| '* Unless required by applicable law or agreed to in writing, software', |
| '* distributed under the License is distributed on an "AS IS" BASIS,', |
| '* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.', |
| '* See the License for the specific language governing permissions and', |
| '* limitations under the License.', |
| '' |
| ] |
| |
| sourcetodests = defaultdict(list) |
| |
| RE_SUBCKT = re.compile(r'\.subckt\s+(?P<subcktname>[^ ]+)\s?(?P<nodenames>.*)') |
| # RE_MODEL = re.compile(r'^[\.]*model\s+(?P<modelname>[^ ]+)\s+(?P<modeltype>[^ ]+)') |
| |
| # RE_MODEL_END = re.compile(r'^[\s\n]*ends(?P<end>.*)(\n|$)') |
| # RE_SUBCKT_END = re.compile(r'^.ends') |
| RE_GROUP = re.compile(r'[*\s]*?(?P<group>[^*\n]+?)[*\s]*(\n|$)') |
| RE_MODE_LINE = re.compile(r'(?P<modeid>\d+)\s*:\s*type=\s*(?P<modetype>.*)(\n|$)') |
| RE_INLINE_SUBCKT_MODEL = re.compile(r'^(?P<modelname>[^ ]+)\s*\((?P<nodenames>.*)\)\s*(?P<subcktname>[^ ]+)\s*(?P<parameters>.*)($|\n)') |
| |
| RE_MODEL = re.compile(r'[\.]?model') |
| |
| def order_parameters(paramname): |
| priority = { |
| 'subckt$subckt': 0, |
| 'subckt$inlinesubckt': 1, |
| 'subckt$nodes': 2, |
| 'model$model': 3, |
| 'model$type': 4, |
| 'mode$mode': 5, |
| 'mode$modetype': 6, |
| 'model$lmin': 7, |
| 'model$lmax': 8, |
| 'model$wmin': 9, |
| 'model$wmax': 10, |
| 'model$level': 11, |
| 'model$tnom': 12, |
| 'model$version': 13, |
| 'model$tox': 14, |
| 'model$toxm': 15, |
| 'mode$lmin': 7, |
| 'mode$lmax': 8, |
| 'mode$wmin': 9, |
| 'mode$wmax': 10, |
| 'mode$level': 11, |
| 'mode$tnom': 12, |
| 'mode$version': 13, |
| 'mode$tox': 14, |
| 'mode$toxm': 15, |
| } |
| if paramname in priority: |
| return (priority[paramname], paramname) |
| return (1000, paramname) |
| |
| |
| def csv_to_pm3(parameters, csventry): |
| # we have following orders |
| # inlinesubckt nodes model type |
| # inlinesubckt nodes model type mode modetype |
| # model type |
| # subckt nodes |
| # subckt nodes model type |
| result = [] |
| if parameters[0] == 'model$model': |
| assert all(['model$' in parameter for parameter in parameters]), parameters |
| for entry in csventry: |
| assert 'N/A' not in entry[:2], entry |
| result.append(f'.model {entry[0]} {entry[1]}') |
| for parameter, value in zip(parameters[2:], entry[2:]): |
| if value != 'N/A': |
| result.append(f'+{parameter.split("$")[1]}= {value}') |
| elif 'mode$mode' in parameters: |
| lastsubcktdef = None |
| lastmodel = None |
| firstsubcktdef = True |
| firstmodel = True |
| for entry in csventry: |
| assert 'N/A' not in entry[:4], entry |
| if entry[0] != lastsubcktdef: |
| if not firstsubcktdef: |
| result.append(f'ends {lastsubcktdef}') |
| lastsubcktdef = entry[0] |
| firstsubcktdef = False |
| if 'subckt$inlinesubckt' in parameters: |
| result.append(f'inline subckt {entry[0]} ({" ".join(entry[1].split(","))})') |
| else: |
| result.append(f'.subckt {entry[0]} {" ".join(entry[1].split(","))}') |
| for parameter, value in zip(parameters[2:], entry[2:]): |
| if value != 'N/A' and parameter.split("$")[0] == 'subckt': |
| result.append(f'+{parameter.split("$")[1]}= {value}') |
| if 'mode$mode' in set(parameters): |
| if entry[2] != lastmodel: |
| if not firstmodel: |
| result.append('}') |
| firstmodel = False |
| result.append(f'model {entry[2]} {entry[3]} {{') |
| lastmodel = entry[2] |
| result.append(f'{entry[4]}: type={entry[5]}') |
| for parameter, value in zip(parameters[6:], entry[6:]): |
| if value != 'N/A' and parameter.split("$")[0] == 'mode': |
| result.append(f'+{parameter.split("$")[1]}= {value}') |
| if not firstmodel: |
| result.append('}') |
| if not firstsubcktdef: |
| result.append(f'ends {lastsubcktdef}') |
| elif parameters[0] in ['subckt$subckt', 'subckt$inlinesubckt']: |
| lastsubckt = None |
| firstsubckt = True |
| assert not any(['mode$' in parameter for parameter in parameters]), entry |
| for entry in csventry: |
| assert 'N/A' not in entry[:2], entry |
| if lastsubckt != entry[0]: |
| if not firstsubckt: |
| result.append('.ends') |
| firstsubckt = False |
| if parameters[0] == 'subckt$subckt': |
| result.append(f'.subckt {entry[0]} {" ".join(entry[1].split(","))}') |
| else: |
| result.append(f'inline subckt {entry[0]} ({" ".join(entry[1].split(","))})') |
| lastsubckt = entry[0] |
| startpoint = 2 |
| for parameter, value in zip(parameters[startpoint:], entry[startpoint:]): |
| if value != 'N/A' and parameter.split('$')[0] == 'subckt': |
| result.append(f'+{parameter.split("$")[1]}= {value}') |
| if parameters[2] == 'model$model' and 'N/A' not in entry[2:4]: |
| assert 'N/A' not in entry[2:4], (parameters, entry) |
| if parameters[0] == 'subckt$subckt': |
| result.append(f'.model {entry[2]} {entry[3]}') |
| else: |
| result.append(f'{entry[2]} ({" ".join(entry[1].split(","))})') |
| startpoint = 4 |
| for parameter, value in zip(parameters[startpoint:], entry[startpoint:]): |
| if value != 'N/A' and parameter.split('$')[0] == 'model': |
| result.append(f'+{parameter.split("$")[1]}= {value}') |
| if not firstsubckt: |
| result.append('.ends') |
| # elif parameters[0] == 'subckt$inlinesubckt': |
| result = clean_spice_files.basic_cleaning(result) |
| result = clean_spice_files.makefixedwidthcolumn(result) |
| return result |
| |
| def pm3_to_csv(lines): |
| result = [] |
| params = {} |
| params['subckt'] = {} |
| params['model'] = {} |
| params['mode'] = {} |
| scopetype = None |
| leftovers = [] |
| parameterbag = {} |
| def produce_line(): |
| finparams = {} |
| finparams.update(params['subckt']) |
| finparams.update(params['model']) |
| finparams.update(params['mode']) |
| if len(finparams) > 0: |
| result.append(finparams) |
| scopetype = None |
| for line in lines: |
| try: |
| if not line.strip(): |
| continue |
| if line.strip().startswith('*'): |
| continue |
| line = re.sub(r'\$.*$', '', line) |
| origline = line |
| line = line.strip() |
| elements = shlex.split(line, posix=False) |
| m = RE_MODE_LINE.match(line) |
| if m: |
| if scopetype == 'mode': |
| produce_line() |
| params['mode'] = {} |
| params['mode']['mode$mode'] = m.group('modeid') |
| params['mode']['mode$modetype'] = m.group('modetype') |
| scopetype = 'mode' |
| continue |
| ind = 0 |
| if line.startswith('parameters'): |
| l = re.sub('\s+', ' ', line) |
| prs = l.split(' ')[1:] |
| assert len(prs) % 2 == 0 |
| ind = 0 |
| while ind < len(prs): |
| parameterbag[prs[ind].split('=')[0]] = prs[ind+1] |
| ind += 2 |
| continue |
| def parse_parameters(): |
| if scopetype is None: |
| return |
| ind = 0 |
| prevkey = None |
| while ind < len(elements): |
| if not elements[ind].strip(): |
| ind += 1 |
| elif elements[ind].endswith('='): |
| if scopetype is None: |
| print(colored(line, 'magenta'), file=sys.stderr) |
| ind += 2 |
| continue |
| key = elements[ind][:-1] |
| val = elements[ind+1] |
| for paramnam, paramval in parameterbag.items(): |
| val = val.replace(paramnam, paramval) |
| params[scopetype][f'{scopetype}${key}'] = val |
| prevkey = key |
| ind += 2 |
| if ind + 1 < len(elements) and 'dev/gauss' in elements[ind]: |
| val = elements[ind+1] |
| for paramnam, paramval in parameterbag.items(): |
| val = val.replace(paramnam, paramval) |
| params[scopetype][f'{scopetype}${key}'] = ' '.join([params[scopetype][f'{scopetype}${key}'], elements[ind], val]) |
| ind += 2 |
| elif '=' in elements[ind]: |
| res = elements[ind].split('=') |
| val = res[1] |
| for paramnam, paramval in parameterbag.items(): |
| val = val.replace(paramnam, paramval) |
| params[scopetype][f'{scopetype}${res[0]}'] = val |
| prevkey = res[0] |
| ind += 1 |
| elif prevkey is not None: |
| val = elements[ind] |
| for paramnam, paramval in parameterbag.items(): |
| val = val.replace(paramnam, paramval) |
| params[scopetype][f'{scopetype}${prevkey}'] += elements[ind] |
| ind += 1 |
| else: |
| print(colored(line, 'cyan'), file=sys.stderr) |
| raise Exception(line) |
| if elements[0] == '.subckt': |
| produce_line() |
| params['subckt'] = {} |
| params['model'] = {} |
| params['mode'] = {} |
| params['subckt']['subckt$subckt'] = elements[1] |
| nodelist = [] |
| ind = 2 |
| for element in elements[2:]: |
| if '=' in element: |
| break |
| element = element.replace('(', '') |
| element = element.replace(')', '') |
| nodelist.append(element) |
| ind += 1 |
| params['subckt']['subckt$nodes'] = ','.join(nodelist) |
| scopetype = 'subckt' |
| elements = elements[ind:] |
| parse_parameters() |
| elif RE_MODEL.match(elements[0]): |
| if scopetype != 'subckt': |
| produce_line() |
| params['model'] = {} |
| params['mode'] = {} |
| params['model']['model$model'] = elements[1] |
| params['model']['model$type'] = elements[2] |
| scopetype = 'model' |
| if len(elements) >=4 and elements[3] == '{': |
| continue |
| elements = elements[3:] |
| parse_parameters() |
| elif elements[0].startswith('+'): |
| elements[0] = elements[0][1:] |
| parse_parameters() |
| elif elements[0] == 'parameters': |
| elements = elements[1:] |
| parse_parameters() |
| else: |
| m = RE_INLINE_SUBCKT_MODEL.match(line) |
| if m: |
| if scopetype is not None: |
| produce_line() |
| params['subckt'] = {} |
| params['model'] = {} |
| params['mode'] = {} |
| scopetype = 'model' |
| params['subckt']['subckt$inlinesubckt'] = m.group('subcktname') |
| params['subckt']['subckt$nodes'] = ','.join(m.group('nodenames').split(' ')) |
| params['model']['model$model'] = m.group('modelname') |
| params['model']['model$type'] = params['subckt']['subckt$inlinesubckt'] |
| elements = m.group('parameters').split() |
| parse_parameters() |
| elif ('subckt$subckt' in params['subckt'] and params['subckt']['subckt$subckt'] in elements) or ('model$model' in params['model'] and params['model']['model$model'].split('.')[0] in elements): |
| typend = params['subckt']['subckt$subckt'] if params['subckt']['subckt$subckt'] in elements else params['model']['model$model'].split('.')[0] |
| typ = params['subckt']['subckt$subckt'] if params['subckt']['subckt$subckt'] in elements else params['model']['model$type'] |
| if scopetype != 'subckt': |
| produce_line() |
| params['model'] = {} |
| params['mode'] = {} |
| params['model']['model$model'] = elements[0] |
| scopetype = 'model' |
| ind = 1 |
| nodes = [] |
| for el in elements[1:]: |
| if el == typend: |
| break |
| nodes.append(el) |
| ind += 1 |
| params['subckt']['subckt$nodes'] = ','.join(nodes) |
| params['model']['model$type'] = elements[ind] |
| elements = elements[ind+1:] |
| parse_parameters() |
| else: |
| if 'ends' not in line.strip() and not line.strip().startswith('inline subckt'): |
| if scopetype is None or not line.strip() in ['{', '}']: |
| leftovers.append(origline.rstrip()) |
| print(colored(line, 'yellow'), file=sys.stderr) |
| except: |
| print(colored(line, 'red'), file=sys.stderr) |
| raise |
| produce_line() |
| parameters = set() |
| for entry in result: |
| parameters.update(entry.keys()) |
| |
| parameters = sorted(parameters, key=order_parameters) |
| |
| csvcontent = [parameters] |
| |
| for entry in result: |
| row = [] |
| for param in parameters: |
| if param in entry: |
| row.append(entry[param]) |
| else: |
| row.append('N/A') |
| csvcontent.append(row) |
| |
| return csvcontent, leftovers |
| |
| if __name__ == '__main__': |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "input_dir", |
| help="The path to the directory containing skywater-pdk", |
| type=Path) |
| parser.add_argument( |
| "--sourcetodests", |
| help="Mapping from source files to destination files", |
| type=Path) |
| parser.add_argument( |
| "--dry-run", |
| help="Do not perform actions on filesystem, only print", |
| action="store_true") |
| |
| args = parser.parse_args() |
| |
| files = sorted(args.input_dir.rglob('*.pm3')) |
| |
| allfilesnum = len(files) |
| |
| parameters = [] |
| # file model parameter value |
| filesdata = defaultdict(lambda: defaultdict(dict)) |
| |
| for num, filename in enumerate(files): |
| with open(filename, 'r') as data: |
| print(f'[{num:05d}/{allfilesnum:05d}]: {filename}') |
| print(f'[{num:05d}/{allfilesnum:05d}]: {filename}', file=sys.stderr) |
| # parameters across many entries |
| lines = [] |
| for line in data.readlines(): |
| lines.append(line) |
| |
| result, leftovers = pm3_to_csv(lines) |
| if len(result) > 1: |
| with open(filename.with_suffix('.csv'), 'w', newline='') as csvfile: |
| writer = csv.writer(csvfile, delimiter=';') |
| writer.writerows(result) |
| sourcetodests[str(filename)].append(str(Path(filename).with_suffix('.csv'))) |
| |
| with open(filename.with_suffix('.table'), 'w') as tablefile: |
| t = PrettyTable(result[0]) |
| t.align = 'r' |
| t.border = False |
| for line in result[1:]: |
| t.add_row(line) |
| tablefile.write(str(t)) |
| sourcetodests[str(filename)].append(str(Path(filename).with_suffix('.table'))) |
| # print(colored('\n'.join(csv_to_pm3(result[0], result[1:])), 'green')) |
| binnedspice = csv_to_pm3(result[0], result[1:]) |
| csv2bsimname = filename.with_suffix(f'.csv2bsim{filename.suffix}') |
| with open(csv2bsimname, 'w') as csv2bsimfile: |
| csv2bsimfile.write('\n'.join(copyright + binnedspice)) |
| with open(filename.with_suffix(f'.csvwrap{filename.suffix}'), 'w') as csvwrapfile: |
| leftovers.append(f'.include "{Path(csv2bsimname).name}"') |
| csvwrapfile.write('\n'.join(copyright + leftovers)) |
| with open(args.sourcetodests, 'w') as srctodst: |
| json.dump(sourcetodests, srctodst, indent=2) |
