cumo 0.5.6 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 324cdfec0cf163d40b3b3b635fa69ecf516aa12e15a0bf614cbc34d3fe61a4c7
-  data.tar.gz: 3d0f6c8b66a9b51eca9fe6912c1a4e7c3534a028ed4c8d740467ae8d6e215824
+  metadata.gz: 12027799f8203c1e08409de1fdec1b550e26511547bbaee2a938488ecd19e079
+  data.tar.gz: 399daea2a183febf70ceeb1e6492479fd3a34ae29e994265c4da9f89644c3c4d
 SHA512:
-  metadata.gz: 9c82a985c471260943c4716630d6db803706ac50cccd5e1fc8a0a2bb02d80172ec38743f5c5f286467e97814843b8fbe1d6ec1f98e75081364fd9a5c0a4da832
-  data.tar.gz: d3ed8c3e8844d51676c4011139faa509de8cdb39ef325d84b4b8b41f6725fb63b9893fae8dbced5e546810ff4eb570f60a347ef248323f805bffa9fde60faab1
+  metadata.gz: d12b0fa56578c8ffd309aa314ab40c98d3b983375d7ddd33b0909ac47092d52b48ea1b53173ea843701587a0fb50442a907b459bd558a8c92e4525eedd1531fd
+  data.tar.gz: ba1b2bac6afb811d790c3f8d90906f3e7f571cbbdb8dc59e3ff6141fa54aa5b8f8a8d6e597ff3045e001c9ae5ff0cab6d9e6679ee6b8f5bbdb1642f203ba19b1

data/CHANGELOG.md

