Merge pull request #216 from mcmasterg/segprint_cleanup

Segprint cleanup

prjxray/db.py

@@ -25,14 +25,15 @@ def get_available_databases(prjxray_root):
 
 
 class Database(object):
-    def __init__(self, db_root):
+    def __init__(self, db_root=None):
         """ Create project x-ray Database at given db_root.
 
     db_root: Path to directory containing settings.sh, *.db, tilegrid.json and
              tileconn.json
 
     """
-        self.db_root = db_root
+        self.db_root = db_root or os.path.join(
+            os.getenv("XRAY_DATABASE_DIR"), os.getenv("XRAY_DATABASE"))
         self.tilegrid = None
         self.tileconn = None
         self.tile_types = None

utils/segprint.py

@@ -6,6 +6,7 @@ This output is intended for debugging and not directly related to FASM
 
 import sys, os, json, re
 from prjxray import bitstream
+from prjxray import db as prjxraydb
 
 
 class NoDB(Exception):
@@ -18,26 +19,20 @@ segbitsdb = dict()
 
 # int and sites are loaded together so that bit coverage can be checked together
 # however, as currently written, each segment is essentially printed twice
-def process_db(tile_type, process):
-    fns = [
-        # sites
-        "%s/%s/segbits_%s.db" % (
-            os.getenv("XRAY_DATABASE_DIR"), os.getenv("XRAY_DATABASE"),
-            tile_type.lower()),
-        # interconnect
-        "%s/%s/segbits_int_%s.db" % (
-            os.getenv("XRAY_DATABASE_DIR"), os.getenv("XRAY_DATABASE"),
-            tile_type[-1].lower()),
-    ]
+def process_db(db, tile_type, process, verbose):
+    print(db.get_tile_types())
+    ttdb = db.get_tile_type(tile_type)
 
+    fns = [ttdb.tile_dbs.segbits, ttdb.tile_dbs.ppips]
+    verbose and print("process_db(%s): %s" % (tile_type, fns))
     for fn in fns:
-        if os.path.exists(fn):
+        if fn:
             with open(fn, "r") as f:
                 for line in f:
                     process(line)
 
 
-def get_database(tile_type):
+def get_database(db, tile_type, verbose=False):
     tags = list()
 
     if tile_type in segbitsdb:
@@ -46,7 +41,7 @@ def get_database(tile_type):
     def process(l):
         tags.append(l.split())
 
-    process_db(tile_type, process)
+    process_db(db, tile_type, process, verbose=verbose)
 
     if len(tags) == 0:
         raise NoDB(tile_type)
@@ -75,7 +70,7 @@ def mk_segbits(seginfo, bitdata):
     return segbits
 
 
-def print_unknown_bits(grid, bitdata):
+def print_unknown_bits(segments, bitdata):
     '''
     Print bits not covered by known tiles
     '''
@@ -84,7 +79,7 @@ def print_unknown_bits(grid, bitdata):
     # seggrames[address] = set()
     # where set contains word numbers
     segframes = dict()
-    for segname, segdata in grid["segments"].items():
+    for segname, segdata in segments.items():
         framebase = int(segdata["baseaddr"][0], 16)
         for i in range(segdata["frames"]):
             words = segframes.setdefault(framebase + i, set())
@@ -120,7 +115,7 @@ def tag_matched(entry, segbits):
 decode_warnings = set()
 
 
-def seg_decode(flag_decode_emit, seginfo, segbits, verbose=False):
+def seg_decode(flag_decode_emit, db, seginfo, segbits, verbose=False):
     segtags = set()
 
     # already failed?
@@ -128,7 +123,7 @@ def seg_decode(flag_decode_emit, seginfo, segbits, verbose=False):
         return segtags
 
     try:
-        for entry in get_database(seginfo["type"]):
+        for entry in get_database(db, seginfo["type"], verbose=verbose):
             if not tagmatch(entry, segbits):
                 continue
             tag_matched(entry, segbits)
