[DRAFT] Spatz integration

Deeploy/Targets/Spatz/Deployer.py

@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: 2023 ETH Zurich and University of Bologna
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Callable, Dict, Type
+
+import onnx_graphsurgeon as gs
+
+from Deeploy.AbstractDataTypes import Pointer
+from Deeploy.CommonExtensions.NetworkDeployers.SignPropDeployer import SignPropDeployer
+from Deeploy.CommonExtensions.OptimizationPasses.TopologyOptimizationPasses.DebugPasses import DebugPrintMergePass
+from Deeploy.CommonExtensions.OptimizationPasses.TopologyOptimizationPasses.LoweringOptimizationPasses import \
+    NCHWtoNHWCPass, TransposeMatmulInputsPass
+from Deeploy.DeeployTypes import DeploymentPlatform, TopologyOptimizer
+from Deeploy.Targets.Generic.TopologyOptimizationPasses.Passes import TransposeConstOptPass, TransposeMergePass
+
+
+class SpatzDeployer(SignPropDeployer):
+
+    def __init__(self,
+                 graph: gs.Graph,
+                 deploymentPlatform: DeploymentPlatform,
+                 inputTypes: Dict[str, Type[Pointer]],
+                 loweringOptimizer: TopologyOptimizer,
+                 scheduler: Callable = lambda x: x,
+                 name: str = 'DeeployNetwork',
+                 default_channels_first = False,
+                 deeployStateDir: str = "DeeployStateDir",
+                 inputOffsets: Dict[str, int] = {}):
+
+        super().__init__(graph,
+                         deploymentPlatform,
+                         inputTypes,
+                         loweringOptimizer,
+                         scheduler,
+                         name,
+                         default_channels_first = default_channels_first,
+                         deeployStateDir = deeployStateDir)
+
+#         self.inputOffsets = inputOffsets
+# 
+#         self.loweringOptimizer.passes += [
+#             TransposeMatmulInputsPass(),
+#             NCHWtoNHWCPass(self.default_channels_first),
+#             TransposeMergePass(),
+#             TransposeConstOptPass(),
+#             DebugPrintMergePass()
+#         ]

Deeploy/Targets/Spatz/Platform.py

@@ -0,0 +1,71 @@
+from typing import List
+
+from Deeploy.DeeployTypes import VariableBuffer, TransientBuffer, ConstantBuffer, StructBuffer, \
+    NodeMapper, NodeTemplate, TopologyOptimizer, DeploymentEngine, DeploymentPlatform
+
+# from Deeploy.Targets.Spatz.Bindings import SpatzAddBindings # <- TODO create this
+from Deeploy.Targets.Generic.Bindings import BasicAddBindings
+from Deeploy.Targets.Generic.Layers import AddLayer
+from Deeploy.Targets.Generic.Parsers import AddParser
+
+# TODO delete this and use from Deeploy.Targets.Spatz.Templates import AllocateTemplate as SpatzAllocateTemplate
+from Deeploy.Targets.Generic.Templates import AllocateTemplate as GenericAllocateTemplate
+from Deeploy.Targets.Generic.Templates import FreeTemplate as GenericFreeTemplate
+
+SpatzAddMapper = NodeMapper(AddParser(), BasicAddBindings)
+
+SpatzMapping = {
+    'Add': AddLayer([SpatzAddMapper]),
+    # sparse attention : ...
+}
+
+
+class SpatzaVariableBuffer(VariableBuffer):
+    initTemplate = GenericAllocateTemplate.referenceInitTemplate
+    allocTemplate = GenericAllocateTemplate.referenceAllocateTemplate
+    deallocTemplate = GenericFreeTemplate.referenceLocalTemplate
+
+
+class SpatzTransientBuffer(TransientBuffer):
+    initTemplate = GenericAllocateTemplate.referenceInitTemplate
+    allocTemplate = GenericAllocateTemplate.referenceAllocateTemplate
+    deallocTemplate = GenericFreeTemplate.referenceLocalTemplate
+
+
+class SpatzConstantBuffer(ConstantBuffer):
+    initTemplate = GenericAllocateTemplate.referenceGlobalInitTemplate
+    allocTemplate = GenericAllocateTemplate.referenceGlobalAllocateTemplate
+    deallocTemplate = NodeTemplate("") # const not deallocated
+
+
+class SpatzStructBuffer(StructBuffer):
+    initTemplate = GenericAllocateTemplate.referenceStructInitTemplate
+    allocTemplate = GenericAllocateTemplate.referenceStructAllocateTemplate
+    deallocTemplate = NodeTemplate("") # struct not deallocated ?
+
+
+SpatzOptimizer = TopologyOptimizer([
+    # TODO add something ?
+], name = "SpatzOptimizer")
+
+includeList = [
+    # TODO ???
+]
+
+
+class SpatzEngine(DeploymentEngine):
+    def __init__(self, name: str, Mapping = SpatzMapping, initCode = "", includeList = includeList) -> None:
+        super().__init__(name, Mapping, initCode, includeList)
+
+
+class SpatzPlatform(DeploymentPlatform):
+
+    def __init__( self,
+        engines = [SpatzEngine("SpatzVectorProcessor")],
+        variableBuffer = SpatzaVariableBuffer,
+        transientBuffer = SpatzTransientBuffer,
+        constantBuffer = SpatzConstantBuffer,
+        structBuffer = SpatzStructBuffer,
+        includeList: List[str] = includeList
+    ):
+        super().__init__(engines, variableBuffer, constantBuffer, structBuffer, transientBuffer)

DeeployTest/Platforms/Spatz/main.c

