update

Author: KelvinChung2000

FABulous/FABulous.py

@@ -146,7 +146,7 @@ def main():
 
     args = parser.parse_args()
 
-    setup_logger(args.verbose)
+    setup_logger(args.verbose, True)
 
     setup_global_env_vars(args)
 

FABulous/FABulous_CLI/helper.py

@@ -13,35 +13,51 @@
 
 MAX_BITBYTES = 16384
 
+def setup_logger(verbosity: int, debug: bool, log_file: Path = Path()):
+    # Remove the default logger to avoid duplicate logs
+    logger.remove()
 
-def error_callback(msg):
-    raise Exception
+    # Define a custom formatting function that has access to 'verbosity'
+    def custom_format_function(record):
+        # Construct the standard part of the log message based on verbosity
+        level = f"<level>{record['level'].name}</level> | "
+        time = f"<cyan>[{record['time']:DD-MM-YYYY HH:mm:ss}]</cyan> | "
+        name = f"<green>[{record['name']}</green>"
+        func = f"<green>{record['function']}</green>"
+        line = f"<green>{record['line']}</green>"
+        msg = f"<level>{record['message']}</level>"
+        exc = (
+            f"<bg red><white>{record['exception'].type.__name__}</white></bg red> | "
+            if record["exception"]
+            else ""
+        )
 
+        if verbosity >= 1:
+            final_log = f"{level}{time}{name}:{func}:{line} - {exc}{msg}\n"
+        else:
+            final_log = f"{level}{exc}{msg}\n"
 
-def setup_logger(verbosity: int):
-    # Remove the default logger to avoid duplicate logs
-    logger.remove()
+        if os.getenv("FABULOUS_TESTING", None):
+            final_log = f"{record['level'].name}: {record['message']}\n"
+
+        return final_log
+
+    # Determine the log level for the sink
+    log_level_to_set = "DEBUG" if debug else "INFO"
 
