cumo 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d50aabaf6d47d63e97fc6c68726cac94af2ecb8b737a3441de618860d2f5ab6a
-  data.tar.gz: 9d7bfc02015586d0ef533802be1d48558abf93fddf362ce445c55b0b4713ab7b
+  metadata.gz: 48de893a0d01a5e8376c2a9cda402be28dd47835661f22bd69e7ed17561abed8
+  data.tar.gz: c403ffc7d25b80a0b50e8513b81439ee46f775cbd8c126667f83656077488a79
 SHA512:
-  metadata.gz: 99f47260f8dbbb9320d2f74984262e328fd42c2dac0321300b6087712dd129d03f80d65a2089f12f624ea2814e59eb8400748c9bf08f3937b09c0bceb452f417
-  data.tar.gz: a3ccc77b320c0bfdaa64abed339cc22ce5099638f8a52e9abc5a44a1e144295f56581b43ebf99f5a431d54bbe7bed2fe590975abd59cb6b7e1a9008878c91f23
+  metadata.gz: '00189a16920241771a70155a98d60c5d53b6fcd23bfcddbaed3094bbbe5d3476b2d6b5ce70f9d8d899e090a9bf3be2c4249c1b98b6d14360736a4a5ba1aa5594'
+  data.tar.gz: bd6a1c8b78837b387f93f5b57f13c26917c71c123a1441deff8e3afb7250a42bc799ded9271b9ad9d46d4c3b928660c38653f85427b024bd00797d6786535734

data/.yardopts

