cumo 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ddc7b756681afdf9fccd45652c422d2f67accfd1cf238d1fd05f6827fb5029d
-  data.tar.gz: 47848503fd8a388b7dfee79d2da0e627032fd4d8c8717645da70d8f09770f599
+  metadata.gz: 12027799f8203c1e08409de1fdec1b550e26511547bbaee2a938488ecd19e079
+  data.tar.gz: 399daea2a183febf70ceeb1e6492479fd3a34ae29e994265c4da9f89644c3c4d
 SHA512:
-  metadata.gz: f59ddc27c8f96a5eceec7fb4ae6665d1fae6dd20ef039a83563c0e0f5a76780fd2ab9b5ebbe06e116a3f01cd59c7493eee06dc6c1166a0bb82ba546c43331f03
-  data.tar.gz: 16543c06d74f79089799442abc30741ffb2a26556da953410023b19711fd25e15adb05548f9664c79bf8430a3be9c8f15c0813dccfae4b5e918ffc55a5fc68c0
+  metadata.gz: d12b0fa56578c8ffd309aa314ab40c98d3b983375d7ddd33b0909ac47092d52b48ea1b53173ea843701587a0fb50442a907b459bd558a8c92e4525eedd1531fd
+  data.tar.gz: ba1b2bac6afb811d790c3f8d90906f3e7f571cbbdb8dc59e3ff6141fa54aa5b8f8a8d6e597ff3045e001c9ae5ff0cab6d9e6679ee6b8f5bbdb1642f203ba19b1

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+# 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:

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

@@ -445,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
+    }
 }

data/ext/cumo/cuda/memory_pool.cpp

@@ -4,6 +4,7 @@
 #include "cumo/cuda/memory_pool.h"
 #include "cumo/cuda/runtime.h"
 
+#include <cstdio>
 #include <cstdlib>
 #include <string>
 
@@ -19,36 +20,83 @@ static bool memory_pool_enabled;
 
 VALUE cumo_cuda_eOutOfMemoryError;
 
