Explicit copy memset nodes

dace/config_schema.yml

@@ -349,6 +349,14 @@ required:
                             generate "#pragma omp parallel sections" code around
                             them.
 
+                    parallel_transfer_min_elements:
+                        type: int
+                        default: 262144
+                        title: Parallel copy/memset element threshold
+                        description: >
+                            Minimum element count (symbolic size counts as large) for a
+                            copy/memset to lower to an OpenMP element map instead of memcpy/memset.
+
             #############################################
             # GPU (CUDA/HIP) compiler
             cuda:

dace/libraries/standard/environments/__init__.py

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

dace/libraries/standard/environments/cpu.py

@@ -0,0 +1,23 @@
+# Copyright 2019-2026 ETH Zurich and the DaCe authors. All rights reserved.
+"""DaCe library environment exposing the C++ standard headers used by CPU-side libnode expansions."""
+import dace.library
+
+
+@dace.library.environment
+class CPU:
+    """Minimal library environment that pulls in ``<cstring>`` for plain CPU expansions."""
+
+    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/helper.py

@@ -0,0 +1,72 @@
+# Copyright 2019-2026 ETH Zurich and the DaCe authors. All rights reserved.
+"""Shared helpers for CopyLibraryNode and MemsetLibraryNode expansions."""
+from typing import Callable, List, Tuple
+
+import dace
+from dace import dtypes
+from dace.sdfg import nodes
+
+# Both legacy and experimental codegens consume this exact name for stream wiring.
+CURRENT_STREAM_NAME = "__dace_current_stream"
+
+# Register is intentionally in neither set: resolves by scope (GPU register vs. host stack slot).
+GPU_RESIDENT_STORAGES = frozenset({
+    dtypes.StorageType.GPU_Global,
+    dtypes.StorageType.GPU_Shared,
+})
+CPU_RESIDENT_STORAGES = frozenset({
+    dtypes.StorageType.CPU_Heap,
+    dtypes.StorageType.CPU_Pinned,
+    dtypes.StorageType.CPU_ThreadLocal,
+})
+
+
+def collapse_shape_and_strides(
+        subset: dace.subsets.Range,
+        strides: List[dace.symbolic.SymExpr]) -> Tuple[List[dace.symbolic.SymExpr], List[dace.symbolic.SymExpr]]:
+    """Drop length-1 dims from a (subset, strides) pair; surviving strides scale by the subset step.
+
+    :param subset: The access range, one ``(begin, end, step)`` per dimension.
+    :param strides: The parent array strides, aligned with ``subset``.
+    :returns: ``(collapsed_shape, collapsed_strides)`` with singletons removed.
+    """
+    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 is_parallel_cpu_transfer_size(num_elements: dace.symbolic.SymbolicType) -> bool:
+    """False only when ``num_elements`` is a compile-time constant below
+    ``compiler.cpu.parallel_transfer_min_elements``; a symbolic (unknown-at-compile-time) size
+    is assumed large and takes the parallel path too.
+
+    :param num_elements: total contiguous element count (constant or symbolic).
+    :returns: ``True`` to route to the mapped expansion, ``False`` to keep the single libc call.
+    """
+    threshold = int(dace.Config.get('compiler', 'cpu', 'parallel_transfer_min_elements'))
+    try:
+        return int(dace.symbolic.simplify(num_elements)) >= threshold
+    except (TypeError, ValueError):
+        return True
+
+
+def auto_dispatch(node: nodes.LibraryNode, parent_state: dace.SDFGState,
+                  select_fn: Callable[[nodes.LibraryNode, dace.SDFGState], str], library_cls: type):
+    """Dispatch a library node's ``'Auto'`` implementation to the one ``select_fn`` picks, setting
+    ``node.implementation`` so introspection reflects what was chosen.
+
+    :param node: the library node being expanded.
+    :param parent_state: state containing ``node`` (owning SDFG is ``parent_state.sdfg``).
+    :param select_fn: callable returning a concrete implementation name (not ``'Auto'``).
+    :param library_cls: the library node class with the ``implementations`` dict.
+    :returns: whatever the resolved expansion returns.
+    """
+    impl_name = select_fn(node, parent_state)
+    assert impl_name != 'Auto', f"{select_fn.__name__} must not return 'Auto'."
+    node.implementation = impl_name
+    return library_cls.implementations[impl_name].expansion(node, parent_state, parent_state.sdfg)

dace/libraries/standard/nodes/__init__.py

@@ -1,4 +1,6 @@
 # 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