luke
/
prjxray
mirror of https://github.com/openXC7/prjxray.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #238 from mcmasterg/dbfixup_zero 

dbfixup: support const 0 entries
This commit is contained in:
John McMaster 2018-11-07 22:08:59 -08:00 committed by GitHub
parent 005616a467 4f93a21a0b
commit 9a634a7090
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 210 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fuzzers/015-clbnffmux/Makefile
View File

@ -1,4 +1,4 @@
N := 1
DBFIXUP := ${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --zero-tile-types clblx
CLB_DBFIXUP=Y
include ../clb.mk

16
fuzzers/015-clbnffmux/bits.dbf
View File

@ -1,9 +1,9 @@
"30_00 30_01 30_02 30_03"
"30_24 30_25 30_26 30_27"
"30_35 30_36 30_37 30_38"
"30_59 30_60 30_61 30_62"
"30_04 31_00 31_01 31_02"
"31_24 31_25 31_26 31_27"
"31_35 31_36 31_37 31_38"
"30_58 31_60 31_61 31_62"
30_00 30_01 30_02 30_03
30_24 30_25 30_26 30_27
30_35 30_36 30_37 30_38
30_59 30_60 30_61 30_62
30_04 31_00 31_01 31_02
31_24 31_25 31_26 31_27
31_35 31_36 31_37 31_38
30_58 31_60 31_61 31_62

2
fuzzers/016-clbnoutmux/Makefile
View File

@ -1,4 +1,4 @@
N := 1
DBFIXUP := ${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --zero-tile-types clblx
CLB_DBFIXUP=Y
include ../clb.mk

2
fuzzers/017-clbprecyinit/Makefile
View File

@ -1,4 +1,4 @@
N := 1
DBFIXUP := ${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --zero-tile-types clblx
CLB_DBFIXUP=Y
include ../clb.mk

5
fuzzers/017-clbprecyinit/bits.dbf
View File

@ -1,4 +1,3 @@
# Reserved for PRECYINIT.0
# Running on empty DB still removes <const0>
# https://github.com/SymbiFlow/prjxray/issues/232
00_12 30_14 30_13,CLB.SLICE_X0.PRECYINIT.0
01_11 31_13 31_12,CLB.SLICE_X1.PRECYINIT.0

18
fuzzers/017-clbprecyinit/top.py
View File

@ -3,21 +3,13 @@ random.seed(0)
import os
import re
from prjxray import verilog
def slice_xy():
'''Return (X1, X2), (Y1, Y2) from XRAY_ROI, exclusive end (for xrange)'''
# SLICE_X12Y100:SLICE_X27Y149
# Note XRAY_ROI_GRID_* is something else
m = re.match(
r'SLICE_X([0-9]*)Y([0-9]*):SLICE_X([0-9]*)Y([0-9]*)',
os.getenv('XRAY_ROI'))
ms = [int(m.group(i + 1)) for i in range(4)]
return ((ms[0], ms[2] + 1), (ms[1], ms[3] + 1))
from prjxray import util
CLBN = 400
SLICEX, SLICEY = slice_xy()
SLICEX, SLICEY = util.site_xy_minmax([
'SLICEL',
'SLICEM',
])
# 800
SLICEN = (SLICEY[1] - SLICEY[0]) * (SLICEX[1] - SLICEX[0])
print('//SLICEX: %s' % str(SLICEX))

10
fuzzers/025-bram-config/Makefile
View File

@ -3,9 +3,13 @@
N := 8
include ../fuzzer.mk
database: $(SPECIMENS_OK)
${XRAY_SEGMATCH} -o build/segbits_bramx.db $(addsuffix /segdata_bram_[lr].txt,$(SPECIMENS))
${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --zero-tile-types bramx
database: build/segbits_bramx.db
build/segbits_bramx.rdb: $(SPECIMENS_OK)
${XRAY_SEGMATCH} -o build/segbits_bramx.rdb $(addsuffix /segdata_bram_[lr].txt,$(SPECIMENS))
build/segbits_bramx.db: build/segbits_bramx.rdb
${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --seg-fn-in $^ --seg-fn-out $@
pushdb:
${XRAY_MERGEDB} bram_l build/segbits_bramx.db

24
fuzzers/025-bram-config/bits.dbf
View File

@ -1,20 +1,12 @@
# Y0
# Y0.READ_WIDTH_A
27_35 27_36 27_37
# Y0.READ_WIDTH_B
27_43 27_44 27_45
# Y0.WRITE_WIDTH_A
27_51 27_52 27_53
# Y0.WRITE_WIDTH_B
27_59 27_60 27_61
27_35 27_36 27_37,BRAM.RAMB18_Y0.READ_WIDTH_A_1
27_43 27_44 27_45,BRAM.RAMB18_Y0.READ_WIDTH_B_1
27_51 27_52 27_53,BRAM.RAMB18_Y0.WRITE_WIDTH_A_1
27_59 27_60 27_61,BRAM.RAMB18_Y0.WRITE_WIDTH_B_1
# Y1
# Y1.READ_WIDTH_A
27_285 27_284 27_283
# Y1.READ_WIDTH_B
27_277 27_276 27_275
# Y1.WRITE_WIDTH_A
27_269 27_268 27_267
# Y1.WRITE_WIDTH_B
27_261 27_260 27_259
27_285 27_284 27_283,BRAM.RAMB18_Y1.READ_WIDTH_A_1
27_277 27_276 27_275,BRAM.RAMB18_Y1.READ_WIDTH_B_1
27_269 27_268 27_267,BRAM.RAMB18_Y1.WRITE_WIDTH_A_1
27_261 27_260 27_259,BRAM.RAMB18_Y1.WRITE_WIDTH_B_1

15
fuzzers/clb.mk
View File

@ -1,10 +1,19 @@
N ?= 1
DBFIXUP ?=
include fuzzer.mk
include ../fuzzer.mk
database: $(SPECIMENS_OK)
${XRAY_SEGMATCH} -o build/segbits_clblx.db $(addsuffix /segdata_clbl[lm]_[lr].txt,$(SPECIMENS))
database: build/segbits_clbx.db
build/segbits_clbx.rdb: $(SPECIMENS_OK)
${XRAY_SEGMATCH} -o build/segbits_clbx.rdb $(addsuffix /segdata_clbl[lm]_[lr].txt,$(SPECIMENS))
build/segbits_clbx.db: build/segbits_clbx.rdb
ifeq ($(CLB_DBFIXUP),Y)
${XRAY_DBFIXUP} --db_root build --zero-db bits.dbf --seg-fn-in $^ --seg-fn-out $@
else
cp $^ $@
endif
pushdb:
$(DBFIXUP)

6
fuzzers/fuzzer.mk
View File

@ -4,10 +4,8 @@ SPECIMENS_OK := $(addsuffix /OK,$(SPECIMENS))
all: database
build:
mkdir build
$(SPECIMENS_OK): build
$(SPECIMENS_OK):
mkdir -p build
bash ${XRAY_DIR}/utils/top_generate.sh $(subst /OK,,$@)
touch $@

17
prjxray/segmaker.py
View File

@ -62,6 +62,15 @@ class Segmaker:
# hacky...improve if we encounter this more
self.def_bt = 'CLB_IO_CLK'
self.index_sites()
def index_sites(self):
self.verbose and print("Indexing sites")
self.sites = {}
for tilename, tiledata in self.grid.items():
for site in tiledata["sites"]:
self.sites[site] = tilename
self.verbose and print("Sites indexed")
def set_def_bt(self, block_type):
'''Set default block type when more than one block present'''
@ -126,9 +135,12 @@ class Segmaker:
raise ValueError("Invalid site: %s" % site)
self.verbose and print(
'segmaker: site %s tag %s = %s' % (site, name, value))
assert site in self.sites, "Unknown site %s" % (site, )
self.site_tags.setdefault(site, dict())[name] = value
def add_tile_tag(self, tile, name, value):
# TODO: test this out
# assert tile in self.grid
self.tile_tags.setdefault(tile, dict())[name] = value
def compile(self, bitfilter=None):
@ -205,6 +217,7 @@ class Segmaker:
return segment
def add_tilename_tags():
self.verbose and print("Tile %s: check tags" % tilename)
segment = getseg(segname)
for name, value in self.tile_tags[tilename].items():
@ -253,6 +266,8 @@ class Segmaker:
(site, site_prefix, sitekey))
for name, value in self.site_tags[site].items():
self.verbose and print("Site %s: check tags" % site)
tags_used.add((site, name))
tag = "%s.%s.%s" % (tile_type_norm, sitekey, name)
# XXX: does this come from name?
@ -316,7 +331,7 @@ class Segmaker:
if not allow_empty:
assert sum(
[len(segments) for segments in self.segments_by_type.values()
]) != 0
]) != 0, "Didn't generate any segments"
for segtype in self.segments_by_type.keys():
if suffix is not None:

21
prjxray/util.py
View File

@ -35,6 +35,27 @@ def get_roi():
return Roi(db=db, x1=x1, x2=x2, y1=y1, y2=y2)
def gen_sites_xy(site_types):
for _tile_name, site_name, _site_type in get_roi().gen_sites(site_types):
m = re.match(r'.*_X([0-9]*)Y([0-9]*)', site_name)
x, y = int(m.group(1)), int(m.group(2))
yield (site_name, (x, y))
def site_xy_minmax(site_types):
'''Return (X1, X2), (Y1, Y2) from XY_ROI, exclusive end (for xrange)'''
xmin = 9999
xmax = -1
ymin = 9999
ymax = -1
for _site_name, (x, y) in gen_sites_xy(site_types):
xmin = min(xmin, x)
xmax = max(xmax, x)
ymin = min(ymin, y)
ymax = max(ymax, y)
return (xmin, xmax + 1), (ymin, ymax + 1)
# we know that all bits for CLB MUXes are in frames 30 and 31, so filter all other bits
def bitfilter_clb_mux(frame_idx, bit_idx):
return frame_idx in [30, 31]

210
utils/dbfixup.py
View File

@ -21,9 +21,14 @@ def parse_line(line):
parts = line.split()
# Ex: CLBLL_L.SLICEL_X0.AMUX.A5Q
tag = parts[0]
orig_bits = line.replace(tag + " ", "")
# <0 candidates> etc
if "<" in orig_bits:
return tag, set(), orig_bits
# Ex: !30_06 !30_08 !30_11 30_07
bits = set(parts[1:])
return tag, bits
return tag, bits, None
def zero_range(bits, wordmin, wordmax):
@ -57,7 +62,7 @@ def bits_str(bits):
return ' '.join(sorted(list(bits)))
def zero_groups(bits, zero_db, strict=True, verbose=False):
def zero_groups(tag, bits, zero_db, strict=True, verbose=False):
"""
See if a line occurs within a bit group
If it does, add 0 bits
@ -66,13 +71,21 @@ def zero_groups(bits, zero_db, strict=True, verbose=False):
Means find a line that has either of these bits
If either of them occurs, default bits in that set to zero
Ex: 01_02 04_05 | 07_08 10_11
Ex: 01_02 04_05|07_08 10_11
If any bits from the first group occur,
default bits in the second group to zero
Ex: 01_02 04_05,ALL_ZERO
ALL_ZERO is an enum that is part of the group but is all 0
It must have 0 candidates
strict: assert that the size of the given group is the size of the given mask
"""
for zdb in zero_db:
allzero_tag = None
if "," in zdb:
zdb, allzero_tag = zdb.split(",")
if "|" in zdb:
a, b = zdb.split("|")
a = a.split()
@ -81,39 +94,39 @@ def zero_groups(bits, zero_db, strict=True, verbose=False):
a = zdb.split()
b = a
match = False
bitmatch = False
for bit in a:
if bit in bits:
match = True
if match:
bits_orig = set(bits)
for bit in b:
if bit not in bits:
bits.add("!" + bit)
verbose and print(
"Grouped: %s => %s" % (bits_str(bits_orig), bits_str(bits)))
if a == b and strict:
assert len(bits) == len(
a), "Mask size %u != DB entry size %u: %s" % (
len(a), len(bits), bits_str(bits))
bitmatch = True
if not (bitmatch or allzero_tag == tag):
continue
bits_orig = set(bits)
for bit in b:
if bit not in bits:
bits.add("!" + bit)
verbose and print(
"Grouped %s: %s => %s" %
(tag, bits_str(bits_orig), bits_str(bits)))
if a == b and strict:
assert len(bits) == len(
a), "Mask size %u != DB entry size %u: %s" % (
len(a), len(bits), bits_str(bits))
def add_zero_bits(db_root, tile_type, zero_db, clb_int=False, verbose=False):
def add_zero_bits(fn_in, fn_out, zero_db, clb_int=False, verbose=False):
'''
Add multibit entries
This requires adding some zero bits (ex: !31_09)
If an entry has any of the
'''
dbfile = "%s/segbits_%s.db" % (db_root, tile_type)
new_lines = set()
changes = 0
verbose and print("zb %s: %s" % (dbfile, os.path.exists(dbfile)))
if not os.path.exists(dbfile):
return None
llast = None
with open(dbfile, "r") as f:
with open(fn_in, "r") as f:
for line in f:
# Hack: skip duplicate lines
# This happens while merging a new multibit entry
@ -121,21 +134,19 @@ def add_zero_bits(db_root, tile_type, zero_db, clb_int=False, verbose=False):
if line == llast:
continue
tag, bits = parse_line(line)
tag, bits, mode = parse_line(line)
assert mode not in (
"<const0>", "<const1>"), "Entries must be resolved"
if mode:
assert mode == "<0 candidates>"
"""
This appears to be a large range of one hot interconnect bits
They are immediately before the first CLB real bits
"""
# FIXME: handle these better
# https://github.com/SymbiFlow/prjxray/issues/232
orig_bits = line.replace(tag + " ", "")
if orig_bits in ("<const0>", "<0 candidates>"):
print("WARNING: dropping %s" % line)
changes += 1
continue
if clb_int:
zero_range(bits, 22, 25)
zero_groups(bits, zero_db, strict=not clb_int, verbose=verbose)
zero_groups(
tag, bits, zero_db, strict=not clb_int, verbose=verbose)
new_line = " ".join([tag] + sorted(bits))
if new_line != line:
@ -143,7 +154,7 @@ def add_zero_bits(db_root, tile_type, zero_db, clb_int=False, verbose=False):
new_lines.add(new_line)
llast = line
with open(dbfile, "w") as f:
with open(fn_out, "w") as f:
for line in sorted(new_lines):
print(line, file=f)
@ -200,31 +211,16 @@ def load_zero_db(fn):
return ret
def run(
db_root,
clb_int=False,
zero_db_fn=None,
zero_tile_types=None,
verbose=False):
if clb_int:
zero_db = clb_int_zero_db
# clblx is used by the CLB fuzzers before being expanded to DB
zero_tile_types = [
"int_l", "int_r", "clbll_l", "clbll_r", "clblm_l", "clblm_r",
"clblx"
]
else:
assert zero_db_fn
assert zero_tile_types
zero_db = load_zero_db(zero_db_fn)
print("CLB INT mode: %s" % clb_int)
print("Segbit groups: %s" % len(zero_db))
def update_seg_fns(fn_inouts, zero_db, clb_int, lazy=False, verbose=False):
seg_files = 0
seg_lines = 0
for tile_type in zero_tile_types:
for fn_in, fn_out in fn_inouts:
verbose and print("zb %s: %s" % (fn_in, os.path.exists(fn_in)))
if lazy and not os.path.exists(fn_in):
continue
changes = add_zero_bits(
db_root, tile_type, zero_db, clb_int=clb_int, verbose=verbose)
fn_in, fn_out, zero_db, clb_int=clb_int, verbose=verbose)
if changes is not None:
seg_files += 1
seg_lines += changes
@ -232,31 +228,80 @@ def run(
"Segbit: checked %u files w/ %u changed lines" %
(seg_files, seg_lines))
def update_masks(db_root):
for mask_db, src_dbs in [
("clbll_l", ("clbll_l", "int_l")),
("clbll_r", ("clbll_r", "int_r")),
("clblm_l", ("clblm_l", "int_l")),
("clblm_r", ("clblm_r", "int_r")),
("hclk_l", ("hclk_l", )),
("hclk_r", ("hclk_r", )),
("bram_l", ("bram_l", )),
("bram_r", ("bram_r", )),
("dsp_l", ("dsp_l", )),
("dsp_r", ("dsp_r", )),
]:
update_mask(db_root, mask_db, src_dbs)
for mask_db, src_dbs in [
("bram_l", ("int_l", )),
("bram_r", ("int_r", )),
("dsp_l", ("int_l", )),
("dsp_r", ("int_r", )),
]:
for k in range(5):
update_mask(db_root, mask_db, src_dbs, offset=64 * k)
print("Mask: checked files")
def update_segs(
db_root, clb_int, seg_fn_in, seg_fn_out, zero_db_fn, verbose=False):
if clb_int:
for mask_db, src_dbs in [
("clbll_l", ("clbll_l", "int_l")),
("clbll_r", ("clbll_r", "int_r")),
("clblm_l", ("clblm_l", "int_l")),
("clblm_r", ("clblm_r", "int_r")),
("hclk_l", ("hclk_l", )),
("hclk_r", ("hclk_r", )),
("bram_l", ("bram_l", )),
("bram_r", ("bram_r", )),
("dsp_l", ("dsp_l", )),
("dsp_r", ("dsp_r", )),
]:
update_mask(db_root, mask_db, src_dbs)
zero_db = clb_int_zero_db
lazy = True
for mask_db, src_dbs in [
("bram_l", ("int_l", )),
("bram_r", ("int_r", )),
("dsp_l", ("int_l", )),
("dsp_r", ("int_r", )),
]:
for k in range(5):
update_mask(db_root, mask_db, src_dbs, offset=64 * k)
def gen_fns():
for tile_type in ["int_l", "int_r", "clbll_l", "clbll_r",
"clblm_l", "clblm_r"]:
fn = "%s/segbits_%s.db" % (db_root, tile_type)
yield (fn, fn)
print("Mask: checked files")
fn_inouts = list(gen_fns())
else:
assert seg_fn_in
assert zero_db_fn
lazy = False
if not seg_fn_out:
seg_fn_out = seg_fn_in
fn_inouts = [(seg_fn_in, seg_fn_out)]
zero_db = load_zero_db(zero_db_fn)
print("CLB INT mode: %s" % clb_int)
print("Segbit groups: %s" % len(zero_db))
update_seg_fns(fn_inouts, zero_db, clb_int, lazy=lazy, verbose=verbose)
def run(
db_root,
clb_int=False,
zero_db_fn=None,
seg_fn_in=None,
seg_fn_out=None,
verbose=False):
# Probably should split this into two programs
update_segs(
db_root,
clb_int=clb_int,
seg_fn_in=seg_fn_in,
seg_fn_out=seg_fn_out,
zero_db_fn=zero_db_fn,
verbose=verbose)
if clb_int:
update_masks()
def main():
@ -269,16 +314,13 @@ def main():
parser.add_argument(
'--clb-int', action='store_true', help='Fixup CLB interconnect')
parser.add_argument('--zero-db', help='Apply custom patches')
parser.add_argument('--zero-tile-types', help='')
parser.add_argument('--seg-fn-in', help='')
parser.add_argument('--seg-fn-out', help='')
args = parser.parse_args()
# XXX: can auto detect this?
zero_tile_types = args.zero_tile_types.split(
",") if args.zero_tile_types else None
run(
args.db_root, args.clb_int, args.zero_db, zero_tile_types,
args.verbose)
args.db_root, args.clb_int, args.zero_db, args.seg_fn_in,
args.seg_fn_out, args.verbose)
if __name__ == '__main__':