@@ -0,0 +1,10 @@
+--no-private
+--exclude ext/cumo/narray/gen/
+-e ext/cumo/narray/gen/cogen_runner.rb
+lib/**/*.rb
+ext/**/*.c
+ext/**/*.cpp
+tmp/yard/types/*.c
+-
+*.md
+LICENSE.txt

data/3rd_party/mkmf-cu/lib/mkmf-cu/cli.rb

@@ -38,7 +38,7 @@ module MakeMakefileCuda
     # TODO(sonots): Make it possible to configure "nvcc" and additional arguments
     def nvcc_command
       s = MakeMakefileCuda::Nvcc.generate(argv)
-      cmd = "nvcc #{s}"
+      cmd = "nvcc #{s} -Xfatbin=-compress-all"
       if ENV['CUMO_NVCC_GENERATE_CODE']
         ENV['CUMO_NVCC_GENERATE_CODE'].split.each do |code|
           cmd << " --generate-code=#{code}"

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# 0.12.0 (2026/10/04)
+
+Fixes:
+
+* Fix a stream left current in a thread that ended never being destroyed. Neither `Stream#destroy` nor the finalizer could free it, so about 0.5 MiB of device memory stayed behind per such stream, and under M:N threads the next Ruby thread on the same native thread inherited it. The current stream now lives on the Ruby `Thread`, which adds about 2% to the fixed cost of a launch (PR #593)
+* Fix a device memory leak each time a thread that used cuBLAS, cuSOLVER or cuDNN ends: 64 MiB per thread for cuBLAS, 32 MiB more for cuSOLVER and about 8 MiB for cuDNN. An ending thread now leaves its handles to the next one, so device memory stays at what the most threads alive at once needed (PR #591)
+* Fix `x.inplace.cumsum` and `cumprod` answering a new array and leaving `x` as it was, which they did since 0.10.0 (PR #582)
+
+Changes:
+
+* Add `Cumo::Linalg`, the functions of `Numo::Linalg` from numo-linalg-alt 0.10.1 on cuSOLVER and cuBLAS, with the same names, arguments, return values and errors: `blas_char`, `dot`, `matmul`, `matrix_power`, `solve`, `inv`, `det`, `slogdet`, `lu`, `lu_fact`, `lu_solve`, `lu_inv`, `cholesky`, `cho_fact`, `cho_solve`, `cho_inv`, `ldl`, `qr`, `eig`, `eigvals`, `eigh`, `eigvalsh`, `svd`, `svdvals`, `pinv`, `lstsq`, `matrix_rank`, `orth`, `null_space`, `norm`, `cond` and `expm`. Load it with `require "cumo/linalg"`. Cumo builds it when the toolkit has cuSOLVER's 64-bit API, and `Cumo::CUDA::Cusolver.available?` says whether it did. `eig` and `eigvals` need `cusolverDnXgeev`, which CUDA 11 does not have, and `ldl` of a Hermitian complex matrix needs `cusolverDnXhetrf`, which CUDA 11 and 12 do not have. Where it differs from numo-linalg-alt on purpose, as in `expm`, `norm` and `cond`, the README says how (PR #594, PR #592, PR #589, PR #588, PR #587, PR #586, PR #584, PR #581, PR #580, PR #577, PR #576, PR #575, PR #574, PR #573, PR #572, PR #571, PR #570, PR #569, PR #568, PR #567)
+* `require "cumo"` sets `CUDA_MODULE_LOADING` to `LAZY` unless it is set already, as PyTorch does. Drivers before 535 otherwise load every kernel module when CUDA starts, which adds about 2.2 GB of RSS. Child processes inherit the setting (PR #590)
+* `triu`, `tril`, `triu!` and `tril!` clear the triangle of a contiguous array with an Integer `k` in one kernel rather than through an index array: `triu` of a 16 x 16 DFloat takes 0.006 ms where it took 0.49 (PR #585)
+* The first kernel of a type costs less host memory. Each type builds separate modules for its reductions, their nan-aware forms and `mulsum` against another type, so DFloat adds 88 MB of RSS for elementwise work and 137 MB once it reduces, where its first kernel of any kind added 181 MB. Every fatbin image is compressed, which takes `cumo.so` from 120 MB to 112 MB (PR #583)
+* The API docs show the NArray methods defined in C, such as `shape` and `NArray.zeros`, and keep the docstrings of the typed-class methods. `.yardopts` keeps the build-time code generators out of the docs, and the gemspec names rubydoc.info as the documentation (PR #579, PR #578)
+* The gem no longer ships the test suite, `bench/` and the files for working on cumo (PR #566)
+
 # 0.11.0 (2026/09/27)
 
 Breaking changes:

data/README.md

@@ -10,6 +10,7 @@ Cumo (pronounced "koomo") is a CUDA-aware, GPU-optimized numerical library that
 * NVIDIA GPU Compute Capability 3.5 (Kepler) or later
 * CUDA 11.0 or later
 * cuDNN 8.0 or later (optional, for the cuDNN features)
+* cuSOLVER with its 64-bit API, which comes with the CUDA Toolkit (optional, for `Cumo::Linalg`)
 
 ## Preparation
 
@@ -282,6 +283,40 @@ q.dot(kt)
 All of this is about the two-dimensional case, where cuBLAS is given one matrix.
 A batched multiplication takes another path through the same flag.
 
+### Linear Algebra
+
+`require "cumo/linalg"` brings in `Cumo::Linalg`, the functions of `Numo::Linalg` from [numo-linalg-alt](https://github.com/yoshoku/numo-linalg-alt) on the GPU.
+They keep numo-linalg-alt's names, arguments, return values and errors, and run on cuSOLVER and cuBLAS.
+
+```ruby
+require "cumo/linalg"
+
+a = Cumo::DFloat.new(3, 3).rand + Cumo::DFloat.eye(3) * 3
+b = Cumo::DFloat.new(3).rand
+x = Cumo::Linalg.solve(a, b)
+w, v = Cumo::Linalg.eigh(a + a.transpose)
+```
+
+The functions are `blas_char`, `dot`, `matmul`, `matrix_power`, `solve`, `inv`, `det`, `slogdet`, `lu`, `lu_fact`, `lu_solve`, `lu_inv`, `cholesky`, `cho_fact`, `cho_solve`, `cho_inv`, `ldl`, `qr`, `eig`, `eigvals`, `eigh`, `eigvalsh`, `svd`, `svdvals`, `pinv`, `lstsq`, `matrix_rank`, `orth`, `null_space`, `norm`, `cond` and `expm`.
+They take `SFloat`, `DFloat`, `SComplex` and `DComplex`.
+An integer or `Bit` matrix is computed in `DFloat`, as numo-linalg-alt does, and `HFloat` and `BFloat` raise `TypeError`.
+
+Cumo looks for cuSOLVER when it is built.
+Without it, the functions that need it raise `NotImplementedError`, and `Cumo::CUDA::Cusolver.available?` answers whether it is there.
+`eig` and `eigvals` also need `cusolverDnXgeev`, which CUDA 11 does not have.
+`ldl` of a Hermitian complex matrix needs `cusolverDnXhetrf`, which CUDA 11 and 12 do not have.
+
+Cumo differs from numo-linalg-alt in a few places on purpose:
+
+* Where numo-linalg-alt answers wrong, Cumo answers as numpy does: a wide matrix in `orth` and `lstsq`, a zero matrix in `pinv`, a matrix of full rank in `null_space`, an integer matrix in `qr` and `svd`, and empty matrices.
+* `expm` scales and squares the way scipy does, after Al-Mohy and Higham, which stays accurate where the norm of the matrix is large. Passing the order of the Pade approximant, as in `expm(a, 3)`, keeps numo-linalg-alt's algorithm.
+* `norm` takes the 2-norm and the nuclear norm of matrices stacked along other axes, which numo-linalg-alt refuses.
+* `cond` checks `ord` before it inverts the matrix, so an invalid `ord` raises `ArgumentError` even for a singular matrix, where numo-linalg-alt raises `LapackError`.
+
+A function waits for the current stream when it answers a Ruby number, or when it reads back whether cuSOLVER could do its work.
+`solve`, `inv` and `det` read back whether the matrix was singular, `cho_fact` whether it was positive definite, and `eigh` and `svd` whether they converged.
+`matmul`, `dot` of two matrices, `matrix_power` to a positive power, `cholesky`, `cho_solve`, `qr` and `norm` along an axis wait for nothing, so a run of them is queued without the host waiting.
+
 ### Fused Operations
 
 `layer_norm`, `rms_norm` and `softmax` normalize along the last axis in one kernel each, and `quantize_symmetric` takes it to 8-bit integers in one more.
@@ -962,6 +997,7 @@ export CUMO_ALLOW_TF32=1
 Over the convolutions of a ResNet-18 forward pass at batch 16, with the ceiling raised to 256MB, the pass gets faster and the worst layer moves from 1.4e-05 to 2.4e-04 against a double precision reference.
 
 The same flag puts `SFloat` and `SComplex` `gemm` on the tensor cores as TF32, and `dot` where it goes through `gemm`.
+`Cumo::Linalg.matrix_power` and `Cumo::Linalg.expm` multiply through `gemm`, so the flag reaches them too.
 Off, the answer is the one cuBLAS gives at single precision, bit for bit.
 On, a large `SFloat` `gemm` runs faster, and its answer is then about 3e-04 from a double precision reference, where it was 4e-07.
 The double types are not affected either way.

data/cumo.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "https://rubydoc.info/gems/cumo/"
   spec.metadata["changelog_uri"] = "https://github.com/sonots/cumo/blob/master/CHANGELOG.md"
   spec.metadata["bug_tracker_uri"] = "https://github.com/sonots/cumo/issues"
   spec.metadata["rubygems_mfa_required"] = "true"
@@ -25,9 +26,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(.github|test|spec|features|docker|examples)/})
+    f.start_with?(*%w[.github/ test/ examples/ bin/ bench/ docker- Dockerfile Gemfile .gitignore .rubocop])
   end
-  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/ext/cumo/cuda/cublas.c

@@ -43,31 +43,22 @@ cumo_cuda_cublas_check_status(cublasStatus_t status)
     }
 }
 
-// Lazily initialize cublas handle, and cache it
+static cumo_cuda_thread_local_t handles;
+
+// One handle per thread: the stream is set on the handle before each call,
+// and another thread with another current stream must not reset it in
+// between. A thread that ends leaves its handle to the next one.
 cublasHandle_t
 cumo_cuda_cublas_handle()
 {
-    // One table per thread: the stream is set on the handle before each call,
-    // and another thread with another current stream must not reset it in
-    // between. A handle is never destroyed.
-    static __thread cublasHandle_t *handles = 0;
-    int device;
-    if (handles == 0) {
-        int i;
-        int device_count = cumo_cuda_runtime_get_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) {
+    cublasHandle_t *handle = (cublasHandle_t*)cumo_cuda_thread_local_get(&handles);
+    if (*handle == 0) {
         // 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]));
+        cumo_cuda_cublas_check_status(cublasCreate(handle));
     }
-    cumo_cuda_cublas_check_status(cublasSetStream(handles[device], cumo_cuda_stream()));
-    return handles[device];
+    cumo_cuda_cublas_check_status(cublasSetStream(*handle, cumo_cuda_stream()));
+    return *handle;
 }
 
 VALUE
@@ -88,6 +79,8 @@ Init_cumo_cuda_cublas(void)
     VALUE mCumo = rb_define_module("Cumo");
     VALUE mCUDA = rb_define_module_under(mCumo, "CUDA");
 
+    cumo_cuda_thread_local_init(&handles, sizeof(cublasHandle_t));
+
     /*
       Document-module: Cumo::Cublas
     */