@@ -1,3 +1,77 @@
+# 0.5.8 (2026/08/17)
+
+Breaking changes:
+
+* Random numbers are generated on the GPU, so `srand` no longer reproduces `Numo::NArray`'s values for the same seed. Reproducibility within Cumo is unchanged and no longer depends on how the calls are split (PR #223)
+* Integer division by zero raises `ZeroDivisionError` instead of returning whatever the hardware produced, matching `Numo::NArray` (PR #218)
+* A numeric index into an unallocated NArray raises instead of returning a view nothing ever reads (PR #225)
+
+Fixes:
+
+* Fix `rb_raise` from inside a C++ catch leaking the exception object (PR #229)
+* Fix a failed Array store leaking its staging buffer, as much as the destination holds per failure (PR #228)
+* Fix the GC free hook raising when a device free fails, which surfaced at whatever line triggered the collection (PR #227)
+* Fix `from_binary` and `store_binary` writing managed memory while a kernel was still reading it (PR #226)
+* Fix integer `sum` and `prod` truncating every partial the reduction merged (PR #224)
+* Fix `minmax` ignoring compatible mode and returning zero-dimensional NArrays (PR #220)
+* Fix `nan` poisoning `max` and an all-`nan` `min` answering `DBL_MAX` (PR #219)
+* Fix `reshape!` and `marshal_load` mutating the array before they validate their arguments (PR #217)
+* Fix `ptp` answering 1 whatever the input (PR #216)
+* Fix `mulsum` ignoring the accumulator and the operand strides, which faulted the GPU on 8-bit dtypes (PR #215)
+* Fix `dot` handing `gemm` operands of a different dtype, an out-of-bounds read (PR #214)
+* Fix view offsets being added in the wrong unit (PR #213)
+* Fix interpreter abort on a zero-dimensional view (PR #212)
+* Fix `Cumo::RObject#logseq` returning `Infinity` (PR #210)
+* Fix `to_i`, `to_f` and `to_c` recursing forever on a one-element array (PR #208)
+* Fix complex `log2` and `log10` discarding the logarithm on the GPU (PR #207)
+* Fix segfault in `max_index` and `min_index` with `nan: true` (PR #206)
+* Fix `poly` failing on every input from an uninitialized `ndfunc` dimension (PR #205)
+* Fix out-of-bounds writes in `bincount` from an overflowing length and a stale scan (PR #204)
+* Fix `bincount` raising `TypeError` for every input (PR #203)
+* Fix host loops reading device memory without synchronizing, which silently corrupted `minmax`, the `nan: true` reductions, `kahan_sum`, `modf`, `frexp` and `set_imag` (PR #202)
+* Fix out-of-bounds access from three unchecked `size_t` multiplications (PR #201)
+* Fix segfaults from an unvalidated marshal payload (PR #200)
+* Fix `store_array` reading a source Array that its own elements rewrite (PR #198)
+* Fix CUDA initialisation statuses being ignored at `require` time (PR #196)
+* Fix kernel launch errors being discarded, which let a rejected launch return an untouched buffer as success (PR #195)
+* Fix wrong `Cumo::RObject` results from driving host memory with asynchronous CUDA work (PR #194)
+* Fix device memory being invisible to the GC, which let a program churning temporaries run the GPU out of memory (PR #221)
+
+Changes:
+
+* Run `rand` and `rand_norm` on the GPU (PR #223)
+* Run `clip` on the GPU (PR #222)
+* Correct spelling in messages, docs and comments (PR #211)
+* Add the math, extra and narray test suites `numo-narray-alt` has and cumo lacked (PR #207, PR #208, PR #209)
+* Add a `store_array` regression test for a shrunk source Array (PR #199)
+* Stop the ccache cache growing past the 10 GB limit in CI (PR #197)
+* Add a benchmark script under `bench/` (commit 3127f84)
+
+# 0.5.7 (2026/08/13)
+
+Breaking changes:
+
+* `reshape` raises `ArgumentError` instead of `RangeError` for a dimension above `INT_MAX` (PR #183)
+* `parse` accepts only numeric literals and `true`/`false`/`nil`, so `parse("3/4")` raises `ArgumentError` instead of returning `[[0]]` (PR #190)
+
+Fixes:
+
+* Fix segfaults from CUDA handles the process did not create, and from destroying one twice (PR #192)
+* Fix process abort from freeing NArray data with the wrong allocator, including a raise out of GC for `Cumo::RObject` (PR #191)
+* Fix arbitrary code execution in `parse`, which ran `eval` on every token (PR #190)
+* Fix stack buffer overflow in `Cumo::RObject#format` with an element longer than 47 characters (PR #189)
+* Fix a freed chunk returning to the arena of the wrong stream (PR #187)
+* Fix `Malloc` searching the free list with the default stream's index (PR #186)
+* Fix data race on the memory pool chunk graph and on the per-device pool table (PR #185)
+* Fix a SIGFPE on fractional range steps and an out-of-bounds read on newaxis (PR #184)
+* Fix a SIGFPE and a silently corrupt shape from unchecked `reshape` arguments (PR #183)
+* Fix segfault when `store_binary` receives a non-String (PR #182)
+* Fix missing range check on NArray indices, which segfaulted on a negative one (PR #181)
+
+Changes:
+
+* Compile the memory pool test harness in CI, and run it from `rake test` (PR #188)
+
 # 0.5.6 (2026/08/09)
 
 Fixes:

data/Rakefile

@@ -12,10 +12,19 @@ end
 require "rake/extensiontask"
 Rake::ExtensionTask.new("cumo")
 
-task :ctest do
-  sh 'cd ext/cumo && ruby extconf.rb && make && make build-ctest && make run-ctest'
+desc 'Build the C++ memory pool test harness without running it (running it needs a GPU)'
+task :build_ctest do
+  sh 'cd ext/cumo && ruby extconf.rb && make build-ctest'
 end
 
+task :ctest => :build_ctest do
+  sh 'cd ext/cumo && make run-ctest'
+end
+
+# Both need a GPU, so CI runs neither. Tie them together so the one place
+# they do run does not skip half of them.
+task :test => :ctest
+
 task :docs do
   dir = "ext/cumo"
   srcs = %w[array.c data.c index.c math.c narray.c rand.c struct.c].map { |s| File.join(dir, "narray", s) }

data/bench/bench.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ---------------------------------------------------------------------------
+# Numo / Cumo comparison benchmark
+#
+#   ruby bench.rb                  # CPU: numo-narray
+#   GPU=1 ruby bench.rb            # GPU: cumo
+#   SIZE=4096 STEPS=500 ITER=3 ruby bench.rb
+#   PGM=0 ruby bench.rb            # skip the PGM output
+#
+# To compare against numo-narray-alt (yoshoku's fork, SIMD enabled), swap the
+# gem; this file needs no change, since the namespace stays Numo:
+#   gem uninstall numo-narray && gem install numo-narray-alt
+#
+# Environment variables that matter on the Cumo side:
+#   CUMO_SHOW_WARNING=ON     warn wherever a CPU/GPU synchronization happens
+#   CUDA_LAUNCH_BLOCKING=1   synchronize on every launch (for profiling; slow)
+#   CUMO_MEMORY_POOL=OFF     turn the memory pool off to measure allocation too
+#   CUDA_VISIBLE_DEVICES=0   device selection
+#
+# Numo::Bit, masked assignment and fancy indexing are deliberately unused. The
+# divergence test is written with clip and floor arithmetic alone, so Numo and
+# Cumo take exactly the same code path.
+# ---------------------------------------------------------------------------
+
+require 'benchmark'
+
+GPU = !%w[0 false].include?(ENV['GPU'].to_s.downcase) && !ENV['GPU'].to_s.empty?
+
+if GPU
+  require 'cumo/narray'
+  XM = Cumo
+else
+  require 'numo/narray'
+  XM = Numo
+end
+
+SIZE  = (ENV['SIZE']  || 1024).to_i   # side of the mandelbrot / diffusion grid
+STEPS = (ENV['STEPS'] || 200).to_i    # number of iterations
+NBODY = (ENV['NBODY'] || 2048).to_i   # number of n-body particles
+MC    = (ENV['MC']    || 10_000_000).to_i
+ITER  = (ENV['ITER']  || 3).to_i      # repeats per measurement (3-5 to steady it)
+PGM   = ENV['PGM'] != '0'
+
+# --- helpers ---------------------------------------------------------------
+
+# Cumo launches kernels asynchronously, so every measurement boundary syncs.
+def sync
+  XM::CUDA::Runtime.cudaDeviceSynchronize if GPU
+end
+
+# Cumo returns a zero-dimensional NArray from sum / min / max / count_true,
+# where Numo returns a Numeric.
+def scalar(v)
+  return v if v.is_a?(Numeric)
+  v.respond_to?(:extract_cpu) ? v.extract_cpu : v.extract
+end
+
+def free(*arrays)
+  return unless GPU
+
+  arrays.each { |a| a.free if a.respond_to?(:free) }
+end
+
+def report(label)
+  result = nil
+  total = Benchmark.realtime do
+    ITER.times do
+      result = yield
+      sync
+    end
+  end
+  puts format('  %-12s %9.3f s total   %9.3f s/iter', label, total, total / ITER)
+  result
+end
+
+def write_pgm(path, arr)
+  return unless PGM
+
+  lo = scalar(arr.min).to_f
+  hi = scalar(arr.max).to_f
+  hi = lo + 1.0 if hi <= lo
+  img = XM::UInt8.cast((arr - lo) / (hi - lo) * 255.0)
+  h, w = img.shape
+  bytes =
+    begin
+      img.to_binary
+    rescue StandardError
+      # fallback for a Cumo without to_binary (device to host copy)
+      img.to_a.flatten.pack('C*')
+    end
+  File.open(path, 'wb') do |f|
+    f.write("P5\n#{w} #{h}\n255\n")
+    f.write(bytes)
+  end
+  free(img)
+  puts "  -> #{path}"
+end
+
+# --- 1. mandelbrot set (pure elementwise arithmetic) ------------------------
+#
+# Build an indicator that is 1.0 once diverged and 0.0 while still alive using
+# clip and floor alone, then accumulate the survival count. No branches and no
+# masks, so it maps straight onto the GPU.
+def mandelbrot(n, steps)
+  lim = 1.0e10 # bound zr and zi here so neither Inf nor NaN appears
+  cr = XM::SFloat.new(1, n).seq / n * 3.0 - 2.0 # real axis [-2.0, 1.0)
+  ci = XM::SFloat.new(n, 1).seq / n * 3.0 - 1.5 # imaginary axis [-1.5, 1.5)
+  zr = XM::SFloat.zeros(n, n)
+  zi = XM::SFloat.zeros(n, n)
+  cnt = XM::SFloat.zeros(n, n)
+  cr = zr + cr # materialize the broadcast
+  ci = zr + ci
+
+  steps.times do
+    zr2 = zr * zr
+    zi2 = zi * zi
+    escaped = ((zr2 + zi2).clip(0.0, 4.0) / 4.0).floor # 1.0 once |z|^2 >= 4
+    cnt += 1.0 - escaped
+    zi = (2.0 * zr * zi + ci).clip(-lim, lim)
+    zr = (zr2 - zi2 + cr).clip(-lim, lim)
+  end
+  free(cr, ci, zr, zi)
+  cnt
+end
+
+# --- 2. 2-D heat diffusion (stencil / slice arithmetic) ---------------------
+def diffusion(n, steps)
+  u = XM::SFloat.zeros(n, n)
+  h = [n / 8, 1].max
+  u[h...(2 * h), h...(2 * h)] = 255.0
+  u[(5 * h)...(7 * h), (3 * h)...(4 * h)] = 255.0
+  k = 0.2
+
+  steps.times do
+    lap = u[0..-3, 1..-2] + u[2..-1, 1..-2] +
+          u[1..-2, 0..-3] + u[1..-2, 2..-1] - 4.0 * u[1..-2, 1..-2]
+    u[1..-2, 1..-2] = u[1..-2, 1..-2] + k * lap
+  end
+  u
+end
+
+# --- 3. n-body (2-D, O(N^2) through broadcasting) ---------------------------
+def nbody(n, steps)
+  dt = 1.0e-3
+  eps = 1.0e-3
+  x = XM::SFloat.new(n).rand * 2.0 - 1.0
+  y = XM::SFloat.new(n).rand * 2.0 - 1.0
+  vx = XM::SFloat.zeros(n)
+  vy = XM::SFloat.zeros(n)
+
+  steps.times do
+    dx = x.reshape(1, n) - x.reshape(n, 1) # [n, n]
+    dy = y.reshape(1, n) - y.reshape(n, 1)
+    r2 = dx * dx + dy * dy + eps
+    inv3 = 1.0 / (r2 * XM::NMath.sqrt(r2))
+    vx += (dx * inv3).sum(axis: 1) * dt
+    vy += (dy * inv3).sum(axis: 1) * dt
+    free(dx, dy, r2, inv3)
+    x += vx * dt
+    y += vy * dt
+  end
+  free(y, vx, vy)
+  x
+end
+
+# --- 4. monte carlo pi (random numbers + reduction) -------------------------
+# The sum is SFloat, so a large n costs pi its accuracy to rounding. Speed is
+# what this measures.
+def monte_carlo_pi(n)
+  x = XM::SFloat.new(n).rand
+  y = XM::SFloat.new(n).rand
+  r2 = x * x + y * y
+  inside = (1.0 - r2.clip(0.0, 1.0)).ceil # 1.0 where r2 < 1
+  hits = scalar(inside.sum).to_f
+  free(x, y, r2, inside)
+  4.0 * hits / n
+end
+
+# --- 5. compatibility probe (eyeball the incompatibilities the README lists) -
+def compat_probe
+  a = XM::SFloat[1.0, 2.0, 3.0]
+  bit = (a > 1.5)
+  count = bit.respond_to?(:count_true_cpu) ? bit.count_true_cpu : bit.count_true
+  puts "  (a > 1.5).class     : #{bit.class}"
+  puts "  count_true          : #{count.inspect}"
+  puts "  a.sum.class         : #{a.sum.class}"   # Numo: Float / Cumo: zero-dimensional NArray
+  puts "  a.max.class         : #{a.max.class}"
+  puts "  a[0].class          : #{a[0].class}"
+  free(a)
+end
+
+# --- main ------------------------------------------------------------------
+
+version = begin
+  XM::NArray::VERSION
+rescue StandardError
+  'unknown'
+end
+
+puts "ruby      : #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+puts "backend   : #{XM} #{version}"
+puts "params    : SIZE=#{SIZE} STEPS=#{STEPS} NBODY=#{NBODY} MC=#{MC} ITER=#{ITER}"
+puts
+
+# warm up (keep GPU initialization and kernel JIT out of the measurement)
+warm = XM::SFloat.new(64, 64).seq
+scalar((warm * warm + warm).sum)
+sync
+free(warm)
+GC.start
+
+puts 'compat:'
+compat_probe
+puts
+
+puts 'bench:'
+cnt = report('mandelbrot') { mandelbrot(SIZE, STEPS) }
+write_pgm('mandelbrot.pgm', cnt)
+free(cnt)
+GC.start
+
+u = report('diffusion') { diffusion(SIZE, STEPS) }
+write_pgm('diffusion.pgm', u)
+free(u)
+GC.start
+
+pos = report('nbody') { nbody(NBODY, 10) }
+free(pos)
+GC.start
+
+pi = nil
+report('monte_carlo') { pi = monte_carlo_pi(MC) }
+puts format('  pi ~= %.6f', pi)

data/ext/cumo/cuda/cublas.c

@@ -51,14 +51,16 @@ cumo_cuda_cublas_handle()
     if (handles == 0) {
         int i;
         int device_count = cumo_cuda_runtime_get_device_count();
-        handles = malloc(sizeof(cublasHandle_t) * device_count);
+        handles = ALLOC_N(cublasHandle_t, device_count);
         for (i = 0; i < device_count; ++i) {
             handles[i] = 0;
         }
     }
     device = cumo_cuda_runtime_get_device();
     if (handles[device] == 0) {
-        cublasCreate(&handles[device]);
+        // A discarded status leaves the handle NULL, and cuBLAS reports that as
+        // CUBLAS_STATUS_NOT_INITIALIZED at the next call instead of the reason.
+        cumo_cuda_cublas_check_status(cublasCreate(&handles[device]));
     }
     return handles[device];
 }

data/ext/cumo/cuda/cudnn.c

@@ -30,14 +30,16 @@ cumo_cuda_cudnn_handle()
     if (handles == 0) {
         int i;
         int device_count = cumo_cuda_runtime_get_device_count();
-        handles = malloc(sizeof(cudnnHandle_t) * device_count);
+        handles = ALLOC_N(cudnnHandle_t, device_count);
         for (i = 0; i < device_count; ++i) {
             handles[i] = 0;
         }
     }
     device = cumo_cuda_runtime_get_device();
     if (handles[device] == 0) {
-        cudnnCreate(&handles[device]);
+        // A discarded status leaves the handle NULL, and cuDNN reports that as
+        // CUDNN_STATUS_NOT_INITIALIZED at the next call instead of the reason.
+        cumo_cuda_cudnn_check_status(cudnnCreate(&handles[device]));
     }
     return handles[device];
 }

data/ext/cumo/cuda/driver.c

@@ -3,12 +3,16 @@
 #include <cuda.h>
 #include <cuda_runtime.h>
 #include "cumo/cuda/driver.h"
+#include "cumo/cuda/handle.h"
 
 VALUE cumo_cuda_eDriverError;
 VALUE cumo_cuda_mDriver;
 #define eDriverError cumo_cuda_eDriverError
 #define mDriver cumo_cuda_mDriver
 
+static cumo_cuda_handle_set_t link_states;
+static cumo_cuda_handle_set_t modules;
+
 static void
 check_status(CUresult status)
 {
@@ -100,13 +104,13 @@ cuLinkAddData_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkAddData(VALUE self, VALUE state, VALUE type, VALUE data, VALUE name)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
     CUjitInputType _type = (CUjitInputType)NUM2INT(type);
     // The image may be a cubin, so it is taken by length and allowed to hold
     // NUL bytes; the name is a plain C string cuLinkAddData reports errors with.
     void* _data = (void *)StringValuePtr(data);
     size_t _size = RSTRING_LEN(data);
     const char* _name = StringValueCStr(name);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkAddDataParam param = {_state, _type, _data, _size, _name, 0, (CUjit_option*)0, (void**)0};
@@ -141,9 +145,9 @@ cuLinkAddFile_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkAddFile(VALUE self, VALUE state, VALUE type, VALUE path)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
     CUjitInputType _type = (CUjitInputType)NUM2INT(type);
     const char* _path = StringValueCStr(path);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkAddFileParam param = {_state, _type, _path, 0, (CUjit_option*)0, (void **)0};
@@ -173,7 +177,7 @@ cuLinkComplete_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkComplete(VALUE self, VALUE state)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     void* _cubinOut;
     size_t _sizeOut;
     CUresult status;
@@ -214,6 +218,7 @@ rb_cuLinkCreate(VALUE self)
     //status = cuLinkCreate(0, (CUjit_option*)0, (void**)0, &state);
 
     check_status(status);
+    cumo_cuda_handle_set_add(&link_states, (size_t)state);
     return SIZET2NUM((size_t)state);
 }
 
@@ -233,7 +238,7 @@ cuLinkDestroy_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkDestroy(VALUE self, VALUE state)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_take(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkDestroyParam param = {_state};
@@ -263,8 +268,8 @@ static VALUE
 rb_cuModuleGetFunction(VALUE self, VALUE hmod, VALUE name)
 {
     CUfunction _hfunc;
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
     const char* _name = StringValueCStr(name);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_get(&modules, hmod, "CUmodule");
     CUresult status;
 
     struct cuModuleGetFunctionParam param = {&_hfunc, _hmod, _name};
@@ -297,8 +302,8 @@ rb_cuModuleGetGlobal(VALUE self, VALUE hmod, VALUE name)
 {
     CUdeviceptr _dptr;
     size_t _bytes;
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
     const char* _name = StringValueCStr(name);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_get(&modules, hmod, "CUmodule");
     CUresult status;
     VALUE ret;
 
@@ -342,6 +347,7 @@ rb_cuModuleLoad(VALUE self, VALUE fname)
 
     RB_GC_GUARD(fname);
     check_status(status);
+    cumo_cuda_handle_set_add(&modules, (size_t)_module);
     return SIZET2NUM((size_t)_module);
 }
 
@@ -373,6 +379,7 @@ rb_cuModuleLoadData(VALUE self, VALUE image)
 
     RB_GC_GUARD(image);
     check_status(status);
+    cumo_cuda_handle_set_add(&modules, (size_t)_module);
     return SIZET2NUM((size_t)_module);
 }
 
@@ -392,7 +399,7 @@ cuModuleUnload_without_gvl_cb(void *param)
 static VALUE
 rb_cuModuleUnload(VALUE self, VALUE hmod)
 {
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_take(&modules, hmod, "CUmodule");
     CUresult status;
 
     struct cuModuleUnloadParam param = {_hmod};
@@ -414,6 +421,9 @@ Init_cumo_cuda_driver()
     mDriver = rb_define_module_under(mCUDA, "Driver");
     eDriverError = rb_define_class_under(mCUDA, "DriverError", rb_eStandardError);
 
+    cumo_cuda_handle_set_init(&link_states);
+    cumo_cuda_handle_set_init(&modules);
+
     rb_define_singleton_method(mDriver, "cuCtxGetCurrent", rb_cuCtxGetCurrent, 0);
     rb_define_singleton_method(mDriver, "cuLinkAddData",   rb_cuLinkAddData,   4);
     rb_define_singleton_method(mDriver, "cuLinkAddFile", rb_cuLinkAddFile, 3);
@@ -435,11 +445,19 @@ Init_cumo_cuda_driver()
     rb_define_const(mDriver, "CU_JIT_INPUT_OBJECT", INT2NUM(CU_JIT_INPUT_OBJECT));
     rb_define_const(mDriver, "CU_JIT_INPUT_PTX", INT2NUM(CU_JIT_INPUT_PTX));
 
-    cuInit(0);
-    cuDeviceGet(&cuDevice, 0);
+    check_status(cuInit(0));
+
+    // A driver API call needs a current context, and the runtime API only
+    // creates its primary one once an array operation happens, so this covers
+    // the gap in between. Losing it is not fatal -- everything but a driver
+    // call made before any array operation still works -- so a device that
+    // refuses a context is left for that call to report. cuDeviceGet leaves
+    // cuDevice untouched when it fails, hence the guard.
+    if (cuDeviceGet(&cuDevice, 0) == CUDA_SUCCESS) {
 #if defined(CUDA_VERSION) && CUDA_VERSION >= 13000
-    cuCtxCreate(&context, NULL, 0, cuDevice);
+        cuCtxCreate(&context, NULL, 0, cuDevice);
 #else
-    cuCtxCreate(&context, 0, cuDevice);
+        cuCtxCreate(&context, 0, cuDevice);
 #endif
+    }
 }