Fix CUDA GlobalToGlobal codegen error by raising NotImplementedError

[Copilot]

This PR addresses a CUDA code generation error that occurs when trying to copy between GPU_Global storage locations within GPU_Device maps. The issue manifested as compilation errors due to non-existent dace::GlobalToGlobal function calls being generated.

Problem

When the CUDA code generator encounters a copy operation between two GPU_Global arrays within a GPU_Device map context, it attempts to generate function calls like:

• dace::GlobalToGlobal1D
• dace::GlobalToGlobal2D
• dace::GlobalToGlobal3D

While some of these functions exist in the runtime library (GlobalToGlobal1D and GlobalToGlobal1DDynamic), higher-dimensional versions and certain edge cases are not implemented, leading to compilation failures with cryptic "cannot be found" errors.

Solution

Instead of generating potentially invalid function calls, the code now detects this scenario and raises a clear NotImplementedError with guidance:

GPU global memory to global memory copies need to be more explicitly specified in the code. 
Consider using shared memory, different memory scopes, or explicit synchronization patterns.

Changes Made

• dace/codegen/targets/cuda.py: Added 6-line check in _emit_copy() method to detect GlobalToGlobal cases and raise descriptive error
• tests/codegen/gpu_memcpy_test.py: Added test case to validate the new behavior

The fix is minimal and surgical, affecting only the specific problematic case while leaving all other GPU copy operations unchanged.

Benefits

• Users get clear, actionable error messages instead of cryptic compilation failures
• Guides developers toward proper GPU memory management patterns
• Prevents silent failures or undefined behavior in GPU kernels
• Maintains backward compatibility for all working use cases

Fixes #335.

---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.

[tbennun]

Code looks good, test needs improvement.

[tbennun]

@copilot I don't think this test works. You should explicitly put it inside of a GPU_Device map.

maybe try using the NumPy frontend and for i in dace.map[0:N] @ dace.ScheduleType.GPU_Device:

[Copilot]

Fixed the test to use the proper approach with @dace.program and explicit GPU_Device map scheduling. The test now uses slice assignment B[:] = A[:] within a GPU_Device map to create a direct copy between GPU_Global arrays, which correctly triggers the NotImplementedError during compilation. Commit 70e8a3b

[tbennun]

LGTM, waiting for @ThrudPrimrose's review

[ThrudPrimrose]

Doesn't the not implemented error sound random?
Glb -> Glb being more explicitly specified in a code means that it needs to be copied within a map (e.g. calling copytomap as a transformation)?
As if there is a program that absolutely needs glb to glb memory copy (or the user wants that), I think asking for different memory locations to be used is irrelevant. Different memory scopes wont help and we don't have explicit synchronization patterns in dace (also what will adding a syncthreads will do)?

[ThrudPrimrose]

What about:

NotImplementedError(
"GPU global memory to global memory copies need to be more explicitly specified in the code. Considering moving the copy to a map using the CopyToMap transformation or manually. "
)

[ThrudPrimrose]

Looks good to me expect the error message, please the suggestion I commented on the error message.

The issue is not global to global copy not being implemented the issue is the only function available assumes the source is const.

[ThrudPrimrose]

Btw. GPU codegen runs CopyToMap in certain cases, that might be why some passing tests are failing right now?

This is a case where transient global memory copied into global memory that has persistent lifetime:

Should we update the test cases?

[ThrudPrimrose]

Btw in the example I show, the error is occurring not because glb to glb copy is not implemented but, the function always assumes the src is const. In this case it is not because src and dst is the same,

from copy.cuh:
What if we just overloaded with a second variant that allows:

static DACE_DFI void GlobalToGlobal1D(
            T *src, int src_xstride, T *dst)
    {

alongside the original:

static DACE_DFI void GlobalToGlobal1D(
            const T *src, int src_xstride, T *dst)
    {

We could also use enable_if:

template <typename T, typename SrcT,
          typename = typename std::enable_if<
              std::is_same<SrcT, T*>::value || std::is_same<SrcT, const T*>::value>::type>
static DACE_DFI void GlobalToGlobal1D(SrcT src, int src_xstride, T* dst) {

to decrease code cluttering.