Explicit Stream Management Passes

dace/codegen/dispatcher.py

@@ -27,6 +27,7 @@ class DefinedType(attr_enum.ExtensibleAttributeEnum):
     Object = auto()  # An object moved by reference
     Stream = auto()  # A stream object moved by reference and accessed via a push/pop API
     StreamArray = auto()  # An array of Streams
+    GPUStream = auto()  # A backend GPU stream handle (e.g., cudaStream_t / hipStream_t)
 
 
 class DefinedMemlets:
@@ -91,7 +92,8 @@ def add(self, name: str, dtype: DefinedType, ctype: str, ancestor: int = 0, allo
         for _, scope, can_access_parent in reversed(self._scopes):
             if name in scope:
                 err_str = "Shadowing variable {} from type {} to {}".format(name, scope[name], dtype)
-                if (allow_shadowing or config.Config.get_bool("compiler", "allow_shadowing")):
+                if (allow_shadowing or config.Config.get_bool("compiler", "allow_shadowing")
+                        or dtype == DefinedType.GPUStream):
                     if not allow_shadowing:
                         print("WARNING: " + err_str)
                 else:

dace/codegen/targets/cpp.py

@@ -216,14 +216,17 @@ def memlet_copy_to_absolute_strides(dispatcher: 'TargetDispatcher',
 
 def is_cuda_codegen_in_device(framecode) -> bool:
     """
-    Check the state of the CUDA code generator, whether it is inside device code.
+    Check the state of the (Experimental) CUDA code generator, whether it is inside device code.
     """
     from dace.codegen.targets.cuda import CUDACodeGen
+
+    cudaClass = CUDACodeGen
+
     if framecode is None:
         cuda_codegen_in_device = False
     else:
         for codegen in framecode.targets:
-            if isinstance(codegen, CUDACodeGen):
+            if isinstance(codegen, cudaClass):
                 cuda_codegen_in_device = codegen._in_device_code
                 break
         else:
@@ -246,11 +249,9 @@ def ptr(name: str, desc: data.Data, sdfg: SDFG = None, framecode: 'DaCeCodeGener
         root = name.split('.')[0]
         if root in sdfg.arrays and isinstance(sdfg.arrays[root], data.Structure):
             name = name.replace('.', '->')
-
     # Special case: If memory is persistent and defined in this SDFG, add state
     # struct to name
     if (desc.transient and desc.lifetime in (dtypes.AllocationLifetime.Persistent, dtypes.AllocationLifetime.External)):
-
         if desc.storage == dtypes.StorageType.CPU_ThreadLocal:  # Use unambiguous name for thread-local arrays
             return f'__{sdfg.cfg_id}_{name}'
         elif not is_cuda_codegen_in_device(framecode):  # GPU kernels cannot access state
@@ -805,9 +806,12 @@ def unparse_cr(sdfg, wcr_ast, dtype):
 def connected_to_gpu_memory(node: nodes.Node, state: SDFGState, sdfg: SDFG):
     for e in state.all_edges(node):
         path = state.memlet_path(e)
-        if ((isinstance(path[0].src, nodes.AccessNode)
-             and path[0].src.desc(sdfg).storage is dtypes.StorageType.GPU_Global)):
+        if (((isinstance(path[0].src, nodes.AccessNode)
+              and path[0].src.desc(sdfg).storage is dtypes.StorageType.GPU_Global))
+                or ((isinstance(path[-1].dst, nodes.AccessNode)
+                     and path[-1].dst.desc(sdfg).storage is dtypes.StorageType.GPU_Global))):
             return True
+
     return False
 
 

dace/codegen/targets/cpu.py

@@ -502,6 +502,14 @@ def allocate_array(self,
 
             return
         elif (nodedesc.storage == dtypes.StorageType.Register):
+            # The assignment necessary to unify the explicit streams and streams declared through
+            # the state of the SDFG.
+            if nodedesc.dtype == dtypes.gpuStream_t:
+                ctype = dtypes.gpuStream_t.ctype
+                allocation_stream.write(f"{ctype}* {name} = __state->gpu_context->streams;")
+                define_var(name, DefinedType.Pointer, ctype)
+                return
+
             ctypedef = dtypes.pointer(nodedesc.dtype).ctype
             if nodedesc.start_offset != 0:
                 raise NotImplementedError('Start offset unsupported for registers')
@@ -577,6 +585,9 @@ def deallocate_array(self, sdfg: SDFG, cfg: ControlFlowRegion, dfg: StateSubgrap
 
         if isinstance(nodedesc, (data.Scalar, data.View, data.Stream, data.Reference)):
             return
+        elif nodedesc.dtype == dtypes.gpuStream_t:
+            callsite_stream.write(f"{alloc_name} = nullptr;")
+            return
         elif (nodedesc.storage == dtypes.StorageType.CPU_Heap
               or (nodedesc.storage == dtypes.StorageType.Register and
                   (symbolic.issymbolic(arrsize, sdfg.constants) or
@@ -994,6 +1005,11 @@ def process_out_memlets(self,
             dst_edge = dfg.memlet_path(edge)[-1]
             dst_node = dst_edge.dst
 
+            if isinstance(dst_node, nodes.AccessNode) and dst_node.desc(state).dtype == dtypes.gpuStream_t:
+                # Special case: GPU Streams do not represent data flow - they assing GPU Streams to kernels/tasks
+                # Thus, nothing needs to be written and out memlets of this kind should be ignored.
+                continue
+
             # Target is neither a data nor a tasklet node
             if isinstance(node, nodes.AccessNode) and (not isinstance(dst_node, nodes.AccessNode)
                                                        and not isinstance(dst_node, nodes.CodeNode)):
@@ -1035,8 +1051,7 @@ def process_out_memlets(self,
             # Tasklet -> array with a memlet. Writing to array is emitted only if the memlet is not empty
             if isinstance(node, nodes.CodeNode) and not edge.data.is_empty():
                 if not uconn:
-                    raise SyntaxError("Cannot copy memlet without a local connector: {} to {}".format(
-                        str(edge.src), str(edge.dst)))
+                    return
 
                 conntype = node.out_connectors[uconn]
                 is_scalar = not isinstance(conntype, dtypes.pointer)
@@ -1254,7 +1269,6 @@ def memlet_definition(self,
                     # Dynamic WCR memlets start uninitialized
                     result += "{} {};".format(memlet_type, local_name)
                     defined = DefinedType.Scalar
-
             else:
                 if not memlet.dynamic:
                     if is_scalar:
@@ -1289,8 +1303,12 @@ def memlet_definition(self,
                 memlet_type = ctypedef
                 result += "{} &{} = {};".format(memlet_type, local_name, expr)
                 defined = DefinedType.Stream
-        else:
-            raise TypeError("Unknown variable type: {}".format(var_type))
+
+        # Set Defined Type for GPU Stream connectors
+        # Shadowing for stream variable needs to be allowed
+        if memlet_type == 'gpuStream_t':
+            var_type = DefinedType.GPUStream
+            defined = DefinedType.GPUStream
 
         if defined is not None:
             self._dispatcher.defined_vars.add(local_name, defined, memlet_type, allow_shadowing=allow_shadowing)

dace/config_schema.yml

@@ -291,7 +291,7 @@ required:
                         type: str
                         title: Arguments
                         description: Compiler argument flags
-                        default: '-fPIC -Wall -Wextra -O3 -march=native -ffast-math -Wno-unused-parameter -Wno-unused-label'
+                        default: '-fopenmp -fPIC -Wall -Wextra -O3 -march=native -ffast-math -Wno-unused-parameter -Wno-unused-label'
                         default_Windows: '/O2 /fp:fast /arch:AVX2 /D_USRDLL /D_WINDLL /D__restrict__=__restrict'
 
                     libs:
@@ -349,7 +349,7 @@ required:
                             Additional CUDA architectures (separated by commas)
                             to compile GPU code for, excluding the current
                             architecture on the compiling machine.
-                        default: '60'
+                        default: '86'
 
                     hip_arch:
                         type: str

dace/dtypes.py

@@ -87,6 +87,8 @@ class ScheduleType(ExtensibleAttributeEnum):
     StorageType.GPU_Shared,
 ]
 
+GPU_KERNEL_ACCESSIBLE_STORAGES = [StorageType.GPU_Global, StorageType.GPU_Shared, StorageType.Register]
+
 
 class ReductionType(Enum):
     """ Reduction types natively supported by the SDFG compiler. """
@@ -176,7 +178,7 @@ class TilingType(Enum):
     ScheduleType.GPU_ThreadBlock: StorageType.Register,
     ScheduleType.GPU_ThreadBlock_Dynamic: StorageType.Register,
     ScheduleType.SVE_Map: StorageType.CPU_Heap,
-    ScheduleType.Snitch: StorageType.Snitch_TCDM
+    ScheduleType.Snitch: StorageType.Snitch_TCDM,
 }
 
 # Maps from ScheduleType to default ScheduleType for sub-scopes
@@ -193,7 +195,7 @@ class TilingType(Enum):
     ScheduleType.GPU_ThreadBlock_Dynamic: ScheduleType.Sequential,
     ScheduleType.SVE_Map: ScheduleType.Sequential,
     ScheduleType.Snitch: ScheduleType.Snitch,
-    ScheduleType.Snitch_Multicore: ScheduleType.Snitch_Multicore
+    ScheduleType.Snitch_Multicore: ScheduleType.Snitch_Multicore,
 }
 
 # Maps from StorageType to a preferred ScheduleType for helping determine schedules.
@@ -1184,6 +1186,7 @@ class complex128(_DaCeArray, npt.NDArray[numpy.complex128]): ...
     class string(_DaCeArray, npt.NDArray[numpy.str_]): ...
     class vector(_DaCeArray, npt.NDArray[numpy.void]): ...
     class MPI_Request(_DaCeArray, npt.NDArray[numpy.void]): ...
+    class gpuStream_t(_DaCeArray, npt.NDArray[numpy.void]): ...
     # yapf: enable
 else:
     # Runtime definitions
@@ -1204,7 +1207,7 @@ class MPI_Request(_DaCeArray, npt.NDArray[numpy.void]): ...
     complex128 = typeclass(numpy.complex128)
     string = stringtype()
     MPI_Request = opaque('MPI_Request')
-
+    gpuStream_t = opaque('gpuStream_t')
 _bool = bool
 
 

dace/libraries/standard/environments/__init__.py

@@ -1,3 +1,4 @@
 # Copyright 2019-2023 ETH Zurich and the DaCe authors. All rights reserved.
 from .cuda import CUDA
 from .hptt import HPTT
+from .cpu import CPU

dace/libraries/standard/environments/cpu.py

@@ -0,0 +1,21 @@
+# Copyright 2019-2026 ETH Zurich and the DaCe authors. All rights reserved.
+import dace.library
+
+
+@dace.library.environment
+class CPU:
+
+    cmake_minimum_version = None
+    cmake_packages = []
+    cmake_variables = {}
+    cmake_includes = []
+    cmake_libraries = []
+    cmake_compile_flags = []
+    cmake_link_flags = []
+    cmake_files = []
+
+    headers = {'frame': ["cstring"]}
+    state_fields = []
+    init_code = ""
+    finalize_code = ""
+    dependencies = []

dace/libraries/standard/environments/cuda.py

@@ -14,7 +14,7 @@ class CUDA:
     cmake_link_flags = []
     cmake_files = []
 
-    headers = []
+    headers = {'frame': ["cuda_runtime.h"]}
     state_fields = []
     init_code = ""
     finalize_code = ""

dace/libraries/standard/helper.py

@@ -0,0 +1,76 @@
+# Copyright 2019-2026 ETH Zurich and the DaCe authors. All rights reserved.
+"""
+Shared helpers for CopyLibraryNode and MemsetLibraryNode expansions: subset
+stride collapsing (used to size nested-SDFG data descriptors from memlet
+subsets) and dynamic map-range input promotion.
+"""
+from typing import List
+
+import dace
+import copy
+
+
+def collapse_shape_and_strides(subset: List[dace.subsets.Range], strides: List[dace.symbolic.SymExpr]):
+    """Remove singleton dimensions (length 1) from a subset/stride pair.
+
+    The resulting strides describe the access pattern of the subset as a
+    view into the parent array, so each parent stride is scaled by the
+    subset's step (``stride * s``).  For unit-step subsets this is a
+    no-op; for strided subsets it yields the effective per-element
+    distance in the underlying memory.
+    """
+    collapsed_shape = []
+    collapsed_strides = []
+    for (b, e, s), stride in zip(subset, strides):
+        length = (e + 1 - b) // s
+        if length != 1:
+            collapsed_shape.append(length)
+            collapsed_strides.append(stride * s)
+    return collapsed_shape, collapsed_strides
+
+
+def add_dynamic_inputs(dynamic_inputs, sdfg: dace.SDFG, subset: dace.subsets.Range, state: dace.SDFGState):
+    """Promote dynamic map-range inputs to SDFG-level data descriptors.
+
+    For each dynamic input not already present in the SDFG (e.g., a
+    runtime-determined array dimension), the function adds the descriptor,
+    renames existing symbolic references with a ``sym_`` prefix, and
+    inserts a pre-assignment state that reads the concrete value into the
+    symbol.  If no promotion is needed, the SDFG is left unchanged.
+    Returns the collapsed (non-singleton) map lengths after substitution.
+    """
+    pre_assignments = dict()
+    map_lengths = [dace.symbolic.SymExpr((e + 1 - b) // s) for (b, e, s) in subset]
+
+    for dynamic_input_name, datadesc in dynamic_inputs.items():
+        if dynamic_input_name in sdfg.arrays:
+            continue
+
+        if dynamic_input_name in sdfg.symbols:
+            continue
+
+        sdfg.replace(str(dynamic_input_name), "sym_" + str(dynamic_input_name))
+        ndesc = copy.deepcopy(datadesc)
+        ndesc.transient = False
+        sdfg.add_datadesc(dynamic_input_name, ndesc)
+        # Should be scalar
+        if isinstance(ndesc, dace.data.Scalar):
+            pre_assignments["sym_" + dynamic_input_name] = f"{dynamic_input_name}"
+        else:
+            assert ndesc.shape == (1, ) or ndesc.shape == [
+                1,
+            ]
+            pre_assignments["sym_" + dynamic_input_name] = f"{dynamic_input_name}[0]"
+
+        new_map_lengths = []
+        for ml in map_lengths:
+            nml = ml.subs({str(dynamic_input_name): "sym_" + str(dynamic_input_name)})
+            new_map_lengths.append(nml)
+        map_lengths = new_map_lengths
+
+    if pre_assignments != dict():
+        # Add a state for assignments in the beginning
+        sdfg.add_state_before(state=state, label="pre_assign", is_start_block=True, assignments=pre_assignments)
+
+    collapsed_map_lengths = [ml for ml in map_lengths if ml != 1]
+    return collapsed_map_lengths

dace/libraries/standard/nodes/__init__.py

@@ -1,5 +1,7 @@
-# Copyright 2019-2023 ETH Zurich and the DaCe authors. All rights reserved.
+# Copyright 2019-2026 ETH Zurich and the DaCe authors. All rights reserved.
 from .code import CodeLibraryNode
+from .copy_node import CopyLibraryNode
+from .memset_node import MemsetLibraryNode
 from .gearbox import Gearbox
 from .reduce import Reduce
 from .transpose import Transpose