@@ -0,0 +1,69 @@
+
+#include <stdint.h>
+#include <string.h>
+#include "printf.h"
+
+#include "Network.h"
+#include "testinputs.h"
+#include "testoutputs.h"
+
+int main() {
+  const unsigned int cid = snrt_cluster_core_idx();
+
+  // do it only with one of the two spatz cores
+  if (cid==0){
+    printf("Initializing network...\r\n");
+
+    InitNetwork(0, 1);
+
+    for (uint32_t buf = 0; buf < DeeployNetwork_num_inputs; buf++) {
+      snrt_dma_start_1d(DeeployNetwork_inputs[buf], testInputVector[buf], DeeployNetwork_inputs_bytes[buf]);
+    }
+
+    printf("Running network...\r\n");
+    RunNetwork(0, 1);
+
+    int32_t tot_err = 0;
+    uint32_t tot = 0;
+    OUTPUTTYPE diff;
+    OUTPUTTYPE expected, actual;
+
+    for (uint32_t buf = 0; buf < DeeployNetwork_num_outputs; buf++) {
+      tot += DeeployNetwork_outputs_bytes[buf] / sizeof(OUTPUTTYPE);
+      for (uint32_t i = 0;
+          i < DeeployNetwork_outputs_bytes[buf] / sizeof(OUTPUTTYPE); i++) {
+        expected = ((OUTPUTTYPE *)testOutputVector[buf])[i];
+        actual = ((OUTPUTTYPE *)DeeployNetwork_outputs[buf])[i];
+        diff = expected - actual;
+
+#if ISOUTPUTFLOAT == 1
+        // RUNWANG: Allow margin of error for float32_t
+        if ((diff < -1e-4) || (diff > 1e-4)) {
+          tot_err += 1;
+          printf("Expected: %10.6f  ", (float)expected);
+          printf("Actual: %10.6f  ", (float)actual);
+          printf("Diff: %10.6f at Index %12u in Output %u\r\n", (float)diff, i,
+                buf);
+        }
+#else
+        // RUNWANG: No margin for integer comparison
+        if (diff != 0) {
+          tot_err += 1;
+          printf("Expected: %4d  ", expected);
+          printf("Actual: %4d  ", actual);
+          printf("Diff: %4d at Index %12u in Output %u\r\n", diff, i, buf);
+        }
+#endif
+      }
+    }
+
+    printf("Errors: %d out of %d \r\n", tot_err, tot);
+
+    return tot_err;
+  } else {
+    // wait for core 0 to finish
+    snrt_cluster_hw_barrier();
+    return 0;
+  }
+
+}

DeeployTest/testUtils/platformMapping.py

@@ -10,6 +10,8 @@
 from Deeploy.DeeployTypes import DeploymentPlatform, NetworkDeployer, TopologyOptimizer
 from Deeploy.MemoryLevelExtension.MemoryLevels import MemoryHierarchy, MemoryLevel
 from Deeploy.MemoryLevelExtension.NetworkDeployers.MemoryLevelDeployer import MemoryPlatform, MemoryPlatformWrapper
+from Deeploy.Targets.Spatz.Deployer import SpatzDeployer
+from Deeploy.Targets.Spatz.Platform import SpatzOptimizer, SpatzPlatform
 from Deeploy.Targets.Chimera.Deployer import ChimeraDeployer
 from Deeploy.Targets.Chimera.Platform import ChimeraOptimizer, ChimeraPlatform
 from Deeploy.Targets.CortexM.Deployer import CMSISDeployer
@@ -31,7 +33,7 @@
 from Deeploy.Targets.SoftHier.Platform import SoftHierOptimizer, SoftHierPlatform
 
 _SIGNPROP_PLATFORMS = ["Apollo3", "Apollo4", "QEMU-ARM", "Generic", "MemPool", "SoftHier"]
-_NONSIGNPROP_PLATFORMS = ["Siracusa", "Siracusa_w_neureka", "PULPOpen", "Snitch", "Chimera", "GAP9"]
+_NONSIGNPROP_PLATFORMS = ["Siracusa", "Siracusa_w_neureka", "PULPOpen", "Snitch", "Chimera", "GAP9", "Spatz"]
 _PLATFORMS = _SIGNPROP_PLATFORMS + _NONSIGNPROP_PLATFORMS
 
 
@@ -76,6 +78,9 @@ def mapPlatform(platformName: str) -> Tuple[DeploymentPlatform, bool]:
     elif platformName == "Chimera":
         Platform = ChimeraPlatform()
 
+    elif platformName == "Spatz":
+        Platform = SpatzPlatform()
+
     else:
         raise RuntimeError(f"Deployment platform {platformName} is not implemented")
 
@@ -272,6 +277,18 @@ def mapDeployer(platform: DeploymentPlatform,
                                    name = name,
                                    default_channels_first = default_channels_first,
                                    deeployStateDir = deeployStateDir)
+
+    elif isinstance(platform, (SpatzPlatform)):
+        deployer = SpatzDeployer(
+            graph,
+            platform,
+            inputTypes,
+            SpatzOptimizer,
+            scheduler,
+            name = name,
+            default_channels_first = default_channels_first,
+            deeployStateDir = deeployStateDir
+        )
 
     else:
         raise RuntimeError(f"Deployer for platform {platform} is not implemented")

TargetLibraries/Spatz/inc/utils.h

@@ -0,0 +1,2 @@
+#include <stddef.h>
+void *deeploy_malloc(const size_t size) ;

TargetLibraries/Spatz/src/Util.c

@@ -0,0 +1,3 @@
+#include "utils.h"
+
+void *deeploy_malloc(const size_t size) { return snrt_l1alloc(size); }