Add PyTest suite for Siracusa and Siracusa Tiled

Author: Victor-Jung

Deeploy/TilingExtension/TilerExtension.py

@@ -52,7 +52,7 @@ class Tiler():
     _MINIMALLOC_OUTPUT_FILENAME = "output_minimalloc"
 
     # Initialize with the list of TemplateTCFbinding
-    def __init__(self, memoryHierarchy: MemoryHierarchy):
+    def __init__(self, memoryHierarchy: MemoryHierarchy, testName: Optional[str] = None, workDir: Optional[str] = None):
 
         self.memoryHierarchy = memoryHierarchy
         self.tilerModel: Optional[TilerModel] = None
@@ -66,6 +66,23 @@ def __init__(self, memoryHierarchy: MemoryHierarchy):
         self.memoryAllocStrategy: Literal["TetrisRandom", "TetrisCo-Opt", "MiniMalloc"] = "TetrisRandom"
         self.searchStrategy: Literal["min", "max", "random-max"] = "random-max"
 
+        if workDir is not None:
+            os.makedirs(workDir, exist_ok = True)
+            minimalloc_base = os.path.join(workDir, self._MINIMALLOC_INPUT_FILENAME)
+            minimalloc_output_base = os.path.join(workDir, self._MINIMALLOC_OUTPUT_FILENAME)
+        else:
+            minimalloc_base = self._MINIMALLOC_INPUT_FILENAME
+            minimalloc_output_base = self._MINIMALLOC_OUTPUT_FILENAME
+        
+        if testName is not None:
+            # VJUNG: Sanitize path
+            safe_test_name = testName.replace("/", "_").replace("\\", "_")
+            self._minimalloc_input = f"{minimalloc_base}_{safe_test_name}"
+            self._minimalloc_output = f"{minimalloc_output_base}_{safe_test_name}"
+        else:
+            self._minimalloc_input = minimalloc_base
+            self._minimalloc_output = minimalloc_output_base
+
     @property
     def worstCaseBufferSize(self):
         return self._worstCaseBufferSize