@@ -142,8 +137,9 @@ def seg_decode(flag_decode_emit, seginfo, segbits, verbose=False):
 
 
 def handle_segment(
+        db,
         segname,
-        grid,
+        segments,
         bitdata,
         flag_decode_emit,
         flag_decode_omit,
@@ -153,15 +149,15 @@ def handle_segment(
     assert segname
 
     # only print bitstream tiles
-    if segname not in grid["segments"]:
+    if segname not in segments:
         return
-    seginfo = grid["segments"][segname]
+    seginfo = segments[segname]
 
     segbits = mk_segbits(seginfo, bitdata)
 
     if flag_decode_emit or flag_decode_omit:
         segtags = seg_decode(
-            flag_decode_emit, seginfo, segbits, verbose=verbose)
+            flag_decode_emit, db, seginfo, segbits, verbose=verbose)
     else:
         segtags = set()
 
@@ -179,23 +175,16 @@ def handle_segment(
         print("tag %s" % tag)
 
 
-def mk_grid():
-    '''Load tilegrid, flattening all blocks into one dictionary'''
+def mk_segments(tiles):
+    segments = {}
 
-    with open("%s/%s/tilegrid.json" % (os.getenv("XRAY_DATABASE_DIR"),
-                                       os.getenv("XRAY_DATABASE")), "r") as f:
-        new_grid = json.load(f)
-
-    # TODO: Migrate to new tilegrid format via library.
-    grid = {'tiles': new_grid, 'segments': {}}
-
-    for tile_name, tile in grid['tiles'].items():
+    for tile_name, tile in tiles.items():
         bits = tile.get('bits', None)
         if not bits:
             continue
         for block_name, block in bits.items():
             segname = mksegment(tile_name, block_name)
-            grid['segments'][segname] = {
+            segments[segname] = {
                 'baseaddr': [
                     block['baseaddr'],
                     block['offset'],
@@ -206,7 +195,16 @@ def mk_grid():
                 'tile_name': tile_name,
                 'block_name': block_name,
             }
-    return grid
+    return segments
+
+
+def mk_grid():
+    with open("%s/%s/tilegrid.json" % (os.getenv("XRAY_DATABASE_DIR"),
+                                       os.getenv("XRAY_DATABASE")), "r") as f:
+        tiles = json.load(f)
+    '''Load tilegrid, flattening all blocks into one dictionary'''
+    # TODO: Migrate to new tilegrid format via library.
+    return tiles, mk_segments(tiles)
 
 
 def mksegment(tile_name, block_name):
@@ -214,9 +212,9 @@ def mksegment(tile_name, block_name):
     return '%s:%s' % (tile_name, block_name)
 
 
-def tile_segnames(grid):
+def tile_segnames(tiles):
     ret = []
-    for tile_name, tile in grid['tiles'].items():
+    for tile_name, tile in tiles.items():
         if 'bits' not in tile:
             continue
 
@@ -233,12 +231,13 @@ def run(
         flag_decode_emit=False,
         flag_decode_omit=False,
         verbose=False):
-    grid = mk_grid()
+    tiles, segments = mk_grid()
+    db = prjxraydb.Database()
 
     bitdata = bitstream.load_bitdata2(open(bits_file, "r"))
 
     if flag_unknown_bits:
-        print_unknown_bits(grid, bitdata)
+        print_unknown_bits(segments, bitdata)
 
     # Default: print all
     if segnames:
@@ -247,15 +246,16 @@ def run(
             if ':' not in segname:
                 segnames[i] = mksegment(segname, 'CLB_IO_CLK')
     else:
-        segnames = sorted(tile_segnames(grid))
+        segnames = sorted(tile_segnames(tiles))
     print('Segments: %u' % len(segnames))
 
     # XXX: previously this was sorted by address, not name
     # revisit?
     for segname in segnames:
         handle_segment(
+            db,
             segname,
-            grid,
+            segments,
             bitdata,
             flag_decode_emit,
             flag_decode_omit,