-    # Define logger format
-    if verbosity >= 1:
-        log_format = (
-            "<level>{level:}</level> | "
-            "<cyan>[{time:DD-MM-YYYY HH:mm:ss]}</cyan> | "
-            "<green>[{name}</green>:<green>{function}</green>:<green>{line}]</green> - "
-            "<level>{message}</level>"
+    # Add logger to write logs to stdout using the custom formatter
+    if log_file != Path():
+        logger.add(
+            log_file, format=custom_format_function, level=log_level_to_set, catch=False
         )
     else:
-        log_format = "<level>{level:}</level> | <level>{message}</level>"
-
-    # Add logger to write logs to stdout
-    logger.add(sys.stdout, format=log_format, level="DEBUG", colorize=True, catch=False)
-    logger.add(
-        error_callback,
-        format=log_format,
-        colorize=True,
-        catch=False,
-        filter=lambda msg: msg["level"].name == "ERROR",
-    )
+        logger.add(
+            sys.stdout,
+            format=custom_format_function,
+            level=log_level_to_set,
+            colorize=True,
+            catch=False,
+        )
 
 
 def setup_global_env_vars(args: argparse.Namespace) -> None:

FABulous/fabric_cad/chip_database_generator.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from itertools import islice
 from pathlib import Path
 from subprocess import run
@@ -11,6 +12,7 @@
 from FABulous.fabric_cad.chip_database.database_timing import TimingValue
 from FABulous.fabric_cad.chip_database.define import NodeWire, PinType
 from FABulous.fabric_cad.graph_draw import genRoutingResourceGraph
+from FABulous.fabric_definition.Wire import WireType
 from FABulous.fabric_definition.define import IO, Loc
 from FABulous.fabric_definition.Fabric import Fabric
 from FABulous.fabric_definition.Port import BelPort, TilePort
@@ -249,37 +251,52 @@ def genTile(tile: Tile, subTile: str, chip: Chip, context=1) -> TileType:
     return tt
 
 
-# change to base on wire type
+# TODO: fix for terminal ports
 def genFabric(fabric: Fabric, chip: Chip, context=1):
     def clipX(value):
         return max(0, min(value, fabric.width - 1))
 
     def clipY(value):
         return max(0, min(value, fabric.height - 1))
-
-    # TODO fix terminal ports
-    for (x, y), wires in fabric.wireDict.items():
-        if not wires:
+    
+    for (x, y), tileName in fabric.tileNames_iter():
+        if tileName is None:
             continue
-        for c in range(context):
-            for wire in wires:
-                for src, dst in zip(wire.source.expand(), wire.destination.expand()):
-                    node = [
-                        NodeWire(
+        
+        tile = fabric.getTileByName(tileName)
+        print(tileName)
+        shareDest:dict[TilePort | BelPort, list[WireType]] = defaultdict(list) 
+        for wireType in tile.wireTypes[tileName]:
+            assert wireType.destinationPort.width == wireType.sourcePort.width
+            shareDest[wireType.sourcePort].append(wireType)
+            
+        print(shareDest)
+        for src, destList in shareDest.items():
+            nodes = []
+            for c in range(context):
+                for n in src.expand():
+                    nodes.append(
+                        [NodeWire(
                             clipX(x),
                             clipY(y),
-                            f"c{c}.{src}",
-                        ),
-                        NodeWire(
-                            clipX(x + wire.xOffset),
-                            clipY(y + wire.yOffset),
-                            f"c{c}.{dst}",
-                        ),
-                    ]
-                    chip.add_node(node, "DEFAULT")
+                            f"c{c}.{n}",
+                        )]
+                    )
+                print(destList)
+                for dest in destList:
+                    for i, n in enumerate(dest.destinationPort.expand()):
+                        nodes[i].append(
+                            NodeWire(
+                                clipX(x + dest.offsetX),
+                                clipY(y + dest.offsetY),
+                                f"c{c}.{n}",
+                            )
+                        )
+            for node in nodes:
+                print(node)
+                chip.add_node(node, "DEFAULT")
     setTiming(chip)
 
-
 def setTiming(chip: Chip):
     speed = "DEFAULT"
     tmg = chip.set_speed_grades([speed])

FABulous/fabric_definition/Fabric.py

@@ -78,6 +78,8 @@ class Fabric:
     superTileDict: dict[str, SuperTile] = field(default_factory=dict)
     wireDict: dict[Loc, list[Wire]] = field(default_factory=dict)
 
+    _subTileToTile: dict[str, Tile] = field(init=False, default_factory=dict)
+
     def __post_init__(self):
         for t in self.tileDict.values():
             if (
@@ -87,11 +89,24 @@ def __post_init__(self):
                 raise ValueError(
                     f"Tile {t.name} has too many config bits. Tile have {self.frameBitsPerRow * self.maxFramesPerCol} but requires {t.configBits*self.contextCount}"
                 )
+            
+        for t in self.tileDict.values():
+            for subTile in t.getSubTiles():
+                if subTile not in self._subTileToTile:
+                    self._subTileToTile[subTile] = t
+                else:
+                    raise ValueError(
+                        f"Subtile {subTile} is defined in multiple tiles: {self._subTileToTile[subTile].name} and {t.name}"
+                    )
 
     def __getitem__(self, index: Any) -> Tile | None:
         if isinstance(index, tuple):
             if t := self.tiles[index[1]][index[0]]:
-                return self.tileDict[t]
+                if t in self.tileDict:
+                    return self.tileDict[t]
+                else:
+                    return self._subTileToTile[t]
+            
             return None
         if isinstance(index, str):
             if index in self.tileDict:
@@ -210,6 +225,18 @@ def getBelByBelPort(self, p: BelPort) -> Bel:
             if tile.isPortInTile(p):
                 return tile.getBelByBelPort(p)
         raise ValueError(f"BelPort {p} not found in any tile")
+    
+    def isSubTile(self, name: str) -> bool:
+        """Check if the given name is a sub-tile in the fabric."""
+        return name in self._subTileToTile
+    
+    def isRootTile(self, name: str) -> bool:
+        for tile in self.tileDict.values():
+            if tile is not None and tile.partOfTile(name):
+                return tile.isRootTile(name)
+        return False
+
+    
 
 
     # def getFlattenFabric(self) -> Generator[tuple[Loc, Tile | None], None, None]: