blob: ab297141f45be7228f1d6bfe887fd34f05b1c76c [file]
#!/usr/bin/env python3
"""\
Convert a Verilog simulation model to a VPR `pb_type.xml`
The following are allowed on a top level module:
- `(* blackbox *)` : specify that the module has no interconnect or child
pb_types (but if modes are used then its modes are allowed to have these).
This will also set the BLIF model to be `.subckt <name>` unless CLASS is
also specified.
- `(* CLASS="lut|routing|mux|flipflop|mem" *)` : specify the class of an given
instance.
- `(* MODES="mode1; mode2; ..." *)` : specify that the module has more than one functional
mode, each with a given name. The module will be evaluated n times, each time setting
the MODE parameter to the nth value in the list of mode names. Each evaluation will be
put in a pb_type `<mode>` section named accordingly.
- `(* MODEL_NAME="model" *)` : override the name used for <model> and for
".subckt name" in the BLIF model. Mostly intended for use with w.py, when several
different pb_types implement the same model.
The following are allowed on nets within modules (TODO: use proper Verilog timing):
- `(* SETUP="clk 10e-12" *)` : specify setup time for a given clock
- `(* HOLD="clk 10e-12" *)` : specify hold time for a given clock
- `(* CLK_TO_Q="clk 10e-12" *)` : specify clock-to-output time for a given clock
- `(* DELAY_CONST_{input}="30e-12" *)` : specify a constant max delay from an input (applied to the output)
- `(* DELAY_MATRIX_{input}="30e-12 35e-12; 20e-12 25e-12; ..." *)` : specify a VPR
delay matrix (semicolons indicate rows). In this format columns specify
inputs bits and rows specify output bits. This should be applied to the output.
The following are allowed on ports:
- `(* CLOCK *)` : force a given port to be a clock
- `(* ASSOC_CLOCK="RDCLK" *)` : force a port's associated clock to a given value
- `(* PORT_CLASS="clock" *)` : specify the VPR "port_class"
The Verilog define "PB_TYPE" is set during generation.
"""
import os, sys
import argparse, re
import lxml.etree as ET
import yosys.run
from yosys.json import YosysJSON
sys.path.insert(0, "..")
from lib import xmlinc
parser = argparse.ArgumentParser(
description=__doc__.strip(), formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument(
'infiles',
metavar='input.v',
type=str,
nargs='+',
help="""\
One or more Verilog input files, that will be passed to Yosys internally.
They should be enough to generate a flattened representation of the model,
so that paths through the model can be determined.
"""
)
parser.add_argument(
'--top',
help="""\
Top level module, will usually be automatically determined from the file name
%.sim.v
"""
)
parser.add_argument(
'--includes',
help="""\
Command seperate list of include directories.
""",
default=""
)
parser.add_argument('-o', help="""\
Output filename, default 'model.xml'
""")
args = parser.parse_args()
iname = os.path.basename(args.infiles[0])
outfile = "pb_type.xml"
if "o" in args and args.o is not None:
outfile = args.o
yosys.run.add_define("PB_TYPE")
if args.includes:
for include in args.includes.split(','):
yosys.run.add_include(include)
vjson = yosys.run.vlog_to_json(args.infiles, flatten=False, aig=False)
yj = YosysJSON(vjson)
if args.top is not None:
top = args.top
else:
wm = re.match(r"([A-Za-z0-9_]+)\.sim\.v", iname)
if wm:
top = wm.group(1).upper()
else:
print(
"ERROR file name not of format %.sim.v ({}), cannot detect top level. Manually specify the top level module using --top"
.format(iname)
)
sys.exit(1)
tmod = yj.module(top)
INVALID_INSTANCE = -1
def is_mod_blackbox(mod):
""" Returns true if module is annotated with blackbox (or equivilant).
Yosys supports 3 attributes that denote blackbox behavior:
"blackbox" - Blackbox with no internal wiring
"whitebox" - Blackbox with internal connections and timing.
"lib_whitebox" - Like "whitebox" when read with "-lib", otherwise
attribute is removed.
"""
return (mod.attr("lib_whitebox", 0) == 1) or \
(mod.attr("whitebox", 0) == 1) or \
(mod.attr("blackbox", 0) == 1)
def mod_pb_name(mod):
"""Convert a Verilog module to a pb_type name in the format documented here:
https://github.com/SymbiFlow/symbiflow-arch-defs/#names"""
modes = mod.attr("MODES", None)
has_modes = modes is not None
# Process type and class of module
mod_cls = mod.CLASS
if mod_cls == "routing":
return mod.name
elif mod_cls == "mux":
return mod.name
elif mod_cls == "flipflop":
return mod.name
elif mod_cls == "lut":
return mod.name
elif is_mod_blackbox(mod) and not has_modes:
return mod.name
else:
#TODO: other types
return mod.name
def strip_name(name):
if '\\' in name:
ts = name.find('\\')
tf = name.rfind('\\')
return name[ts + 1:tf]
return name
def make_pb_content(yj, mod, xml_parent, mod_pname, is_submode=False):
"""Build the pb_type content - child pb_types, timing and direct interconnect,
but not IO. This may be put directly inside <pb_type>, or inside <mode>."""
def get_module_name(pin, instance=INVALID_INSTANCE):
"""Returns the name of the module relative to the pin and a boolean that indicates whether
the module is a cell (True) or the top one (False)"""
if instance <= INVALID_INSTANCE:
instance = ""
else:
instance = "[" + str(instance) + "]"
cname, cellpin = pin
if cname.startswith("$"):
return mod.cell_type(cname) + instance, True
elif cname != mod.name:
cname = mod.cell_type(cname)
modname = mod_pb_name(yj.module(cname)) + instance
return modname, True
else:
return mod_pname, False
def get_cellpin(pin):
cname, cellpin = pin
return cellpin
def create_port(pin_name, mod_name, is_cell, direction):
"""Returns a dictionary containing the port definition. If the module is a cell, the port
contains the 'from' attribute."""
port = dict()
port['name'] = pin_name
port['type'] = direction
if is_cell:
port['from'] = mod_name
return port
def make_direct_conn(
ic_xml,
src,
dst,
source_instance=INVALID_INSTANCE,
dest_instance=INVALID_INSTANCE
):
s_cellpin = get_cellpin(src)
d_cellpin = get_cellpin(dst)
s_cname, s_is_cell = get_module_name(src, source_instance)
d_cname, d_is_cell = get_module_name(dst, dest_instance)
s_port = create_port(s_cellpin, s_cname, s_is_cell, "input")
d_port = create_port(d_cellpin, d_cname, d_is_cell, "output")
dir_xml = ET.SubElement(ic_xml, 'direct')
s_port_xml = ET.SubElement(dir_xml, 'port', s_port)
d_port_xml = ET.SubElement(dir_xml, 'port', d_port)
# Find out whether or not the module we are generating content for is a blackbox
is_blackbox = is_mod_blackbox(mod) or not mod.cells
# List of entries in format ((from_cell, from_pin), (to_cell, to_pin))
interconn = []
# Determine multiple instances of the same cell:
cells = dict()
for cname, i_of in mod.cells:
if i_of in cells:
cells[i_of]['count'] += 1
cells[i_of]['is_multi_instance'] = True
# assign unique instance number
cells[i_of][cname] = cells[i_of]['count']
else:
cells[i_of] = dict()
cells[i_of]['is_multi_instance'] = False
cells[i_of]['count'] = 0
cells[i_of][cname] = 0
# Blackbox modules don't have inner cells or interconnect (but do still have timing)
if (not is_blackbox) or is_submode:
# Process cells. First build the list of cnames.
processed_cells = list()
for cname, i_of in mod.cells:
pb_name = strip_name(i_of)
pbtype_already_included = False
if i_of in processed_cells:
# do not emit xml include for every instance of multi instace cell
pbtype_already_included = True
else:
processed_cells.append(i_of)
instance = INVALID_INSTANCE
# If currently considered cell is a multi instance one, pass it's unique
# instance number to connection creator. If not, pass INVALID_INSTANCE
# constant
if cells[i_of]['is_multi_instance']:
instance = cells[i_of][cname]
module_file = yj.get_module_file(i_of)
module_path = os.path.dirname(module_file)
module_basename = os.path.basename(module_file)
# Heuristic for autogenerated files from w.py
if not pbtype_already_included:
wm = re.match(r"([A-Za-z0-9_]+)\.sim\.v", module_basename)
if wm:
pb_type_path = "{}/{}.pb_type.xml".format(
module_path,
wm.group(1).lower()
)
else:
pb_type_path = "{}/pb_type.xml".format(module_path)
# inlude contents of the included pb_type, but update it's
# num_pb value
with open(pb_type_path, 'r') as inc_xml:
xml_inc = ET.fromstring(inc_xml.read().encode('utf-8'))
inc_attrib = xml_inc.attrib
inc_attrib['num_pb'] = str(cells[i_of]['count'] + 1)
inc_pb_type = ET.SubElement(xml_parent, 'pb_type', inc_attrib)
xmlinc.include_xml(
parent=inc_pb_type,
href=pb_type_path,
outfile=outfile,
xptr="xpointer(pb_type/child::node())"
)
# In order to avoid overspecifying interconnect, there are two directions we currently
# consider. All interconnect going INTO a cell, and interconnect going out of a cell
# into a top level output - or all outputs if "mode" is used.
inp_cons = mod.cell_conns(cname, "input")
for pin, net in inp_cons:
drvs = mod.net_drivers(net)
assert len(drvs) > 0, (
"ERROR: pin {}.{} has no driver, interconnect will be missing\n{}"
.format(pb_name, pin, mod)
)
assert len(drvs) < 2, (
"ERROR: pin {}.{} has multiple drivers, interconnect will be overspecified"
.format(pb_name, pin)
)
for drv_cell, drv_pin in drvs:
print(pin, net, drv_cell, drv_pin)
# check if we're driven by multi instance cell
drive_instance = INVALID_INSTANCE
drv_cell_type = [
c[1] for c in mod.cells if c[0] == drv_cell
]
if len(drv_cell_type) != 0:
drv_cell_type = drv_cell_type[0]
if cells[drv_cell_type]['is_multi_instance']:
# get drv_cell unique instance number
drive_instance = cells[drv_cell_type][drv_cell]
interconn.append(
(
(drv_cell, drv_pin), (cname, pin), drive_instance,
instance
)
)
out_cons = mod.cell_conns(cname, "output")
for pin, net in out_cons:
sinks = mod.net_sinks(net)
for sink_cell, sink_pin in sinks:
if sink_cell != mod.name:
continue
# Only consider outputs from cell to top level IO. Inputs to other cells will be dealt with
# in those cells.
interconn.append(
(
(cname, pin), (sink_cell, sink_pin), instance,
INVALID_INSTANCE
)
)
# Direct pin->pin connections
for net in mod.nets:
drv = mod.conn_io(net, "input")
if not drv:
continue
assert len(drv) == 1, (
"ERROR: net {} has multiple drivers {}, interconnect will be over specified"
.format(net, drv)
)
for snk in mod.conn_io(net, "output"):
conn = ((mod.name, drv[0]), (mod.name, snk))
interconn.append(conn)
ic_xml = ET.SubElement(xml_parent, "interconnect")
# Process interconnect
for source, dest, src_instance, dst_instance in interconn:
make_direct_conn(ic_xml, source, dest, src_instance, dst_instance)
def process_clocked_tmg(tmgspec, port, xmltype, xml_parent):
"""Add a suitable timing spec if necessary to the pb_type"""
if tmgspec is not None:
splitspec = tmgspec.split(" ")
assert len(
splitspec
) == 2, 'bad timing specification "{}", must be of format "clock value"'.format(
tmgspec
)
attrs = {"port": port, "clock": splitspec[0]}
if xmltype == "T_clock_to_Q":
attrs["max"] = splitspec[1]
else:
attrs["value"] = splitspec[1]
ET.SubElement(xml_parent, xmltype, attrs)
# Process timing
for name, width, bits, iodir in mod.ports:
port = "{}".format(name)
# Clocked timing
Tsetup = mod.net_attr(name, "SETUP")
Thold = mod.net_attr(name, "HOLD")
Tctoq = mod.net_attr(name, "CLK_TO_Q")
process_clocked_tmg(Tsetup, port, "T_setup", xml_parent)
process_clocked_tmg(Thold, port, "T_hold", xml_parent)
process_clocked_tmg(Tctoq, port, "T_clock_to_Q", xml_parent)
# Combinational delays
dly_prefix = "DELAY_CONST_"
dly_mat_prefix = "DELAY_MATRIX_"
for attr, atvalue in sorted(mod.net_attrs(name).items()):
if attr.startswith(dly_prefix):
# Single, constant delays
inp = attr[len(dly_prefix):]
inport = "{}".format(inp)
ET.SubElement(
xml_parent, "delay_constant", {
"in_port": inport,
"out_port": port,
"max": str(atvalue)
}
)
elif attr.startswith(dly_mat_prefix):
# Constant delay matrices
inp = attr[len(dly_mat_prefix):]
inport = "{}".format(inp)
mat = "\n" + atvalue.replace(";", "\n") + "\n"
xml_mat = ET.SubElement(
xml_parent, "delay_matrix", {
"in_port": inport,
"out_port": port,
"type": "max"
}
)
xml_mat.text = mat
def make_pb_type(yj, mod):
"""Build the pb_type for a given module. mod is the YosysModule object to
generate."""
modes = mod.attr("MODES", None)
if modes is not None:
modes = modes.split(";")
mod_pname = mod_pb_name(mod)
pb_xml_attrs = dict()
pb_xml_attrs["name"] = mod_pname
# If we are a blackbox with no modes, then generate a blif_model
is_blackbox = is_mod_blackbox(mod) or not mod.cells
has_modes = modes is not None
print("is_blackbox", is_blackbox, "has_modes?", has_modes)
# Process type and class of module
mod_cls = mod.CLASS
if mod_cls is not None:
if mod_cls == "lut":
pb_xml_attrs["blif_model"] = ".names"
pb_xml_attrs["class"] = "lut"
elif mod_cls == "routing":
# TODO: pb_xml_attrs["class"] = "routing"
pass
elif mod_cls == "mux":
# TODO: ?
pass
elif mod_cls == "flipflop":
pb_xml_attrs["blif_model"] = ".latch"
pb_xml_attrs["class"] = "flipflop"
else:
assert False, "unknown class {}".format(mod_cls)
elif is_blackbox and not has_modes:
pb_xml_attrs["blif_model"
] = ".subckt " + mod.attr("MODEL_NAME", mod.name)
# set num_pb to 1, it will be updated if this pb_type
# will be included by another one
pb_xml_attrs["num_pb"] = "1"
pb_type_xml = ET.Element(
"pb_type", pb_xml_attrs, nsmap={'xi': xmlinc.xi_url}
)
# Process IOs
clocks = yosys.run.list_clocks(args.infiles, mod.name)
for name, width, bits, iodir in mod.ports:
ioattrs = {"name": name, "num_pins": str(width)}
pclass = mod.net_attr(name, "PORT_CLASS")
if pclass is not None:
ioattrs["port_class"] = pclass
if name in clocks:
ET.SubElement(pb_type_xml, "clock", ioattrs)
elif iodir == "input":
ET.SubElement(pb_type_xml, "input", ioattrs)
elif iodir == "output":
ET.SubElement(pb_type_xml, "output", ioattrs)
else:
assert False, "bidirectional ports not supported in VPR pb_types"
if has_modes:
for mode in modes:
smode = mode.strip()
mode_xml = ET.SubElement(pb_type_xml, "mode", {"name": smode})
# Rerun Yosys with mode parameter
mode_yj = YosysJSON(
yosys.run.vlog_to_json(
args.infiles,
flatten=False,
aig=False,
mode=smode,
module_with_mode=mod.name
)
)
mode_mod = mode_yj.module(mod.name)
make_pb_content(yj, mode_mod, mode_xml, mod_pname, True)
else:
make_pb_content(yj, mod, pb_type_xml, mod_pname)
return pb_type_xml
parser = argparse.ArgumentParser(
description=__doc__.strip(), formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument(
'infiles',
metavar='input.v',
type=str,
nargs='+',
help="""\
One or more Verilog input files, that will be passed to Yosys internally.
They should be enough to generate a flattened representation of the model,
so that paths through the model can be determined.
"""
)
parser.add_argument(
'--top',
help="""\
Top level module, will usually be automatically determined from the file name
%.sim.v
"""
)
parser.add_argument(
'--outfile',
'-o',
type=argparse.FileType('w'),
default="pb_type.xml",
help="""\
Output filename, default 'model.xml'
"""
)
def main(args):
iname = os.path.basename(args.infiles[0])
yosys.run.add_define("PB_TYPE")
vjson = yosys.run.vlog_to_json(args.infiles, flatten=False, aig=False)
yj = YosysJSON(vjson)
if args.top is not None:
top = args.top
else:
wm = re.match(r"([A-Za-z0-9_]+)\.sim\.v", iname)
if wm:
top = wm.group(1).upper()
else:
print(
"ERROR file name not of format %.sim.v ({}), cannot detect top level. Manually specify the top level module using --top"
.format(iname)
)
sys.exit(1)
tmod = yj.module(top)
pb_type_xml = make_pb_type(yj, tmod)
args.outfile.write(
ET.tostring(
pb_type_xml,
pretty_print=True,
encoding="utf-8",
xml_declaration=True
).decode('utf-8')
)
print("Generated {} from {}".format(args.outfile.name, iname))
args.outfile.close()
if __name__ == "__main__":
args = parser.parse_args()
sys.exit(main(args))