+// How a call into the pool ended, so that the raise can wait until the handler
+// has been left. rb_raise longjmps, and a longjmp out of an active handler
+// skips __cxa_end_catch: the exception object is never destroyed and leaks for
+// the life of the process.
+enum pool_outcome {
+    POOL_OK,
+    POOL_CUDA_ERROR,
+    POOL_OUT_OF_MEMORY,
+    POOL_UNKNOWN_ERROR,
+};
+
+struct pool_error {
+    cudaError_t status;
+    char message[256];
+};
+
+static enum pool_outcome
+pool_malloc(size_t size, char **ptr, struct pool_error *err)
+{
+    try {
+        // TODO(sonots): Get current CUDA stream and pass it
+        *ptr = reinterpret_cast<char*>(pool.Malloc(size));
+        return POOL_OK;
+    } catch (const cumo::internal::CUDARuntimeError& e) {
+        err->status = e.status();
+        return POOL_CUDA_ERROR;
+    } catch (const cumo::internal::OutOfMemoryError& e) {
+        // A std::string here would in turn be leaked by the raise.
+        std::snprintf(err->message, sizeof(err->message), "%s", e.what());
+        return POOL_OUT_OF_MEMORY;
+    } catch (const std::exception& e) {
+        // Nothing may reach the C caller: it has no handler, so an escaping
+        // exception is std::terminate.
+        std::snprintf(err->message, sizeof(err->message), "%s", e.what());
+        return POOL_UNKNOWN_ERROR;
+    } catch (...) {
+        std::snprintf(err->message, sizeof(err->message), "unknown C++ exception");
+        return POOL_UNKNOWN_ERROR;
+    }
+}
+
 char*
 cumo_cuda_runtime_malloc(size_t size)
 {
-    if (memory_pool_enabled) {
-        try {
-            // TODO(sonots): Get current CUDA stream and pass it
-            return reinterpret_cast<char*>(pool.Malloc(size));
-        } catch (const cumo::internal::CUDARuntimeError& e) {
-            cumo_cuda_runtime_check_status(e.status());
-        } catch (const cumo::internal::OutOfMemoryError& e) {
-            // retry after GC
-            rb_funcall(rb_define_module("GC"), rb_intern("start"), 0);
-            try {
-                return reinterpret_cast<char*>(pool.Malloc(size));
-            } catch (const cumo::internal::CUDARuntimeError& e) {
-                cumo_cuda_runtime_check_status(e.status());
-            } catch (const cumo::internal::OutOfMemoryError& e) {
-                rb_raise(cumo_cuda_eOutOfMemoryError, "%s", e.what());
-            }
-        }
-    } else {
-        void *ptr = 0;
-        cumo_cuda_runtime_check_status(cudaMallocManaged(&ptr, size, cudaMemAttachGlobal));
-        return reinterpret_cast<char*>(ptr);
+    char *ptr = 0;
+    struct pool_error err;
+    enum pool_outcome outcome;
+
+    if (!memory_pool_enabled) {
+        void *raw = 0;
+        cumo_cuda_runtime_check_status(cudaMallocManaged(&raw, size, cudaMemAttachGlobal));
+        return reinterpret_cast<char*>(raw);
+    }
+
+    outcome = pool_malloc(size, &ptr, &err);
+    if (outcome == POOL_OUT_OF_MEMORY) {
+        // retry after GC
+        rb_funcall(rb_define_module("GC"), rb_intern("start"), 0);
+        outcome = pool_malloc(size, &ptr, &err);
+    }
+
+    switch (outcome) {
+    case POOL_OK:
+        return ptr;
+    case POOL_CUDA_ERROR:
+        cumo_cuda_runtime_check_status(err.status);
+        break;
+    case POOL_OUT_OF_MEMORY:
+        rb_raise(cumo_cuda_eOutOfMemoryError, "%s", err.message);
+    case POOL_UNKNOWN_ERROR:
+        rb_raise(rb_eRuntimeError, "%s", err.message);
     }
     return 0; // should not reach here
 }
 
-void
-cumo_cuda_runtime_free(char *ptr)
+static cudaError_t
+runtime_free(char *ptr)
 {
     // Always offer the pointer to the pool first, whatever memory_pool_enabled
     // says now: MemoryPool.enable/disable is public, so the state can differ
@@ -57,14 +105,35 @@ cumo_cuda_runtime_free(char *ptr)
     // which is not at the head of its buffer.
     try {
         if (pool.Free(reinterpret_cast<intptr_t>(ptr))) {
-            return;
+            return cudaSuccess;
         }
     } catch (const cumo::internal::CUDARuntimeError& e) {
-        cumo_cuda_runtime_check_status(e.status());
-        return;
+        return e.status();
+    } catch (...) {
+        return cudaErrorUnknown;
     }
     // No pool owns it, so it came straight from cudaMallocManaged.
-    cumo_cuda_runtime_check_status(cudaFree((void*)ptr));
+    return cudaFree((void*)ptr);
+}
+
+void
+cumo_cuda_runtime_free(char *ptr)
+{
+    cumo_cuda_runtime_check_status(runtime_free(ptr));
+}
+
+void
+cumo_cuda_runtime_free_no_raise(char *ptr)
+{
+    cudaError_t status = runtime_free(ptr);
+    // rb_raise from a GC free hook longjmps out of the sweep, so report the
+    // failure the way ~Memory does. cudaFree only fails once the context is
+    // unusable, and the next runtime call reports the same status anyway.
+    if (status == cudaSuccess || status == cudaErrorCudartUnloading) {
+        return;
+    }
+    std::fprintf(stderr, "cumo: failed to free device memory: %s (error=%d)\n",
+                 cudaGetErrorString(status), static_cast<int>(status));
 }
 
 /*
@@ -110,17 +179,22 @@ rb_memory_pool_enabled_p(VALUE self)
 static VALUE
 rb_memory_pool_free_all_blocks(int argc, VALUE* argv, VALUE self)
 {
+    // TODO(sonots): FIX if we create a Stream object
+    cudaStream_t stream_ptr = (argc < 1) ? 0 : (cudaStream_t)NUM2SIZET(argv[0]);
+    cudaError_t status = cudaSuccess;
+
     try {
         if (argc < 1) {
             pool.FreeAllBlocks();
         } else {
-            // TODO(sonots): FIX if we create a Stream object
-            cudaStream_t stream_ptr = (cudaStream_t)NUM2SIZET(argv[0]);
             pool.FreeAllBlocks(stream_ptr);
         }
     } catch (const cumo::internal::CUDARuntimeError& e) {
-        cumo_cuda_runtime_check_status(e.status());
+        status = e.status();
+    } catch (...) {
+        status = cudaErrorUnknown;
     }
+    cumo_cuda_runtime_check_status(status);
     return Qnil;
 }
 

data/ext/cumo/cuda/runtime.c

@@ -10,6 +10,35 @@ VALUE cumo_cuda_mRuntime;
 
 #define check_status(status) (cumo_cuda_runtime_check_status((status)))
 
+// Called right after a <<<>>> launch. cudaGetLastError() reports errors the
+// launch itself was rejected for; a fault while the kernel runs is asynchronous
+// and still surfaces at a later call.
+void
+cumo_cuda_runtime_check_kernel_launch(void)
+{
+    check_status(cudaGetLastError());
+}
+
+int*
+cumo_cuda_runtime_error_flag_new(void)
+{
+    static int *flag = NULL;
+
+    if (flag == NULL) {
+        check_status(cudaHostAlloc((void**)&flag, sizeof(int),
+                                   cudaHostAllocMapped | cudaHostAllocPortable));
+    }
+    *flag = 0;
+    return flag;
+}
+
+bool
+cumo_cuda_runtime_error_flag_get(int *flag)
+{
+    check_status(cudaDeviceSynchronize());
+    return (*flag != 0);
+}
+
 ///////////////////////////////////////////
 // Version Management
 ///////////////////////////////////////////

data/ext/cumo/include/cumo/cuda/cudnn.h

@@ -40,7 +40,7 @@ extern VALUE cumo_na_eShapeError;
 #define CUMO_CUDA_CUDNN_CHECK_DIM_EQ(nd1,nd2)        \
     if ((nd1) != (nd2)) {                            \
         rb_raise(cumo_na_eShapeError,                \
-                 "dimention mismatch: %d != %d",     \
+                 "dimension mismatch: %d != %d",     \
                  (int)(nd1), (int)(nd2));            \
     }
 

data/ext/cumo/include/cumo/cuda/cumo_thrust.hpp

@@ -53,7 +53,12 @@ class cumo_thrust_strided_range
 
     // construct strided_range for the range [first,last)
     cumo_thrust_strided_range(Iterator first, Iterator last, difference_type stride)
-        : first(first), last(last), stride(stride) {}
+        : first(first), stride(stride), count(((last - first) + (stride - 1)) / stride) {}
+
+    // A stride of 0 repeats one element and a negative stride walks backwards, so
+    // neither can be counted from (last - first); those callers pass the count.
+    cumo_thrust_strided_range(Iterator first, difference_type stride, difference_type count)
+        : first(first), stride(stride), count(count) {}
 
     iterator begin(void) const
     {
@@ -62,13 +67,13 @@ class cumo_thrust_strided_range
 
     iterator end(void) const
     {
-        return begin() + ((last - first) + (stride - 1)) / stride;
+        return begin() + count;
     }
 
     protected:
     Iterator first;
-    Iterator last;
     difference_type stride;
+    difference_type count;
 };
 
 

data/ext/cumo/include/cumo/cuda/memory_pool.h

@@ -18,6 +18,11 @@ cumo_cuda_runtime_malloc(size_t size);
 void
 cumo_cuda_runtime_free(char *ptr);
 
+// For GC free hooks, which cannot take a raise: reports a failed free on stderr
+// instead of raising.
+void
+cumo_cuda_runtime_free_no_raise(char *ptr);
+
 #if defined(__cplusplus)
 #if 0
 { /* satisfy cc-mode */

data/ext/cumo/include/cumo/cuda/runtime.h

@@ -45,9 +45,20 @@ cumo_cuda_runtime_is_device_memory(void* ptr)
     if (!ptr) { return false; }
     status = cudaPointerGetAttributes(&attrs, ptr);
     cudaGetLastError(); // reset last error to success
-    return (status != cudaErrorInvalidValue);
+    // Since CUDA 11 this succeeds for host memory as well and reports the kind
+    // in attrs.type, so the status alone no longer tells the two apart.
+    if (status != cudaSuccess) { return false; }
+    return (attrs.type != cudaMemoryTypeUnregistered);
 }
 
+// A kernel cannot raise, so it reports a bad argument through this flag and the
+// caller turns it into an exception. The buffer is pinned host memory the device
+// writes through, not pool memory: a four-byte pool allocation lands in the same
+// bin as a small output array, and the managed page then migrates back and forth
+// once per operation.
+int* cumo_cuda_runtime_error_flag_new(void);
+bool cumo_cuda_runtime_error_flag_get(int *flag);
+
 #if defined(__cplusplus)
 #if 0
 { /* satisfy cc-mode */

data/ext/cumo/include/cumo/intern.h

@@ -84,6 +84,11 @@ VALUE cumo_na_at_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result
 // defined in array, used in math
 VALUE cumo_na_ary_composition_dtype(VALUE ary);
 
+// defined in rand, used by the generated rand and rand_norm
+u_int64_t cumo_cuda_rand_seed(void);
+u_int64_t cumo_cuda_rand_offset(void);
+void cumo_cuda_rand_set_offset(u_int64_t offset);
+
 #include "ruby/version.h"
 
 #if RUBY_API_VERSION_CODE == 20100 // 2.1.0