| 1 |
""" |
| 2 |
Utilities for SDF file parsing to determine cell timings |
| 3 |
""" |
| 4 |
import sys |
| 5 |
|
| 6 |
|
| 7 |
class SDFData: |
| 8 |
def __init__(self): |
| 9 |
self.cells = {} |
| 10 |
|
| 11 |
class Delay: |
| 12 |
def __init__(self, minv, typv, maxv): |
| 13 |
self.minv = minv |
| 14 |
self.typv = typv |
| 15 |
self.maxv = maxv |
| 16 |
|
| 17 |
|
| 18 |
class IOPath: |
| 19 |
def __init__(self, from_pin, to_pin, rising, falling): |
| 20 |
self.from_pin = from_pin |
| 21 |
self.to_pin = to_pin |
| 22 |
self.rising = rising |
| 23 |
self.falling = falling |
| 24 |
|
| 25 |
|
| 26 |
class SetupHoldCheck: |
| 27 |
def __init__(self, pin, clock, setup, hold): |
| 28 |
self.pin = pin |
| 29 |
self.clock = clock |
| 30 |
self.setup = setup |
| 31 |
self.hold = hold |
| 32 |
|
| 33 |
|
| 34 |
class WidthCheck: |
| 35 |
def __init__(self, clock, width): |
| 36 |
self.clock = clock |
| 37 |
self.width = width |
| 38 |
|
| 39 |
|
| 40 |
class Interconnect: |
| 41 |
def __init__(self, from_net, to_net, rising, falling): |
| 42 |
self.from_net = from_net |
| 43 |
self.to_net = to_net |
| 44 |
self.rising = rising |
| 45 |
self.falling = falling |
| 46 |
|
| 47 |
|
| 48 |
class CellData: |
| 49 |
def __init__(self, celltype, inst): |
| 50 |
self.type = celltype |
| 51 |
self.inst = inst |
| 52 |
self.entries = [] |
| 53 |
self.interconnect = {} |
| 54 |
|
| 55 |
|
| 56 |
def parse_sexpr(stream): |
| 57 |
content = [] |
| 58 |
buffer = "" |
| 59 |
instr = False |
| 60 |
while True: |
| 61 |
c = stream.read(1) |
| 62 |
assert c != "", "unexpected end of file" |
| 63 |
if instr: |
| 64 |
if c == '"': |
| 65 |
instr = False |
| 66 |
else: |
| 67 |
buffer += c |
| 68 |
else: |
| 69 |
if c == '(': |
| 70 |
content.append(parse_sexpr(stream)) |
| 71 |
elif c == ')': |
| 72 |
if buffer != "": |
| 73 |
content.append(buffer) |
| 74 |
return content |
| 75 |
elif c.isspace(): |
| 76 |
if buffer != "": |
| 77 |
content.append(buffer) |
| 78 |
buffer = "" |
| 79 |
elif c == '"': |
| 80 |
instr = True |
| 81 |
else: |
| 82 |
buffer += c |
| 83 |
|
| 84 |
|
| 85 |
def parse_sexpr_file(filename): |
| 86 |
with open(filename, 'r') as f: |
| 87 |
c = f.read(1) |
| 88 |
while c != '(': |
| 89 |
assert c == ' ' or c == '\n' or c == '\t' |
| 90 |
c = f.read(1) |
| 91 |
return parse_sexpr(f) |
| 92 |
|
| 93 |
|
| 94 |
def parse_delay(delay): |
| 95 |
sp = [float(x) if x != '' else None for x in delay.split(":")] |
| 96 |
assert len(sp) == 3 |
| 97 |
return Delay(sp[0], sp[1], sp[2]) |
| 98 |
|
| 99 |
|
| 100 |
def parse_sdf_file(filename): |
| 101 |
sdata = parse_sexpr_file(filename) |
| 102 |
assert sdata[0] == "DELAYFILE" |
| 103 |
sdf = SDFData() |
| 104 |
for entry in sdata[1:]: |
| 105 |
if entry[0] != "CELL": |
| 106 |
continue |
| 107 |
assert entry[1][0] == "CELLTYPE" |
| 108 |
celltype = entry[1][1] |
| 109 |
assert entry[2][0] == "INSTANCE" |
| 110 |
if len(entry[2]) > 1: |
| 111 |
inst = entry[2][1] |
| 112 |
else: |
| 113 |
inst = "top" |
| 114 |
cell = CellData(celltype, inst) |
| 115 |
setups = {} |
| 116 |
holds = {} |
| 117 |
for subentry in entry[3:]: |
| 118 |
if subentry[0] == "DELAY": |
| 119 |
assert subentry[1][0] == "ABSOLUTE" |
| 120 |
for delay in subentry[1][1:]: |
| 121 |
if delay[0] == "IOPATH": |
| 122 |
cell.entries.append( |
| 123 |
IOPath(delay[1], delay[2], parse_delay(delay[3][0]), parse_delay(delay[4][0]))) |
| 124 |
elif delay[0] == "INTERCONNECT": |
| 125 |
cell.interconnect[(delay[1], delay[2])] = Interconnect(delay[1], delay[2], |
| 126 |
parse_delay(delay[3][0]), |
| 127 |
parse_delay(delay[4][0])) |
| 128 |
elif subentry[0] == "TIMINGCHECK": |
| 129 |
for check in subentry[1:]: |
| 130 |
if check[0] == "SETUPHOLD": |
| 131 |
cell.entries.append( |
| 132 |
SetupHoldCheck(check[1], check[2], parse_delay(check[3][0]), parse_delay(check[4][0]))) |
| 133 |
elif check[0] == "SETUP": |
| 134 |
setups[(check[1], check[2][1])] = parse_delay(check[3][0]) |
| 135 |
elif check[0] == "HOLD": |
| 136 |
holds[(check[1], check[2][1])] = parse_delay(check[3][0]) |
| 137 |
elif check[0] == "WIDTH": |
| 138 |
cell.entries.append(WidthCheck(check[1], parse_delay(check[2][0]))) |
| 139 |
# merge setups and holds |
| 140 |
for k, v in setups.items(): |
| 141 |
if k not in holds: |
| 142 |
continue |
| 143 |
cell.entries.append(SetupHoldCheck(k[0], k[1], v, holds[k])) |
| 144 |
sdf.cells[(celltype, inst)] = cell |
| 145 |
return sdf |