blob: 6cbda80a292551251728dc0d33f1d78cd3bf3a98 [file] [log] [blame]
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2020 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.
#
# SPDX-License-Identifier: Apache-2.0
import argparse
import enum
import json
import os
import pathlib
import pprint
import re
import sys
from collections import defaultdict
from typing import Tuple, List, Dict
from . import sizes
from .utils import sortable_extracted_numbers
debug = False
class TimingType(enum.IntFlag):
"""
>>> TimingType.parse("ff_100C_1v65")
('ff_100C_1v65', <TimingType.basic: 1>)
>>> TimingType.parse("ff_100C_1v65_ccsnoise")
('ff_100C_1v65', <TimingType.ccsnoise: 3>)
>>> TimingType.basic in TimingType.ccsnoise
True
>>> TimingType.parse("ff_100C_1v65_pwrlkg")
('ff_100C_1v65', <TimingType.leakage: 4>)
>>> (TimingType.basic).describe()
''
>>> (TimingType.ccsnoise).describe()
'(with ccsnoise)'
>>> (TimingType.leakage).describe()
'(with power leakage)'
>>> (TimingType.leakage | TimingType.ccsnoise).describe()
'(with ccsnoise and power leakage)'
>>> (TimingType.leakage | TimingType.ccsnoise).names()
'basic, ccsnoise, leakage'
>>> TimingType.ccsnoise.names()
'basic, ccsnoise'
"""
basic = 1
# ccsnoise files are basic files with extra 'ccsn_' values in the timing
# data.
ccsnoise = 2 | basic
# leakage files are separate from the basic files
leakage = 4
def names(self):
o = []
for t in TimingType:
if t in self:
o.append(t.name)
return ", ".join(o)
def describe(self):
o = []
if TimingType.ccsnoise in self:
o.append("ccsnoise")
if TimingType.leakage in self:
o.append("power leakage")
if not o:
return ""
return "(with "+" and ".join(o)+")"
@property
def file(self):
if self == TimingType.ccsnoise:
return "_ccsnoise"
elif self == TimingType.leakage:
return "_pwrlkg"
return ""
@classmethod
def parse(cls, name):
ttype = TimingType.basic
if name.endswith("_ccsnoise"):
name = name[:-len("_ccsnoise")]
ttype = TimingType.ccsnoise
elif name.endswith("_pwrlkg"):
name = name[:-len("_pwrlkg")]
ttype = TimingType.leakage
return name, ttype
@property
def singular(self):
return len(self.types) == 1
@property
def types(self):
tt = set(t for t in TimingType if t in self)
if TimingType.ccsnoise in tt:
tt.remove(TimingType.basic)
return list(tt)
def cell_corner_file(lib, cell_with_size, corner, corner_type: TimingType):
"""
>>> cell_corner_file("sky130_fd_sc_hd", "a2111o", "ff_100C_1v65", TimingType.basic)
'cells/a2111o/sky130_fd_sc_hd__a2111o__ff_100C_1v65.lib.json'
>>> cell_corner_file("sky130_fd_sc_hd", "a2111o_1", "ff_100C_1v65", TimingType.basic)
'cells/a2111o/sky130_fd_sc_hd__a2111o_1__ff_100C_1v65.lib.json'
>>> cell_corner_file("sky130_fd_sc_hd", "a2111o_1", "ff_100C_1v65", TimingType.ccsnoise)
'cells/a2111o/sky130_fd_sc_hd__a2111o_1__ff_100C_1v65_ccsnoise.lib.json'
"""
assert corner_type.singular, (lib, cell_with_size, corner, corner_type, corner_type.types())
sz = sizes.parse_size(cell_with_size)
if sz:
cell = cell_with_size[:-len(sz.suffix)]
else:
cell = cell_with_size
fname = "cells/{cell}/{lib}__{cell_sz}__{corner}{corner_type}.lib.json".format(
lib=lib, cell=cell, cell_sz=cell_with_size, corner=corner, corner_type=corner_type.file)
return fname
def top_corner_file(libname, corner, corner_type: TimingType, directory_prefix = "timing"):
"""
>>> top_corner_file("sky130_fd_sc_hd", "ff_100C_1v65", TimingType.ccsnoise)
'timing/sky130_fd_sc_hd__ff_100C_1v65_ccsnoise.lib.json'
>>> top_corner_file("sky130_fd_sc_hd", "ff_100C_1v65", TimingType.basic)
'timing/sky130_fd_sc_hd__ff_100C_1v65.lib.json'
>>> top_corner_file("sky130_fd_sc_hd", "ff_100C_1v65", TimingType.basic, "")
'sky130_fd_sc_hd__ff_100C_1v65.lib.json'
"""
assert corner_type.singular, (libname, corner, corner_type, corner_type.types())
if directory_prefix:
return "{prefix}/{libname}__{corner}{corner_type}.lib.json".format(
libname=libname,
corner=corner,
corner_type=corner_type.file,
prefix = directory_prefix)
return "{libname}__{corner}{corner_type}.lib.json".format(
libname=libname,
corner=corner,
corner_type=corner_type.file)
def collect(library_dir) -> Tuple[Dict[str, TimingType], List[str]]:
"""Collect the available timing information in corners.
Parameters
----------
library_dir: str
Path to a library.
Returns
-------
lib : str
Library name
corners : {str: TimingType}
corners in the library.
cells : list of str
cells in the library.
"""
if not isinstance(library_dir, pathlib.Path):
library_dir = pathlib.Path(library_dir)
libname0 = None
corners = {}
all_cells = set()
for p in library_dir.rglob("*.lib.json"):
if not p.is_file():
continue
if "timing" in str(p):
continue
fname, fext = str(p.name).split('.', 1)
libname, cellname, corner = fname.split("__")
if libname0 is None:
libname0 = libname
assert libname0 == libname, (libname0, libname)
corner_name, corner_type = TimingType.parse(corner)
if corner_name not in corners:
corners[corner_name] = [corner_type, set()]
corners[corner_name][0] |= corner_type
corners[corner_name][1].add(cellname)
all_cells.add(cellname)
for c in corners:
corners[c] = (corners[c][0], list(sorted(corners[c][1])))
assert corners, library_dir
assert all_cells, library_dir
assert libname0, library_dir
all_cells = list(sorted(all_cells))
# Sanity check to make sure the corner exists for all cells.
for corner, (corner_types, corner_cells) in sorted(corners.items()):
missing = set()
for cell_with_size in all_cells:
if cell_with_size not in corner_cells:
missing.add(cell_with_size)
if not missing:
continue
print("Missing", ", ".join(missing), "from", corner, corner_types)
return libname0, corners, all_cells
for corner, (corner_types, corner_cells) in sorted(corners.items()):
for corner_type in corner_types.types:
fname = cell_corner_file(libname0, cell_with_size, corner, corner_type)
fpath = os.path.join(library_dir, fname)
if not os.path.exists(fpath) and debug:
print("Missing", (fpath, corner, corner_type, corner_types))
timing_dir = os.path.join(library_dir, "timing")
assert os.path.exists(timing_dir), timing_dir
for corner, (corner_types, corner_cells) in sorted(corners.items()):
for corner_type in corner_types.types:
fname = top_corner_file(libname0, corner, corner_type)
fpath = os.path.join(library_dir, fname)
if not os.path.exists(fpath) and debug:
print("Missing", (fpath, corner, corner_type, corner_types))
return libname0, corners, all_cells
def remove_ccsnoise_from_timing(data, dataname):
assert "timing" in data, (dataname, data.keys(), data)
timing = data["timing"]
if isinstance(timing, list):
for i, t in enumerate(timing):
assert isinstance(t, dict), (dataname, i, t)
remove_ccsnoise_from_dict(t, "{}.timing[{:3d}]".format(dataname, i))
elif isinstance(timing, dict):
remove_ccsnoise_from_dict(timing, dataname+".timing")
else:
assert False, (dataname, type(timing), timing)
def remove_ccsnoise_from_dict(data, dataname):
if "timing" in data:
remove_ccsnoise_from_timing(data, dataname)
ccsn_keys = set()
for k in data:
if "ccsn_" in k:
ccsn_keys.add(k)
for k in ccsn_keys:
if debug:
print("{:s}: Removing {}".format(dataname, k))
del data[k]
def remove_ccsnoise_from_cell(data, cellname):
remove_ccsnoise_from_dict(data, cellname)
for k, v in list(data.items()):
if k.startswith("pin "):
pin_data = data[k]
if "input_voltage" in pin_data:
del pin_data["input_voltage"]
remove_ccsnoise_from_dict(pin_data, "{}.{}".format(cellname, k))
if k.startswith("bus"):
bus_data = data[k]
remove_ccsnoise_from_dict(bus_data, "{}.{}".format(cellname, k))
remove_ccsnoise_from_library = remove_ccsnoise_from_dict
def generate(library_dir, lib, corner, ocorner_type, icorner_type, cells, output_directory):
output_directory_prefix = None if output_directory else "timing"
top_fname = top_corner_file(lib, corner, ocorner_type, output_directory_prefix).replace('.lib.json', '.lib')
output_directory = output_directory if output_directory else library_dir
top_fpath = os.path.join(output_directory, top_fname)
top_fout = open(top_fpath, "w")
def top_write(lines):
print("\n".join(lines), file=top_fout)
otype_str = "({} from {})".format(ocorner_type.name, icorner_type.names())
print("Starting to write", top_fpath, otype_str, flush=True)
common_data = {}
common_data_path = os.path.join(library_dir, "timing", "{}__common.lib.json".format(lib))
assert os.path.exists(common_data_path), common_data_path
with open(common_data_path) as f:
d = json.load(f)
assert isinstance(d, dict)
for k, v in d.items():
assert k not in common_data, (k, common_data[k])
common_data[k] = v
top_data_path = os.path.join(library_dir, top_corner_file(lib, corner, icorner_type))
assert os.path.exists(top_data_path), top_data_path
with open(top_data_path) as f:
d = json.load(f)
assert isinstance(d, dict)
for k, v in d.items():
if k in common_data:
print("Overwriting", k, "with", v, "(existing value of", common_data[k], ")")
common_data[k] = v
# Remove the ccsnoise if it exists
if ocorner_type != TimingType.ccsnoise:
remove_ccsnoise_from_library(common_data, "library")
attribute_types = {}
output = liberty_dict("library", lib+"__"+corner, common_data, attribute_types)
assert output[-1] == '}', output
top_write(output[:-1])
for cell_with_size in cells:
fname = cell_corner_file(lib, cell_with_size, corner, icorner_type)
fpath = os.path.join(library_dir, fname)
assert os.path.exists(fpath), fpath
with open(fpath) as f:
cell_data = json.load(f)
# Remove the ccsnoise if it exists
if ocorner_type != TimingType.ccsnoise:
remove_ccsnoise_from_cell(cell_data, cell_with_size)
top_write([''])
top_write(liberty_dict(
"cell",
"%s__%s" % (lib, cell_with_size),
cell_data,
[cell_with_size],
attribute_types,
))
top_write([''])
top_write(['}'])
top_fout.close()
print(" Finish writing", top_fpath, flush=True)
print("")
# * The 'delay_model' should be the 1st attribute in the library
# * The 'technology' should be the 1st attribute in the library
LIBERTY_ATTRIBUTE_ORDER = re.sub('/\\*[^*]*\\*/', '', """
library (name_string) {
/* Library-Level Simple and Complex Attributes */
define (...,...,...) ;
technology (name_enum) ;
delay_model : "model" ;
bus_naming_style : "string" ;
date : "date" ;
comment : "string" ;
/* Unit definitions */
time_unit : "unit" ;
voltage_unit : "unit" ;
leakage_power_unit : "unit" ;
current_unit : "unit" ;
pulling_resistance_unit : "unit" ;
..._unit : "unit" ;
/* FIXME: Should capacitive_load_unit always be last? */
capacitive_load_unit (value, unit) ;
/* FIXME: Why is define_cell_area here, while other defines are up above? */
define_cell_area (area_name, resource_type) ;
revision : float | string ;
/* Default Attributes and Values */
default_cell_leakage_power : float ;
default_fanout_load : float ;
default_inout_pin_cap : float ;
default_input_pin_cap : float ;
default_max_transition : float ;
default_output_pin_cap : float ;
default_... : ... ;
/* Scaling Factors Attributes and Values */
k_process_cell_fall ... ;
k_process_cell_rise ... ;
k_process_fall_propagation ... ;
k_process_fall_transition ... ;
k_process_rise_propagation ... ;
k_process_rise_transition ... ;
k_temp_cell_fall ... ;
k_temp_cell_rise ... ;
k_temp_fall_propagation ... ;
k_temp_fall_transition ... ;
k_temp_rise_propagation ... ;
k_temp_rise_transition ... ;
k_volt_cell_fall ... ;
k_volt_cell_rise ... ;
k_volt_fall_propagation ... ;
k_volt_fall_transition ... ;
k_volt_rise_propagation ... ;
k_volt_rise_transition ... ;
k_... : ... ;
/* Library-Level Group Statements */
operating_conditions (name_string) {
... operating conditions description ...
}
wire_load (name_string) {
... wire load description ...
}
wire_load_selection (name_string) {
... wire load selection criteria...
}
power_lut_template (namestring) {
... power lookup table template information...
}
lu_table_template (name_string) {
variable_1 : value_enum ;
variable_2 : value_enum ;
variable_3 : value_enum ;
index_1 ("float, ..., float");
index_2 ("float, ..., float");
index_3 ("float, ..., float");
}
normalized_driver_waveform (waveform_template_name) {
driver_waveform_name : string; /* Specifies the name of the driver waveform table */
index_1 ("float, ... float"); /* Specifies input net transition */
index_2 ("float, ... float"); /* Specifies normalized voltage */
values ("float, ... float", \ /* Specifies the time in library units */
... , \\
"float, ... float");
}
/* Cell definitions */
cell (namestring2) {
... cell description ...
}
...
/* FIXME: What are these and why are they last */
type (namestring) {
... type description ...
}
input_voltage (name_string) {
... input voltage information ...
}
output_voltage (name_string) {
... output voltage information ...
}
}
""")
RE_LIBERTY_LIST = re.compile("(.*)_([0-9]+)")
RE_NUMBERS = re.compile('([0-9]+)')
def _lookup_attribute_pos(name):
# Pad with spaces so you don't get substring matches.
name = ' ' + name
if name.endswith('_'):
name = name + ' '
i = LIBERTY_ATTRIBUTE_ORDER.find(name)
if i != -1:
return float(i)
return None
def liberty_attribute_order(attr_name):
"""
FIXME: Make these doctests less fragile...
>>> liberty_attribute_order("define")
(33.0, 0.0)
>>> liberty_attribute_order('voltage_map')
(inf, inf)
>>> liberty_attribute_order('slew_lower_threshold_pct_fall')
(inf, inf)
>>> liberty_attribute_order('time_unit')
(203.0, 0.0)
>>> liberty_attribute_order('random_unit')
(357.0, 0.0)
>>> liberty_attribute_order('capacitive_load_unit')
(386.0, 0.0)
>>> liberty_attribute_order('technology')
(60.0, 0.0)
>>> liberty_attribute_order('technology("cmos")')
(60.0, 0.0)
>>> liberty_attribute_order('delay_model')
(89.0, 0.0)
>>> liberty_attribute_order("cell")
(2282.0, 0.0)
>>> v1, v2 = "variable_1", "variable_2"
>>> i1, i2, i3, i4 = "index_1", "index_2", "index_3", "index_4"
>>> print('\\n'.join(sorted([v2, i1, v1, i2, i3, i4], key=liberty_attribute_order)))
variable_1
variable_2
index_1
index_2
index_3
index_4
>>> liberty_attribute_order("values")
(2182.0, 0.0)
>>> print('\\n'.join(sorted([
... 'default_inout_pin_cap',
... 'k_XXXX',
... 'k_temp_cell_fall',
... 'default_XXXX',
... ], key=liberty_attribute_order)))
default_inout_pin_cap
default_XXXX
k_temp_cell_fall
k_XXXX
"""
assert ':' not in attr_name, attr_name
m = RE_LIBERTY_LIST.match(attr_name)
if m:
k, n = m.group(1), m.group(2)
i = _lookup_attribute_pos(k)
if not i:
i = float('inf')
return float(i), float(n)
lookup_name = attr_name
i = _lookup_attribute_pos(lookup_name)
if i:
return i, 0.0
if '(' in lookup_name:
lookup_name = lookup_name[:lookup_name.index('(')]
if 'default_' in attr_name:
lookup_name = 'default_...'
if '_unit' in attr_name:
lookup_name = '..._unit'
if 'k_' in attr_name:
lookup_name = 'k_...'
i = _lookup_attribute_pos(lookup_name)
if i:
return i, 0.0
return float('inf'), float('inf')
def is_liberty_list(k):
"""
>>> is_liberty_list("variable_1")
True
>>> is_liberty_list("index_3")
True
>>> is_liberty_list("values")
True
"""
m = RE_LIBERTY_LIST.match(k)
if m:
k, n = m.group(1), m.group(2)
return k in ('variable', 'index', 'values')
def liberty_guess(o):
"""
>>> liberty_guess('hello') # doctest: +ELLIPSIS
<function liberty_str at ...>
>>> liberty_guess(1.0) # doctest: +ELLIPSIS
<function liberty_float at ...>
>>> liberty_guess(1) # doctest: +ELLIPSIS
<function liberty_float at ...>
>>> liberty_guess(None)
Traceback (most recent call last):
...
ValueError: None has unguessable type: <class 'NoneType'>
"""
if isinstance(o, str):
return liberty_str
elif isinstance(o, (float,int)):
return liberty_float
else:
raise ValueError("%r has unguessable type: %s" % (o, type(o)))
def liberty_bool(b):
"""
>>> liberty_bool(True)
'true'
>>> liberty_bool(False)
'false'
>>> liberty_bool(1.0)
'true'
>>> liberty_bool(1.5)
Traceback (most recent call last):
...
ValueError: 1.5 is not a bool
>>> liberty_bool(0.0)
'false'
>>> liberty_bool(0)
'false'
>>> liberty_bool(1)
'true'
>>> liberty_bool("error")
Traceback (most recent call last):
...
ValueError: 'error' is not a bool
"""
try:
b2 = bool(b)
except ValueError:
b2 = None
if b2 != b:
raise ValueError("%r is not a bool" % b)
return {True: 'true', False: 'false'}[b]
def liberty_str(s):
"""
>>> liberty_str("hello")
'"hello"'
>>> liberty_str('he"llo')
Traceback (most recent call last):
...
ValueError: '"' is not allow in the string: 'he"llo'
>>> liberty_str(1.0)
'"1.0000000000"'
>>> liberty_str(1)
'"1.0000000000"'
>>> liberty_str([])
Traceback (most recent call last):
...
ValueError: [] is not a string
>>> liberty_str(True)
Traceback (most recent call last):
...
ValueError: True is not a string
"""
try:
if isinstance(s, (int, float)):
s = liberty_float(s)
except ValueError:
pass
if not isinstance(s, str):
raise ValueError("%r is not a string" % s)
if '"' in s:
raise ValueError("'\"' is not allow in the string: %r" % s)
return '"'+s+'"'
def liberty_int(f):
"""
>>> liberty_int(1.0)
1
>>> liberty_int(1.5)
Traceback (most recent call last):
...
ValueError: 1.5 is not an int
>>> liberty_int("error")
Traceback (most recent call last):
...
ValueError: 'error' is not an int
"""
try:
f2 = int(f)
except ValueError as e:
f2 = None
if f2 is None or f2 != f:
raise ValueError("%r is not an int" % f)
return int(f)
def liberty_float(f):
"""
>>> liberty_float(1.9208818e-02)
'0.0192088180'
>>> liberty_float(1.5)
'1.5000000000'
>>> liberty_float(1e20)
'1.000000e+20'
>>> liberty_float(1)
'1.0000000000'
>>> liberty_float(True)
Traceback (most recent call last):
...
ValueError: True is not a float
>>> liberty_float(False)
Traceback (most recent call last):
...
ValueError: False is not a float
>>> liberty_float(0)
'0.0000000000'
>>> liberty_float(None)
Traceback (most recent call last):
...
ValueError: None is not a float
>>> liberty_float('hello')
Traceback (most recent call last):
...
ValueError: 'hello' is not a float
"""
try:
f2 = float(f)
except (ValueError, TypeError):
f2 = None
if isinstance(f, bool):
f2 = None
if f is None or f2 != f:
raise ValueError("%r is not a float" % f)
WIDTH = len(str(0.0083333333))
s = json.dumps(f)
if 'e' in s:
a, b = s.split('e')
if '.' not in a:
a += '.'
while len(a)+len(b)+1 < WIDTH:
a += '0'
s = "%se%s" % (a, b)
elif '.' in s:
while len(s) < WIDTH:
s += '0'
else:
if len(s) < WIDTH:
s += '.'
while len(s) < WIDTH:
s += '0'
return s
LIBERTY_ATTRIBUTE_TYPES = {
'boolean': liberty_bool,
'string': liberty_str,
'int': liberty_int,
'float': liberty_float,
}
INDENT=" "
def liberty_composite(k, v, i=tuple()):
"""
>>> def pl(l):
... print("\\n".join(l))
>>> pl(liberty_composite("capacitive_load_unit", [1.0, "pf"], []))
capacitive_load_unit(1.0000000000, "pf");
>>> pl(liberty_composite("voltage_map", [("vpwr", 1.95), ("vss", 0.0)], []))
voltage_map("vpwr", 1.9500000000);
voltage_map("vss", 0.0000000000);
>>> pl(liberty_composite("library_features", 'report_delay_calculation', []))
library_features("report_delay_calculation");
"""
if isinstance(v, tuple):
v = list(v)
if not isinstance(v, list):
v = [v]
#assert isinstance(v, list), (k, v)
if isinstance(v[0], (list, tuple)):
o = []
for j, l in enumerate(v):
o.extend(liberty_composite(k, l, i))
return o
o = []
for l in v:
if isinstance(l, (float, int)):
o.append(liberty_float(l))
elif isinstance(l, str):
assert '"' not in l, (k, v)
o.append('"%s"' % l)
else:
raise ValueError("%s - %r (%r)" % (k, l, v))
return ["%s%s(%s);" % (INDENT*len(i), k, ", ".join(o))]
def liberty_join(l):
"""
>>> l = [5, 1.0, 10]
>>> liberty_join(l)(l)
'5.0000000000, 1.0000000000, 10.000000000'
>>> l = [1, 5, 8]
>>> liberty_join(l)(l)
'1, 5, 8'
"""
d = defaultdict(lambda: 0)
for i in l:
d[type(i)] += 1
def types(l):
return [(i, type(i)) for i in l]
if d[float] > 0:
assert (d[float]+d[int]) == len(l), (d, types(l))
def join(l):
return ", ".join(liberty_float(f) for f in l)
return join
elif d[int] > 0:
assert d[int] == len(l), (d, types(l))
def join(l):
return ", ".join(str(f) for f in l)
return join
raise ValueError("Invalid value: %r" % types(l))
def liberty_list(k, v, i=tuple()):
o = []
if isinstance(v[0], list):
o.append('%s%s(' % (INDENT*len(i), k))
join = liberty_join(v[0])
for l in v:
o.append('%s"%s", \\' % (INDENT*(len(i)+1), join(l)))
o0 = o.pop(0)
o[0] = o0+o[0].lstrip()
o[-1] = o[-1][:-3] + ');'
else:
join = liberty_join(v)
o.append('%s%s("%s");' % (INDENT*len(i), k, join(v)))
return o
def liberty_dict(dtype, dvalue, data, indent=tuple(), attribute_types=None):
"""
>>> def g(a, b, c):
... return {"group_name": a, "attribute_name":b, "attribute_type": c}
>>> d = {'float': 1.0, "str": "str"}
>>> print('\\n'.join(liberty_dict("library", "test", d)))
library ("test") {
float : 1.0000000000;
str : "str";
}
>>> d['define'] = [g("cell", "float", "string")]
>>> print('\\n'.join(liberty_dict("library", "test", d)))
library ("test") {
define(float,cell,string);
float : 1.0000000000;
str : "str";
}
>>> d['define'] = [g("library", "float", "string")]
>>> print('\\n'.join(liberty_dict("library", "test", d)))
library ("test") {
define(float,library,string);
float : "1.0000000000";
str : "str";
}
"""
assert isinstance(data, dict), (dtype, dvalue, data)
if attribute_types is None:
attribute_types = {}
assert isinstance(attribute_types, dict), (dtype, dvalue, attribute_types)
o = []
if dvalue:
dbits = dvalue.split(",")
for j, d in enumerate(dbits):
if '"' in d:
assert d.startswith('"'), (dvalue, dbits, indent)
assert d.endswith('"'), (dvalue, dbits, indent)
dbits[j] = d[1:-1]
dvalue = ','.join('"%s"' % d.strip() for d in dbits)
o.append('%s%s (%s) {' % (INDENT*len(indent), dtype, dvalue))
# Sort the attributes
def attr_sort_key(item):
k, v = item
if "," in k:
ktype, kvalue = k.split(",", 1)
sortable_kv = sortable_extracted_numbers(kvalue)
else:
ktype = k
kvalue = ""
sortable_kv = tuple()
if ktype == "comp_attribute":
sortable_kt = liberty_attribute_order(kvalue)
else:
sortable_kt = liberty_attribute_order(ktype)
return sortable_kt, ktype, sortable_kv, kvalue, k, v
di = [attr_sort_key(i) for i in data.items()]
di.sort()
if debug:
print(" "*len(str(indent)), "s1 s2 ", "%-40s" % "ktype", '%-40r' % "kvalue", "value")
print("-"*len(str(indent)), "---- ---- ", "-"*40, "-"*40, "-"*44)
for sk, kt, skv, kv, k, v in di:
print(str(indent), "%4.0f %4.0f --" % sk, "%-40s" % kt, '%-40r' % kv, end=" ")
sv = str(v)
print(sv[:40], end=" ")
if len(sv) > 40:
print('...', end=" ")
print()
# Output all the attributes
if dtype not in attribute_types:
dtype_attribute_types = {}
attribute_types[dtype] = dtype_attribute_types
dtype_attribute_types = attribute_types[dtype]
for _, ktype, _, kvalue, k, v in di:
indent_n = list(indent)+[k]
if ktype == 'define':
for d in sorted(data['define'], key=lambda d: d['group_name']+'.'+d['attribute_name']):
aname = d['attribute_name']
gname = d['group_name']
atype = d['attribute_type']
o.append('%sdefine(%s,%s,%s);' % (
INDENT*len(indent_n), aname, gname, atype))
assert atype in LIBERTY_ATTRIBUTE_TYPES, (atype, d)
if gname not in attribute_types:
attribute_types[gname] = {}
attribute_types[gname][aname] = LIBERTY_ATTRIBUTE_TYPES[atype]
elif ktype == "comp_attribute":
o.extend(liberty_composite(kvalue, v, indent_n))
elif isinstance(v, dict):
assert isinstance(v, dict), (dtype, dvalue, k, v)
o.extend(liberty_dict(ktype, kvalue, v, indent_n, attribute_types))
elif isinstance(v, list):
assert len(v) > 0, (dtype, dvalue, k, v)
if isinstance(v[0], dict):
def sk(o):
return o.items()
for l in sorted(v, key=sk):
o.extend(liberty_dict(ktype, kvalue, l, indent_n, attribute_types))
elif is_liberty_list(ktype):
o.extend(liberty_list(ktype, v, indent_n))
elif "table" == ktype:
o.append('%s%s : "%s";' % (INDENT*len(indent_n), k, ",".join(v)))
elif "clk_width" == ktype:
for l in sorted(v):
o.append('%s%s : "%s";' % (INDENT*len(indent_n), k, l))
else:
raise ValueError("Unknown %s: %r\n%s" % ((ktype, kvalue, k), v, indent_n))
else:
if ktype in dtype_attribute_types:
liberty_out = dtype_attribute_types[ktype]
else:
liberty_out = liberty_guess(v)
ov = liberty_out(v)
o.append("%s%s : %s;" % (INDENT*len(indent_n), k, ov))
o.append("%s}" % (INDENT*len(indent)))
return o
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"library_path",
help="Path to the library.",
type=pathlib.Path,
nargs=1)
parser.add_argument(
"corner",
help="Corner to write output for.",
default=None,
nargs='*')
parser.add_argument(
"--ccsnoise",
help="Include ccsnoise in file output.",
action='store_true',
default=False)
parser.add_argument(
"--leakage",
help="Include power leakage in file output.",
action='store_true',
default=False)
parser.add_argument(
"--debug",
help="Include verbose debug output on the console.",
action='store_true',
default=False)
parser.add_argument(
"-o",
"--output_directory",
help="Sets the parent directory of the liberty files",
default="")
args = parser.parse_args()
if args.debug:
global debug
debug = True
libdir = args.library_path[0]
retcode = 0
lib, corners, all_cells = collect(libdir)
if args.ccsnoise:
output_corner_type = TimingType.ccsnoise
elif args.leakage:
output_corner_type = TimingType.leakage
else:
output_corner_type = TimingType.basic
if args.corner == ['all']:
args.corner = list(sorted(k for k, (v0, v1) in corners.items() if output_corner_type in v0))
if args.corner:
for acorner in args.corner:
if acorner in corners:
continue
print()
print("Unknown corner:", acorner)
retcode = 1
if retcode != 0:
args.corner.clear()
if not args.corner:
print()
print("Available corners for", lib+":")
for k, v in sorted(corners.items()):
print(" -", k, v[0].describe())
print()
return retcode
print("Generating", output_corner_type.name, "liberty timing files for", lib, "at", ", ".join(args.corner))
print()
for corner in args.corner:
input_corner_type, corner_cells = corners[corner]
if output_corner_type not in input_corner_type:
print("Corner", corner, "doesn't support", output_corner_type, "(only {})".format(input_corner_type))
return 1
if output_corner_type == TimingType.basic and TimingType.ccsnoise in input_corner_type:
input_corner_type = TimingType.ccsnoise
else:
input_corner_type = output_corner_type
generate(
libdir, lib,
corner, output_corner_type, input_corner_type,
corner_cells, args.output_directory
)
return 0
if __name__ == "__main__":
import doctest
fail, _ = doctest.testmod()
if fail > 0:
sys.exit(1)
sys.exit(main())