data/ext/cumo/cuda/cudnn.c

@@ -72,30 +72,21 @@ cumo_cuda_cudnn_release_conv_held(VALUE held)
     return Qnil;
 }
 
-// Lazily initialize cudnn handle, and cache it
+static cumo_cuda_thread_local_t handles;
+
+// One handle per thread, as in cublas.c: the stream set on the handle must
+// not be reset by another thread before the call.
 cudnnHandle_t
 cumo_cuda_cudnn_handle()
 {
-    // One table per thread, as in cublas.c: the stream set on the handle must
-    // not be reset by another thread before the call. A handle is never destroyed.
-    static __thread cudnnHandle_t *handles = 0;
-    int device;
-    if (handles == 0) {
-        int i;
-        int device_count = cumo_cuda_runtime_get_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) {
+    cudnnHandle_t *handle = (cudnnHandle_t*)cumo_cuda_thread_local_get(&handles);
+    if (*handle == 0) {
         // 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]));
+        cumo_cuda_cudnn_check_status(cudnnCreate(handle));
     }
-    cumo_cuda_cudnn_check_status(cudnnSetStream(handles[device], cumo_cuda_stream()));
-    return handles[device];
+    cumo_cuda_cudnn_check_status(cudnnSetStream(*handle, cumo_cuda_stream()));
+    return *handle;
 }
 
 #endif // CUDNN_FOUND
@@ -144,6 +135,7 @@ Init_cumo_cuda_cudnn(void)
 
     rb_define_singleton_method(mCUDNN, "available?", rb_cudnn_available_p, 0);
 #ifdef CUDNN_FOUND
+    cumo_cuda_thread_local_init(&handles, sizeof(cudnnHandle_t));
     init_max_workspace_size();
     rb_define_singleton_method(mCUDNN, "max_workspace_size", rb_cudnn_max_workspace_size, 0);
     rb_define_const(mCUDNN, "CUDNN_POOLING_MAX", INT2NUM(CUDNN_POOLING_MAX));