fix(core): retain cuLinkCreate optionValues array for CUlinkState lifetime

The CUDA driver docs state: "optionValues must remain valid for the life
of the CUlinkState if output options are used." The driver writes log-
fill sizes (output) back into the optionValues slots for
CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES and CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES.
Linker_init previously declared c_jit_keys/c_jit_values as local
cdef vector[...] on the stack of Linker_init; they were destroyed when
the function returned, leaving the driver with dangling writes during
subsequent cuLinkAddData/cuLinkComplete/cuLinkDestroy calls.

This was always latent. It became reachable with the per-instance
backend dispatch (CTK 12.9.1 runners now select the driver linker when
they pair with a driver 13 install), and only manifested on driver 13
as heap corruption that killed the next NVRTC or link call.

Promote the two arrays to cdef class fields declared after
_culink_handle in the pxd. Cython's tp_dealloc destroys C++ fields in
pxd declaration order, so the vectors are destroyed after the shared_ptr
deleter runs cuLinkDestroy. The cuda.bindings high-level wrapper
(driver.cuLinkCreate) already handles this by attaching a keepalive to
CUlinkState; cuda.core's low-level cydriver.cuLinkCreate path did not.

Also drop the now-unused void_ptr ctypedef.

Author: cpcloud

cuda_core/cuda/core/_linker.pxd

@@ -2,13 +2,25 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from libcpp.vector cimport vector
+
+from cuda.bindings cimport cydriver
+
 from ._resource_handles cimport NvJitLinkHandle, CuLinkHandle
 
 
 cdef class Linker:
     cdef:
         NvJitLinkHandle _nvjitlink_handle
         CuLinkHandle _culink_handle
+        # _drv_jit_keys/_drv_jit_values are the C arrays handed to cuLinkCreate.
+        # The driver retains a reference to the optionValues array for the life
+        # of the CUlinkState (it writes back log-size outputs into its slots),
+        # so these must live past cuLinkCreate and outlive cuLinkDestroy.
+        # Declared after _culink_handle so their C++ destructors run AFTER
+        # cuLinkDestroy executes during tp_dealloc.
+        vector[cydriver.CUjit_option] _drv_jit_keys
+        vector[void*] _drv_jit_values
         bint _use_nvjitlink
         object _drv_log_bufs  # formatted_options list (driver); None for nvjitlink
         str _info_log         # decoded log; None until link() or pre-link get_*_log()

cuda_core/cuda/core/_linker.pyx

@@ -42,7 +42,6 @@ from cuda.core._utils.cuda_utils import (
 from cuda.core._utils.version import driver_version
 
 ctypedef const char* const_char_ptr
-ctypedef void* void_ptr
 
 __all__ = ["Linker", "LinkerOptions"]
 
@@ -460,8 +459,8 @@ cdef inline int Linker_init(Linker self, tuple object_codes, object options) exc
     cdef cydriver.CUlinkState c_raw_culink
     cdef Py_ssize_t c_num_opts, i
     cdef vector[const_char_ptr] c_str_opts
-    cdef vector[cydriver.CUjit_option] c_jit_keys
-    cdef vector[void_ptr] c_jit_values
+    cdef cydriver.CUjit_option* c_drv_jit_keys_ptr
+    cdef void** c_drv_jit_values_ptr
 
     self._options = options = check_or_create_options(LinkerOptions, options, "Linker options")
 
@@ -501,19 +500,32 @@ cdef inline int Linker_init(Linker self, tuple object_codes, object options) exc
         # the driver writes into via raw pointers during linking operations.
         self._drv_log_bufs = formatted_options
         c_num_opts = len(option_keys)
-        c_jit_keys.resize(c_num_opts)
-        c_jit_values.resize(c_num_opts)
+        # Store the option key/value arrays as instance members so they outlive
+        # the cuLinkCreate call. CUDA driver docs require optionValues to
+        # remain valid for the life of the CUlinkState when output options are
+        # used (the driver writes log-fill sizes back into the array). The
+        # pxd declaration order ensures these vectors are destroyed AFTER
+        # _culink_handle -- i.e. after cuLinkDestroy has run.
+        self._drv_jit_keys.resize(c_num_opts)
+        self._drv_jit_values.resize(c_num_opts)
         for i in range(c_num_opts):
-            c_jit_keys[i] = <cydriver.CUjit_option><int>option_keys[i]
+            self._drv_jit_keys[i] = <cydriver.CUjit_option><int>option_keys[i]
             val = formatted_options[i]
             if isinstance(val, bytearray):
-                c_jit_values[i] = <void*>PyByteArray_AS_STRING(val)
+                self._drv_jit_values[i] = <void*>PyByteArray_AS_STRING(val)
             else:
-                c_jit_values[i] = <void*><intptr_t>int(val)
+                self._drv_jit_values[i] = <void*><intptr_t>int(val)
+        # Capture the vector data() pointers before entering nogil to keep
+        # the nogil region free of any attribute access on self.
+        c_drv_jit_keys_ptr = self._drv_jit_keys.data()
+        c_drv_jit_values_ptr = self._drv_jit_values.data()
         try:
             with nogil:
                 HANDLE_RETURN(cydriver.cuLinkCreate(
-                    <unsigned int>c_num_opts, c_jit_keys.data(), c_jit_values.data(), &c_raw_culink))
+                    <unsigned int>c_num_opts,
+                    c_drv_jit_keys_ptr,
+                    c_drv_jit_values_ptr,
+                    &c_raw_culink))
         except CUDAError as e:
             Linker_annotate_error_log(self, e)
             raise