Harden green context stream creation and resource queries

- Let the driver validate the nonblocking flag for green context streams:
  cuGreenCtxStreamCreate rejects CU_STREAM_DEFAULT. On failure, check if
  the context is green + nonblocking is False and raise a clear ValueError.
- cuCtxGetStreamPriorityRange failure (CUDA_ERROR_INVALID_CONTEXT) now
  raises: "No current CUDA context. Call dev.set_current() before
  creating streams."
- C++ create_stream_handle returns CUDA_ERROR_NOT_SUPPORTED if the
  context is green but cuGreenCtxStreamCreate is unavailable (CUDA < 12.5),
  instead of falling through to cuStreamCreateWithPriority.
- ctx.resources.workqueue now dispatches to cuGreenCtxGetDevResource for
  green contexts, matching the SM query path.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: leofang

cuda_core/cuda/core/_cpp/resource_handles.cpp

@@ -414,7 +414,11 @@ StreamHandle create_stream_handle(const ContextHandle& h_ctx, unsigned int flags
 
     // Dispatch: green context uses cuGreenCtxStreamCreate, primary uses cuStreamCreateWithPriority
     GreenCtxHandle h_green = get_context_green_ctx(h_ctx);
-    if (h_green && p_cuGreenCtxStreamCreate) {
+    if (h_green) {
+        if (!p_cuGreenCtxStreamCreate) {
+            err = CUDA_ERROR_NOT_SUPPORTED;
+            return {};
+        }
         if (CUDA_SUCCESS != (err = p_cuGreenCtxStreamCreate(&stream, as_cu(h_green), flags, priority))) {
             return {};
         }

cuda_core/cuda/core/_device_resources.pyx

@@ -548,19 +548,35 @@ cdef class DeviceResources:
         cdef cydriver.CUdevResource _wq
 
         IF CUDA_CORE_BUILD_MAJOR >= 13:
+            cdef GreenCtxHandle h_green
             if self._h_context:
-                # Context-level query
-                with nogil:
-                    HANDLE_RETURN(cydriver.cuCtxGetDevResource(
-                        as_cu(self._h_context),
-                        &_wq_config,
-                        cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE_CONFIG,
-                    ))
-                    HANDLE_RETURN(cydriver.cuCtxGetDevResource(
-                        as_cu(self._h_context),
-                        &_wq,
-                        cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE,
-                    ))
+                h_green = get_context_green_ctx(self._h_context)
+                if h_green:
+                    # Green context query
+                    with nogil:
+                        HANDLE_RETURN(cydriver.cuGreenCtxGetDevResource(
+                            as_cu(h_green),
+                            &_wq_config,
+                            cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE_CONFIG,
+                        ))
+                        HANDLE_RETURN(cydriver.cuGreenCtxGetDevResource(
+                            as_cu(h_green),
+                            &_wq,
+                            cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE,
+                        ))
+                else:
+                    # Primary context query
+                    with nogil:
+                        HANDLE_RETURN(cydriver.cuCtxGetDevResource(
+                            as_cu(self._h_context),
+                            &_wq_config,
+                            cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE_CONFIG,
+                        ))
+                        HANDLE_RETURN(cydriver.cuCtxGetDevResource(
+                            as_cu(self._h_context),
+                            &_wq,
+                            cydriver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_WORKQUEUE,
+                        ))
             else:
                 # Device-level query
                 with nogil:

cuda_core/cuda/core/_stream.pyx

@@ -30,7 +30,9 @@ from cuda.core._resource_handles cimport (
     create_event_handle_noctx,
     create_stream_handle,
     create_stream_handle_with_owner,
+    get_context_green_ctx,
     get_current_context,
+    get_last_error,
     get_legacy_stream,
     get_per_thread_stream,
     get_stream_context,
@@ -143,8 +145,15 @@ cdef class Stream:
                                    else cydriver.CUstream_flags.CU_STREAM_DEFAULT)
         # TODO: we might want to consider memoizing high/low per CUDA context and avoid this call
         cdef int high, low
+        cdef cydriver.CUresult res_code
         with nogil:
-            HANDLE_RETURN(cydriver.cuCtxGetStreamPriorityRange(&high, &low))
+            res_code = cydriver.cuCtxGetStreamPriorityRange(&high, &low)
+        if res_code != cydriver.CUresult.CUDA_SUCCESS:
+            if res_code == cydriver.CUresult.CUDA_ERROR_INVALID_CONTEXT:
+                raise RuntimeError(
+                    "No current CUDA context. Call dev.set_current() before creating streams."
+                )
+            HANDLE_RETURN(res_code)
         cdef int prio
         if priority is not None:
             prio = priority
@@ -157,6 +166,18 @@ cdef class Stream:
         # For green contexts, the C++ layer auto-dispatches to cuGreenCtxStreamCreate.
         h_stream = create_stream_handle(h_context, flags, prio)
         if not h_stream:
+            cdef bint is_green_ctx = h_context and get_context_green_ctx(h_context).get() != NULL
+            if is_green_ctx and not nonblocking:
+                raise ValueError(
+                    "Green context streams must be non-blocking. "
+                    "Use StreamOptions(nonblocking=True) or omit the option (True is the default)."
+                )
+            if is_green_ctx:
+                HANDLE_RETURN(get_last_error())
+                raise RuntimeError(
+                    "Failed to create green context stream. "
+                    "cuGreenCtxStreamCreate may not be available (requires CUDA 12.5+)."
+                )
             raise RuntimeError("Failed to create CUDA stream")
         self = Stream._from_handle(cls, h_stream)
         self._nonblocking = int(nonblocking)

cuda_core/tests/test_green_context.py

@@ -293,6 +293,13 @@ def test_create_stream_on_primary_raises(self, init_cuda):
         with pytest.raises(RuntimeError, match="only supported on green contexts"):
             ctx.create_stream()
 
+    def test_create_stream_blocking_raises(self, green_ctx):
+        """Green context streams must be non-blocking."""
+        from cuda.core import StreamOptions
+
+        with pytest.raises(ValueError, match="must be non-blocking"):
+            green_ctx.create_stream(StreamOptions(nonblocking=False))
+
     def test_create_stream_explicit(self, green_ctx):
         """Create a stream directly from the green context (no set_current)."""
         stream = green_ctx.create_stream()