@@ -238,7 +255,7 @@ def _convertCtxtToStaticSchedule(self, ctxt: NetworkContext,
 
     def minimalloc(self, memoryMap, ctxt, nodeMemoryConstraint, capacity: int, memoryLevel: str):
 
-        with open(f"{self._MINIMALLOC_INPUT_FILENAME}.csv", mode = "w", newline = "") as file:
+        with open(f"{self._minimalloc_input}.csv", mode = "w", newline = "") as file:
             writer = csv.writer(file, lineterminator = "\n")
             writer.writerow(["id", "lower", "upper", "size"])
             for memoryBlock in memoryMap:
@@ -273,7 +290,7 @@ def minimalloc(self, memoryMap, ctxt, nodeMemoryConstraint, capacity: int, memor
 
         minimallocOutput = subprocess.run([
             f"{minimallocInstallDir}/minimalloc", f"--capacity={capacity}",
-            f"--input={self._MINIMALLOC_INPUT_FILENAME}.csv", f"--output={self._MINIMALLOC_OUTPUT_FILENAME}.csv"
+            f"--input={self._minimalloc_input}.csv", f"--output={self._minimalloc_output}.csv"
         ],
                                           capture_output = True,
                                           text = True)
@@ -284,7 +301,7 @@ def minimalloc(self, memoryMap, ctxt, nodeMemoryConstraint, capacity: int, memor
             )
             raise subprocess.CalledProcessError(minimallocOutput.returncode, " ".join(minimallocOutput.args))
 
-        with open(f"{self._MINIMALLOC_OUTPUT_FILENAME}.csv", mode = "r", newline = "") as file:
+        with open(f"{self._minimalloc_output}.csv", mode = "r", newline = "") as file:
             reader = csv.reader(file)
             header = next(reader)
             for row in reader:
@@ -944,11 +961,11 @@ def testMemoryMapCorrectness(self, memoryMap: Dict[str, List[List[MemoryBlock]]]
 
 class TilerDeployerWrapper(NetworkDeployerWrapper):
 
-    def __init__(self, deployer: Union[MemoryLevelAwareDeployer, MemoryDeployerWrapper], tilerCls: Type[Tiler] = Tiler):
+    def __init__(self, deployer: Union[MemoryLevelAwareDeployer, MemoryDeployerWrapper], tilerCls: Type[Tiler] = Tiler, testName: Optional[str] = None, workDir: Optional[str] = None):
         super().__init__(deployer)
         assert isinstance(self.Platform, (MemoryPlatform, MemoryPlatformWrapper)), \
             f"Platform should be a MemoryPlatform or MemoryPlatformWrapper! Got {type(self.Platform).__name__}"
-        self.tiler = tilerCls(self.Platform.memoryHierarchy)
+        self.tiler = tilerCls(self.Platform.memoryHierarchy, testName = testName, workDir = workDir)
 
     @property
     def worstCaseBufferSize(self):

DeeployTest/conftest.py

@@ -51,8 +51,14 @@ def pytest_configure(config: pytest.Config) -> None:
     # Register custom markers
     config.addinivalue_line("markers", "generic: mark test as a Generic platform test")
     config.addinivalue_line("markers", "cortexm: mark test as a Cortex-M (QEMU-ARM) platform test")
+    config.addinivalue_line("markers", "siracusa: mark test as a Siracusa platform test (untiled)")
+    config.addinivalue_line("markers", "siracusa_tiled: mark test as a Siracusa platform test (tiled)")
     config.addinivalue_line("markers", "kernels: mark test as a kernel test (individual operators)")
     config.addinivalue_line("markers", "models: mark test as a model test (full networks)")
+    config.addinivalue_line("markers", "singlebuffer: mark test as single-buffer configuration")
+    config.addinivalue_line("markers", "doublebuffer: mark test as double-buffer configuration")
+    config.addinivalue_line("markers", "l2: mark test as L2 default memory level")
+    config.addinivalue_line("markers", "l3: mark test as L3 default memory level")
     config.addinivalue_line("markers", "slow: mark test as slow running")
 
     # Configure logging based on verbosity

DeeployTest/testMVP.py

@@ -5,6 +5,7 @@
 import argparse
 import os
 import sys
+import hashlib
 from collections import OrderedDict
 from typing import List, Tuple
 
@@ -115,14 +116,18 @@ def setupDeployer(graph: gs.Graph, memoryHierarchy: MemoryHierarchy, defaultTarg
     deployer = MemoryDeployerWrapper(deployer, memoryLevelAnnotationPasses)
 
     # Make the deployer tiler aware
+    # VJUNG: Create unique ID for the IO files of minimalloc and prevent conflict in case of parallel execution
+    unique_params = f"{args.dumpdir}_L1{args.l1}_L2{args.l2}_{args.defaultMemLevel}_DB{args.doublebuffer}"
+    testIdentifier = hashlib.md5(unique_params.encode()).hexdigest()[:16]
+    
     if args.doublebuffer:
         assert args.defaultMemLevel in ["L3", "L2"]
         if args.defaultMemLevel == "L3":
-            deployer = TilerDeployerWrapper(deployer, DBOnlyL3Tiler)
+            deployer = TilerDeployerWrapper(deployer, DBOnlyL3Tiler, testName = testIdentifier, workDir = args.dumpdir)
         else:
-            deployer = TilerDeployerWrapper(deployer, DBTiler)
+            deployer = TilerDeployerWrapper(deployer, DBTiler, testName = testIdentifier, workDir = args.dumpdir)
     else:
-        deployer = TilerDeployerWrapper(deployer, SBTiler)
+        deployer = TilerDeployerWrapper(deployer, SBTiler, testName = testIdentifier, workDir = args.dumpdir)
 
     deployer.tiler.visualizeMemoryAlloc = args.plotMemAlloc
     deployer.tiler.memoryAllocStrategy = args.memAllocStrategy

DeeployTest/testUtils/pytestRunner.py

@@ -6,6 +6,7 @@
 import re
 import shutil
 import subprocess
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from typing import List, Literal, Optional, Tuple
@@ -132,10 +133,10 @@ def generate_network(config: DeeployTestConfig, skip: bool = False) -> None:
 
     log.debug(f"[pytestRunner] Generation command: {' '.join(cmd)}")
 
-    result = subprocess.run(cmd, capture_output = True, text = True)
+    result = subprocess.run(cmd, check = False)
 
     if result.returncode != 0:
-        log.error(f"Network generation failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
+        log.error(f"Network generation failed with return code {result.returncode}")
         raise RuntimeError(f"Network generation failed for {config.test_name}")
 
 
@@ -192,10 +193,10 @@ def configure_cmake(config: DeeployTestConfig) -> None:
 
     log.debug(f"[pytestRunner] CMake command: {' '.join(cmd)}")
 
-    result = subprocess.run(cmd, capture_output = True, text = True, env = env)
+    result = subprocess.run(cmd, check = False, env = env)
 
     if result.returncode != 0:
-        log.error(f"CMake configuration failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
+        log.error(f"CMake configuration failed with return code {result.returncode}")
         raise RuntimeError(f"CMake configuration failed for {config.test_name}")
 
 
@@ -223,10 +224,10 @@ def build_binary(config: DeeployTestConfig) -> None:
 
     log.debug(f"[pytestRunner] Build command: {' '.join(cmd)}")
 
-    result = subprocess.run(cmd, capture_output = True, text = True, env = env)
+    result = subprocess.run(cmd, check = False, env = env)
 
     if result.returncode != 0:
-        log.error(f"Build failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
+        log.error(f"Build failed with return code {result.returncode}")
         raise RuntimeError(f"Build failed for {config.test_name}")
 
 
@@ -281,6 +282,12 @@ def run_simulation(config: DeeployTestConfig, skip: bool = False) -> TestResult:
 
     result = subprocess.run(cmd, capture_output = True, text = True, env = env)
 
+    # Print captured output so it's visible when running with pytest -s
+    if result.stdout:
+        print(result.stdout, end = '')
+    if result.stderr:
+        print(result.stderr, end = '', file = sys.stderr)
+
     # Parse output for error count
     output = result.stdout + result.stderr
 
@@ -362,19 +369,39 @@ def create_test_config(
     toolchain_dir: Optional[str],
     cmake_args: List[str],
     tiling: bool = False,
+    cores: Optional[int] = None,
+    l1: Optional[int] = None,
+    l2: int = 1024000,
+    default_mem_level: str = "L2",
+    double_buffer: bool = False,
+    mem_alloc_strategy: str = "MiniMalloc",
+    search_strategy: str = "random-max",
+    profile_tiling: bool = False,
+    plot_mem_alloc: bool = False,
+    randomized_mem_scheduler: bool = False,
 ) -> DeeployTestConfig:
     """
     Create DeeployTestConfig for a specific test and platform.
     
     Args:
         test_name: Name of the test
-        platform: Target platform (e.g., "Generic", "QEMU-ARM")
+        platform: Target platform (e.g., "Generic", "QEMU-ARM", "Siracusa")
         simulator: Simulator to use
         deeploy_test_dir: Base DeeployTest directory
         toolchain: Toolchain to use - LLVM/GCC
         toolchain_dir: Path to toolchain installation
         cmake_args: Additional CMake arguments
         tiling: Whether to use tiling
+        cores: Number of cores (for Siracusa platforms)
+        l1: L1 memory size in bytes (for tiled platforms)
+        l2: L2 memory size in bytes (default: 1024000)
+        default_mem_level: Default memory level ("L2" or "L3")
+        double_buffer: Enable double buffering
+        mem_alloc_strategy: Memory allocation strategy
+        search_strategy: CP solver search strategy
+        profile_tiling: Enable tiling profiling
+        plot_mem_alloc: Enable memory allocation plotting
+        randomized_mem_scheduler: Enable randomized memory scheduler
         
     Returns:
         DeeployTestConfig instance
@@ -384,7 +411,39 @@ def create_test_config(
     gen_dir, test_dir_abs, test_name_clean = get_test_paths(test_dir, platform, base_dir = deeploy_test_dir)
 
     worker_id = get_worker_id()
-    build_dir = str(Path(deeploy_test_dir) / f"TEST_{platform.upper()}" / f"build_{worker_id}")
+    
+    # VJUNG: Build dir has to be unique for each worker to prevent conflict
+    build_suffix = Path(gen_dir).name
+    build_dir = str(Path(deeploy_test_dir) / f"TEST_{platform.upper()}" / f"build_{worker_id}_{build_suffix}")
+
+    cmake_args_list = list(cmake_args) if cmake_args else []
+    if cores is not None:
+        cmake_args_list.append(f"NUM_CORES={cores}")
+
+    gen_args_list = []
+    
+    if cores is not None and platform in ["Siracusa", "Siracusa_w_neureka"]:
+        gen_args_list.append(f"--cores={cores}")
+    
+    if tiling:
+        if l1 is not None:
+            gen_args_list.append(f"--l1={l1}")
+        if l2 != 1024000:
+            gen_args_list.append(f"--l2={l2}")
+        if default_mem_level != "L2":
+            gen_args_list.append(f"--defaultMemLevel={default_mem_level}")
+        if double_buffer:
+            gen_args_list.append("--doublebuffer")
+        if mem_alloc_strategy != "MiniMalloc":
+            gen_args_list.append(f"--memAllocStrategy={mem_alloc_strategy}")
+        if search_strategy != "random-max":
+            gen_args_list.append(f"--searchStrategy={search_strategy}")
+        if profile_tiling:
+            gen_args_list.append("--profileTiling")
+        if plot_mem_alloc:
+            gen_args_list.append("--plotMemAlloc")
+        if randomized_mem_scheduler:
+            gen_args_list.append("--randomizedMemoryScheduler")
 
     config = DeeployTestConfig(
         test_name = test_name_clean,
@@ -396,7 +455,8 @@ def create_test_config(
         build_dir = build_dir,
         toolchain = toolchain,
         toolchain_install_dir = toolchain_dir,
-        cmake_args = cmake_args,
+        cmake_args = cmake_args_list,
+        gen_args = gen_args_list,
     )
 
     return config