cumo 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0872662f2f59cb4486df50f2f9b6dee5fc62fe938f6c47bafdb1ebdfc744c2f6'
-  data.tar.gz: 248f4ea1224ee0ff46069d16b424b1c90a98d81b33610506c58d45ffb9693c08
+  metadata.gz: d6fcb0462dc2821749f43c243267e8eef32c5362d2a647769c3f93ccc048ddd0
+  data.tar.gz: 131ec1045f331591fb3f1c522824ea1e14c56fad40091bccacde73bb7f64a649
 SHA512:
-  metadata.gz: caf8d608d673afd9e71d3c421d2c096db503bb0054bf1ca846f33de738ccb2662ab53a6c715e6003f9a27b48d148d1e8f60f509076d53eee1b1bebf56c023e97
-  data.tar.gz: 78c2fd433b79741516f842b069adfa90c0452694a106554e99fd0ac5415684d6b82beb7f44dae63a09a745fc075bf21c1fb71276fa8ad691965f9ddd335e8d9a
+  metadata.gz: dfbb78f6f9ea625ae2848210722aa58106e6efd80af31d38e239585def253b7fb0e00426d18804e4177040492469d3498eaf61dca0cb7880ee482bd1c9669d0e
+  data.tar.gz: 80c944b3b2a544c593a221c9600c2a8cc441b273e37dc77f3ca1bbb738e381e1fcc0db42cbc66265f6d75832ee0ca396b008ffec7ff666549db313d386b82e81

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# 0.15.0 (2026/11/02)
+
+Breaking changes:
+
+* A subscript of an empty array is read as it is for any other array, where every subscript of an empty array raised `Cumo::NArray::ShapeError`. `a[true, 1]` of a 0 x 3 array answers an empty view, and a subscript that names an element raises as it does for any array, so `a[0]` raises `IndexError`. An empty range now selects nothing when it starts where an element could be inserted, as with `Array#[]`, so `b[2...2, true]` of a 2 x 3 array answers a 0 x 3 view where it raised `RangeError`. The README lists where this differs from Numo (PR #641)
+* `Cumo::RObject` no longer has `store_binary`, `to_string`, `hton` or `Cumo::RObject.from_string`, and `set` with a String raises `NoMethodError` for it. They read or wrote the object references of an RObject as raw bytes, so the next garbage collection could crash, and `to_string` gave out heap addresses. Calling the methods of `Cumo::NArray` on an RObject through `bind_call` raises `TypeError` (PR #638)
+
+Fixes:
+
+* Fix `require "cumo"` under `ruby -w` warning "method redefined; discarding old %". Cumo no longer defines `Range#%` again, which Ruby has had since 2.6 and which works the same (PR #643)
+* Fix a crash, possible since 0.7.0, when storing an Array whose NArray row of another type is followed by a row that raises, such as one with the wrong number of dimensions. The garbage collector could free the cast copy of the row before the store let go of it (PR #642)
+* Fix a range with a negative step and an excluded or missing end selecting the wrong elements: `(4...1).step(-1)` selected 5 elements of a 5-element array where it should select 3, and `(3..).step(-1)` none. Fix a stepped range that selects nothing returning elements, as `(1..0).step(2)` returned one and `(3...3).step(-1)` two (PR #641)
+* Fix `to_a` and `format_to_a` aborting when Cumo is compiled with `RUBY_DEBUG` against a Ruby whose headers check the index of `RARRAY_AREF`, as Ruby master does since ruby/ruby@61261bf5c4 (PR #640)
+
+Changes:
+
+* CI builds against CUDA 13.4.3 on Ubuntu 26.04 where it built against 13.4.1 on Ubuntu 24.04, and the CUDA 12.9.2 job builds for sm_121 where it built for sm_120 (PR #639)
+* The first `sort`, `median` or `sort_index` of a type loads the sort kernels of that type alone, where the first of a process loaded those of all twelve types. On SFloat the first `sort` is about 5.7 times faster, `median` about 9 times and `sort_index` about 3 times (PR #636)
+* The first `cumsum` or `cumprod` of a process no longer loads every sort kernel, which makes the first SFloat `cumsum` about 2.1 times faster and keeps the peak RSS 57 MB lower (PR #635)
+* `sum`, `mean`, `max`, `min` and the `dot` of two vectors have a kernel module of their own, so the first of them on a type no longer loads every reduction of the type. The first SFloat `sum` or vector `dot` of a process is about 8.6 times faster (PR #634)
+
 # 0.14.1 (2026/10/22)
 
 Fixes:

data/README.md

@@ -198,6 +198,30 @@ Cumo::DFloat.new(1, 3).seq.transpose.contiguous?               #=> true
 Code that runs against both libraries should not read `contiguous?` and expect the same answer.
 Where it wants a contiguous array it can ask for one, since `dup` answers one in either library.
 
+#### Subscripts That Select Nothing
+
+Numo raises `ShapeError` for every subscript of an empty array.
+Cumo returns the empty view numpy does, and raises only for a subscript that names an element.
+
+```ruby
+a = Cumo::DFloat.new(0, 3)
+a[true, 1].shape   #=> [0], where Numo raises ShapeError
+a[0]               # raises IndexError, where Numo raises ShapeError
+```
+
+A range that selects nothing only has to start where an element could be inserted, as with `Array#[]`.
+Numo raises `RangeError` when such a range starts at either end of an axis.
+
+```ruby
+b = Cumo::DFloat.new(2, 3).seq
+b[2...2, true].shape   #=> [0, 3], where Numo raises RangeError
+b[3...3, true]         # raises RangeError in both
+```
+
+A stepped range that selects nothing also selects nothing in Cumo.
+Numo returns one element for `(1..0).step(2)` and two for `(3...3).step(-1)`.
+`compatible_mode` does not change any of this.
+
 ### Keeping Scalars On The Device
 
 The 0-dimensional return is what lets an iterative loop stay on the GPU.

data/Rakefile

@@ -39,7 +39,9 @@ Rake::TestTask.new(:test) do |t|
 end
 
 require "rake/extensiontask"
-Rake::ExtensionTask.new("cumo")
+ext = Rake::ExtensionTask.new("cumo")
+# The Makefile lists an object for each kernel part, so a new part needs extconf.rb to run again.
+file "#{ext.tmp_dir}/#{ext.platform}/#{ext.name}/#{RUBY_VERSION}/Makefile" => "ext/cumo/narray/gen/kernel_parts.rb"
 
 desc 'Build the C++ memory pool test harness without running it (running it needs a GPU)'
 task :build_ctest do

data/ext/cumo/cuda/cub.cu

@@ -0,0 +1,26 @@
+#include <cub/util_device.cuh>
+#include "cumo/template_kernel.h"
+
+namespace {
+
+__global__ void cumo_cub_ptx_version_probe() {}
+
+}  // namespace
+
+// CUB learns each device's PTX version once, from the attributes of an empty
+// kernel. Each translation unit has its own empty kernel, but the link keeps
+// one copy of the code that asks. The query loads the module that copy came
+// from, which can be a large one the caller never runs. This module has one
+// kernel built with the same flags, so it gives the same version at little cost.
+extern "C" void
+cumo_cuda_cub_prime_ptx_version(void)
+{
+    cub::GetPerDeviceAttributeCache<cub::PtxVersionCacheTag>()(
+        [](int& ptx_version) {
+            cudaFuncAttributes attrs = {};
+            cudaError_t status = cudaFuncGetAttributes(&attrs, (const void*)cumo_cub_ptx_version_probe);
+            ptx_version = attrs.ptxVersion * 10;
+            return status;
+        },
+        cub::CurrentDevice());
+}

data/ext/cumo/extconf.rb

@@ -55,7 +55,6 @@ narray/ndloop
 narray/ndloop_kernel
 narray/data
 narray/data_kernel
-narray/sort_kernel
 narray/math
 narray/SFMT
 narray/struct
@@ -70,6 +69,7 @@ cuda/cudnn
 cuda/cudnn_impl
 cuda/cusolver
 cuda/cufft
+cuda/cub
 )
 %w[bit int8 int16 int32 int64 uint8 uint16 uint32 uint64 hfloat bfloat sfloat dfloat scomplex dcomplex robject].each do |type_name|
   srcs << "narray/types/#{type_name}"

data/ext/cumo/{narray/sort_kernel.cu → include/cumo/sort_kernel.h}

@@ -1,3 +1,6 @@
+#ifndef CUMO_SORT_KERNEL_H
+#define CUMO_SORT_KERNEL_H
+
 #include "cumo/narray_kernel.h"
 #include "cumo/indexer.h"
 #include "cumo/template_kernel.h"
@@ -146,6 +149,7 @@ cudaError_t sort_pairs(const Key* kin, Key* kout, const Value* vin, Value* vout,
                        int64_t total, int64_t n_rows, int64_t row_len) {
     size_t bytes = 0;
     cudaError_t st = cudaSuccess;
+    cumo_cuda_cub_prime_ptx_version();
     if (n_rows == 1) {
         st = cub::DeviceRadixSort::SortPairs(nullptr, bytes, kin, kout, vin, vout, total, 0, sizeof(Key) * 8, cumo_cuda_stream());
         if (st != cudaSuccess) { return st; }
@@ -168,6 +172,7 @@ template <typename Key>
 cudaError_t sort_keys(const Key* kin, Key* kout, int64_t total, int64_t n_rows, int64_t row_len) {
     size_t bytes = 0;
     cudaError_t st = cudaSuccess;
+    cumo_cuda_cub_prime_ptx_version();
     if (n_rows == 1) {
         st = cub::DeviceRadixSort::SortKeys(nullptr, bytes, kin, kout, total, 0, sizeof(Key) * 8, cumo_cuda_stream());
         if (st != cudaSuccess) { return st; }
@@ -329,6 +334,12 @@ __global__ void iota_kernel(I* out, int64_t n) {
     }
 }
 
+// The positions go to CUB as this rather than as a bare integer, so that
+// SortPairs is a function of this file alone. With a bare integer it is the
+// same function for every type whose key has the same width, and the link
+// keeps one, so SFloat would launch the kernels of the UInt32 module.
+template <typename I> struct position { I value; };
+
 // perm[i] is the position the i-th smallest element sat at, and the index
 // array holds the number to answer for that position.
 template <int NDIM, typename I>
@@ -373,13 +384,13 @@ void sort_index_rows(cumo_na_iarray_t* a, cumo_na_indexer_t* indexer, cumo_na_ia
         key_t* kout = (key_t*)cumo_cuda_runtime_malloc(sizeof(key_t) * total);
         float_key_kernel<T><<<grid_dim, block_dim, 0, cumo_cuda_stream()>>>(data, kin, total);
         cumo_check_launch_holding(kin, kout, pin, pout, gathered);
-        cumo_check_status_holding(sort_pairs(kin, kout, pin, pout, total, n_rows, row_len),
+        cumo_check_status_holding(sort_pairs(kin, kout, (const position<I>*)pin, (position<I>*)pout, total, n_rows, row_len),
                              kin, kout, pin, pout, gathered);
         cumo_cuda_runtime_free((char*)kout);
         cumo_cuda_runtime_free((char*)kin);
     } else {
         T* kout = (T*)cumo_cuda_runtime_malloc(sizeof(T) * total);
-        cumo_check_status_holding(sort_pairs(data, kout, pin, pout, total, n_rows, row_len),
+        cumo_check_status_holding(sort_pairs(data, kout, (const position<I>*)pin, (position<I>*)pout, total, n_rows, row_len),
                              kout, pin, pout, gathered);
         cumo_cuda_runtime_free((char*)kout);
     }
@@ -396,7 +407,7 @@ void sort_index_rows(cumo_na_iarray_t* a, cumo_na_indexer_t* indexer, cumo_na_ia
 
 } // namespace
 
-// float_key is only defined for the two float types, so the integer entry
+// float_key is only defined for the float types, so the integer entry
 // points must not instantiate it; the bool picks the branch at compile time.
 #define CUMO_DEF_SORT(name, type, is_float)                                                     \
     extern "C" void cumo_##name##_sort_kernel_launch(                                           \
@@ -420,15 +431,4 @@ void sort_index_rows(cumo_na_iarray_t* a, cumo_na_indexer_t* indexer, cumo_na_ia
         }                                                                                       \
     }
 
-CUMO_DEF_SORT(int8, int8_t, false)
-CUMO_DEF_SORT(int16, int16_t, false)
-CUMO_DEF_SORT(int32, int32_t, false)
-CUMO_DEF_SORT(int64, int64_t, false)
-CUMO_DEF_SORT(uint8, u_int8_t, false)
-CUMO_DEF_SORT(uint16, u_int16_t, false)
-CUMO_DEF_SORT(uint32, u_int32_t, false)
-CUMO_DEF_SORT(uint64, u_int64_t, false)
-CUMO_DEF_SORT(hfloat, cumo_half, true)
-CUMO_DEF_SORT(bfloat, cumo_bfloat, true)
-CUMO_DEF_SORT(sfloat, float, true)
-CUMO_DEF_SORT(dfloat, double, true)
+#endif /* ifndef CUMO_SORT_KERNEL_H */

data/ext/cumo/include/cumo/template_kernel.h

@@ -186,6 +186,8 @@ void cumo_cuda_runtime_check_kernel_launch(void);
 // The stream every launch and copy goes to. It is 0 until Stream#with says
 // otherwise, and thread local, so one thread's choice is not another's.
 struct CUstream_st* cumo_cuda_stream(void);
+// Call before any CUB or Thrust algorithm. Defined in cuda/cub.cu, which says why.
+void cumo_cuda_cub_prime_ptx_version(void);
 
 // The forms to call while scratch is held, which free what they are given
 // before they raise. Pass every buffer that is still outstanding, including the

data/ext/cumo/narray/data.c

@@ -158,6 +158,9 @@ cumo_na_swap_byte(VALUE self)
                           CUMO_STRIDE_LOOP|CUMO_NDF_INDEXER_LOOP|CUMO_NDF_ACCEPT_BYTESWAP,
                           1, 1, ain, aout };
 
+    if (rb_obj_is_kind_of(self, cumo_cRObject)) {
+        rb_raise(rb_eTypeError, "cannot swap bytes of %s", rb_obj_classname(self));
+    }
     // Cumo::Bit's element is one bit, so swapping the bytes of an element
     // changes nothing, and a loop stepping by the element stride would walk
     // one byte per bit, eight times past the end of the packed buffer. Only

data/ext/cumo/narray/gen/cogen_kernel.rb

@@ -41,14 +41,14 @@ erb_dir.unshift("tmpl_bit") if (type_name == "bit")
 erb_dir.map! { |d| File.join(thisdir, d) }
 
 TEMPLATE_KERNEL_PARTS = {
-  "accum" => %w[reduce reduce_nan],
-  "accum_index" => %w[reduce reduce_nan],
-  "accum_arg" => %w[reduce reduce_nan],
-  "accum_binary" => %w[reduce reduce_nan reduce_from],
-  "cum" => %w[reduce],
-  "layer_norm" => %w[reduce],
-  "rms_norm" => %w[reduce],
-  "softmax" => %w[reduce],
+  "accum" => %w[reduce reduce_rare reduce_nan],
+  "accum_index" => %w[reduce reduce_rare reduce_nan],
+  "accum_arg" => %w[reduce reduce_rare reduce_nan],
+  "accum_binary" => %w[reduce reduce_rare reduce_nan reduce_from],
+  "cum" => %w[reduce_rare],
+  "layer_norm" => %w[reduce_rare],
+  "rms_norm" => %w[reduce_rare],
+  "softmax" => %w[reduce_rare],
   "bit_count" => %w[reduce],
   "bit_reduce" => %w[reduce],
   "bit_stat" => %w[reduce],
@@ -59,10 +59,14 @@ TEMPLATE_KERNEL_PARTS = {
   "poly" => %w[misc],
   "quantize_symmetric" => %w[misc],
   "unary_ret2" => %w[misc],
+  "sort" => %w[sort],
 }.freeze
 
 MATH_TEMPLATES = %w[unary_s binary_s ternary_s frexp].freeze
 COMMON_MATH = %w[sqrt log log2 log10 exp exp2 sin cos tan tanh erf gelu gelu_tanh silu sigmoid softplus].freeze
+# mulsum is here for dot of two vectors.
+COMMON_REDUCE = %w[sum mean max min mulsum].freeze
+RARE_REDUCE = %w[prod ptp minmax var stddev rms abs_sum abs_max abs_min kahan_sum min_index max_index argmin argmax].freeze
 
 abort "unknown kernel part: #{$kernel_part}" unless KERNEL_PARTS.include?($kernel_part)
 undeclared_math = COMMON_MATH - File.read(File.join(thisdir, "spec.rb")).scan(/^\s*math "(\w+)"/).flatten
@@ -83,8 +87,13 @@ class ErbPP
     @children.select { |c| c.kernel_parts.include?($kernel_part) }
   end
 
-  def kernel_part?(nan: false, from: nil)
-    $kernel_part == (from ? "reduce_from" : nan ? "reduce_nan" : "reduce")
+  def kernel_part?(op = nil, nan: false, from: nil)
+    return $kernel_part == "reduce_from" if from
+    return $kernel_part == "reduce_nan" if nan
+    return $kernel_part == "reduce" if COMMON_REDUCE.include?(op)
+    return $kernel_part == "reduce_rare" if RARE_REDUCE.include?(op)
+
+    raise ArgumentError, "#{op.inspect} is in neither COMMON_REDUCE nor RARE_REDUCE"
   end
 
   def indexer_dims(narrow = false)

data/ext/cumo/narray/gen/kernel_parts.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-KERNEL_PARTS = %w[main reduce reduce_nan reduce_from math math_rare compare cast misc].freeze
+KERNEL_PARTS = %w[main reduce reduce_nan reduce_from reduce_rare math math_rare compare cast misc sort].freeze
 MATH_TYPES = %w[hfloat bfloat sfloat dfloat scomplex dcomplex].freeze
+SORT_TYPES = %w[int8 int16 int32 int64 uint8 uint16 uint32 uint64 hfloat bfloat sfloat dfloat].freeze
 
 def kernel_parts_of(type_name)
-  return KERNEL_PARTS.first(4) if type_name == "robject"
+  return %w[main reduce reduce_nan reduce_from] if type_name == "robject"
 
   KERNEL_PARTS.reject do |part|
     (%w[math math_rare].include?(part) && !MATH_TYPES.include?(type_name)) ||
-      (%w[compare misc].include?(part) && type_name == "bit")
+      (%w[compare misc reduce_rare].include?(part) && type_name == "bit") ||
+      (part == "sort" && !SORT_TYPES.include?(type_name))
   end
 end
 

data/ext/cumo/narray/gen/spec.rb

@@ -100,8 +100,12 @@ end
 
 if is_object
   undef_singleton_method "from_binary"
+  undef_singleton_method "from_string"
+  undef_method "store_binary"
   undef_method "to_binary"
+  undef_method "to_string"
   undef_method "swap_byte"
+  undef_method "hton"
   undef_method "to_network"
   undef_method "to_vacs"
   undef_method "to_host"

data/ext/cumo/narray/gen/tmpl/accum_arg_kernel.cu

@@ -119,7 +119,7 @@ extern "C" {
 #endif
 #endif
 
-<% if kernel_part? %>
+<% if kernel_part?("argmin") %>
 void cumo_<%=type_name%>_argmin_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_arg_split<dtype, idx_t, cumo_<%=type_name%>_argmin_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_argmin_int<%=i%>_impl{});
@@ -133,7 +133,7 @@ void cumo_<%=type_name%>_argmin_nan_int<%=i%>_kernel_launch(cumo_na_reduction_ar
 }
 <% end %>
 
-<% if kernel_part? %>
+<% if kernel_part?("argmax") %>
 void cumo_<%=type_name%>_argmax_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_arg_split<dtype, idx_t, cumo_<%=type_name%>_argmax_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_argmax_int<%=i%>_impl{});

data/ext/cumo/narray/gen/tmpl/accum_binary_kernel.cu

@@ -63,7 +63,7 @@ extern "C" {
 //<% (is_float ? ["","_nan"] : [""]).each do |nan| %>
 //<% ([nil] + from_types).each do |from| %>
 //<% sfx = from ? "_from_#{from[:id]}" : "" %>
-//<% if kernel_part?(nan: nan == "_nan", from: from) %>
+//<% if kernel_part?(name, nan: nan == "_nan", from: from) %>
 void <%="cumo_#{type_name}_#{name}#{nan}#{sfx}_kernel_launch"%>(cumo_na_reduction_arg_t* arg, cumo_na_iarray_t* in2)
 {
     cumo_reduce_zip_split<dtype, <%= from ? from[:ctype] : "dtype" %>, dtype, <%="cumo_#{type_name}_#{name}#{nan}#{sfx}_impl"%>>(*arg, *in2, <%="cumo_#{type_name}_#{name}#{nan}#{sfx}_impl"%>{});

data/ext/cumo/narray/gen/tmpl/accum_index_kernel.cu

@@ -119,7 +119,7 @@ extern "C" {
 #endif
 #endif
 
-<% if kernel_part? %>
+<% if kernel_part?("min_index") %>
 void cumo_<%=type_name%>_min_index_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, idx_t, cumo_<%=type_name%>_min_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_min_index_int<%=i%>_impl{});
@@ -133,7 +133,7 @@ void cumo_<%=type_name%>_min_index_nan_int<%=i%>_kernel_launch(cumo_na_reduction
 }
 <% end %>
 
-<% if kernel_part? %>
+<% if kernel_part?("max_index") %>
 void cumo_<%=type_name%>_max_index_int<%=i%>_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, idx_t, cumo_<%=type_name%>_max_index_int<%=i%>_impl>(*arg, cumo_<%=type_name%>_max_index_int<%=i%>_impl{});

data/ext/cumo/narray/gen/tmpl/complex_accum_kernel.cu

@@ -215,33 +215,43 @@ extern "C" {
 #endif
 #endif
 
-<% if kernel_part? %>
+<% if kernel_part?("sum") %>
 void cumo_<%=type_name%>_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, <%=dtype%>, cumo_<%=type_name%>_sum_impl>(*arg, cumo_<%=type_name%>_sum_impl{});
 }
+<% end %>
 
+<% if kernel_part?("prod") %>
 void cumo_<%=type_name%>_prod_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, <%=dtype%>, cumo_<%=type_name%>_prod_impl>(*arg, cumo_<%=type_name%>_prod_impl{});
 }
+<% end %>
 
+<% if kernel_part?("mean") %>
 void cumo_<%=type_name%>_mean_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     rtype n = (rtype)(arg->in_indexer.total_size / arg->out_indexer.total_size);
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_mean_impl>(*arg, cumo_<%=type_name%>_mean_impl{n});
 }
+<% end %>
 
+<% if kernel_part?("var") %>
 void cumo_<%=type_name%>_var_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_var_impl>(*arg, cumo_<%=type_name%>_var_impl{});
 }
+<% end %>
 
+<% if kernel_part?("stddev") %>
 void cumo_<%=type_name%>_stddev_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_stddev_impl>(*arg, cumo_<%=type_name%>_stddev_impl{});
 }
+<% end %>
 
+<% if kernel_part?("rms") %>
 void cumo_<%=type_name%>_rms_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     rtype n = (rtype)(arg->in_indexer.total_size / arg->out_indexer.total_size);
@@ -280,25 +290,29 @@ void cumo_<%=type_name%>_rms_nan_kernel_launch(cumo_na_reduction_arg_t* arg)
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_rms_nan_impl>(*arg, cumo_<%=type_name%>_rms_nan_impl{});
 }
 <% end %>
-<% if kernel_part? %>
+<% if kernel_part?("abs_sum") %>
 void cumo_<%=type_name%>_abs_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_abs_sum_impl>(*arg, cumo_<%=type_name%>_abs_sum_impl{});
 }
+<% end %>
 
+<% if kernel_part?("abs_max") %>
 void cumo_<%=type_name%>_abs_max_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     using impl = cumo_<%=type_name%>_abs_extremum_of<cumo_<%=type_name%>_abs_extremum_rules::Max>;
     cumo_reduce_split<dtype, rtype, impl>(*arg, impl{});
 }
+<% end %>
 
+<% if kernel_part?("abs_min") %>
 void cumo_<%=type_name%>_abs_min_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     using impl = cumo_<%=type_name%>_abs_extremum_of<cumo_<%=type_name%>_abs_extremum_rules::Min>;
     cumo_reduce_split<dtype, rtype, impl>(*arg, impl{});
 }
 <% end %>
-<% if is_double_precision && kernel_part? %>
+<% if is_double_precision && kernel_part?("kahan_sum") %>
 
 void cumo_<%=type_name%>_kahan_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {

data/ext/cumo/narray/gen/tmpl/cum_kernel.cu

@@ -162,6 +162,7 @@ struct <%="cumo_thrust_#{name}#{j}"%>
 template<typename Iterator1, typename Iterator2>
 static cudaError_t <%="cumo_#{type_name}_#{name}#{j}_scan_by_key"%>(Iterator1 first, Iterator1 last, Iterator2 result, uint64_t row_len)
 {
+    cumo_cuda_cub_prime_ptx_version();
     cumo_thrust_pool_allocator alloc;
     <%="cumo_thrust_#{name}_row"%> row = {row_len};
     auto keys = thrust::make_transform_iterator(thrust::make_counting_iterator<uint64_t>(0), row);
@@ -190,6 +191,7 @@ static cudaError_t <%="cumo_#{type_name}_#{name}#{j}_scan_by_key"%>(Iterator1 fi
 template<typename Iterator1, typename Iterator2>
 static cudaError_t <%="cumo_#{type_name}_#{name}#{j}_scan"%>(Iterator1 first, Iterator1 last, Iterator2 result)
 {
+    cumo_cuda_cub_prime_ptx_version();
     cumo_thrust_pool_allocator alloc;
     try {
 <% if widen %>

data/ext/cumo/narray/gen/tmpl/float_accum_kernel.cu

@@ -181,23 +181,29 @@ extern "C" {
 #endif
 #endif
 
-<% if kernel_part? %>
+<% if kernel_part?("mean") %>
 void cumo_<%=type_name%>_mean_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     <%=acc%> n = (<%=acc%>)(arg->in_indexer.total_size / arg->out_indexer.total_size);
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_mean_impl>(*arg, cumo_<%=type_name%>_mean_impl{n});
 }
+<% end %>
 
+<% if kernel_part?("var") %>
 void cumo_<%=type_name%>_var_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_var_impl>(*arg, cumo_<%=type_name%>_var_impl{});
 }
+<% end %>
 
+<% if kernel_part?("stddev") %>
 void cumo_<%=type_name%>_stddev_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_stddev_impl>(*arg, cumo_<%=type_name%>_stddev_impl{});
 }
+<% end %>
 
+<% if kernel_part?("rms") %>
 void cumo_<%=type_name%>_rms_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     <%=acc%> n = (<%=acc%>)(arg->in_indexer.total_size / arg->out_indexer.total_size);
@@ -226,25 +232,31 @@ void cumo_<%=type_name%>_rms_nan_kernel_launch(cumo_na_reduction_arg_t* arg)
     cumo_reduce_split<dtype, rtype, cumo_<%=type_name%>_rms_nan_impl>(*arg, cumo_<%=type_name%>_rms_nan_impl{});
 }
 <% end %>
-<% if %w[sfloat dfloat].include?(type_name) && kernel_part? %>
+<% if %w[sfloat dfloat].include?(type_name) %>
+<% if kernel_part?("abs_sum") %>
 void cumo_<%=type_name%>_abs_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_abs_sum_impl>(*arg, cumo_<%=type_name%>_abs_sum_impl{});
 }
+<% end %>
 
+<% if kernel_part?("abs_max") %>
 void cumo_<%=type_name%>_abs_max_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     using impl = cumo_<%=type_name%>_abs_extremum_of<cumo_<%=type_name%>_extremum_rules::Max>;
     cumo_reduce_split<dtype, dtype, impl>(*arg, impl{});
 }
+<% end %>
 
+<% if kernel_part?("abs_min") %>
 void cumo_<%=type_name%>_abs_min_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     using impl = cumo_<%=type_name%>_abs_extremum_of<cumo_<%=type_name%>_extremum_rules::Min>;
     cumo_reduce_split<dtype, dtype, impl>(*arg, impl{});
 }
 <% end %>
-<% if is_double_precision && kernel_part? %>
+<% end %>
+<% if is_double_precision && kernel_part?("kahan_sum") %>
 
 void cumo_<%=type_name%>_kahan_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {

data/ext/cumo/narray/gen/tmpl/real_accum_kernel.cu

@@ -198,54 +198,72 @@ extern "C" {
 #endif
 #endif
 
-<% if kernel_part? %>
+<% if kernel_part?("sum") %>
 void cumo_<%=type_name%>_sum_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, <%=dtype%>, cumo_<%=type_name%>_sum_impl>(*arg, cumo_<%=type_name%>_sum_impl{});
 }
+<% end %>
 
+<% if kernel_part?("prod") %>
 void cumo_<%=type_name%>_prod_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, <%=dtype%>, cumo_<%=type_name%>_prod_impl>(*arg, cumo_<%=type_name%>_prod_impl{});
 }
+<% end %>
 
+<% if kernel_part?("min") %>
 void cumo_<%=type_name%>_min_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_min_impl>(*arg, cumo_<%=type_name%>_min_impl{});
 }
+<% end %>
 
+<% if kernel_part?("max") %>
 void cumo_<%=type_name%>_max_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_max_impl>(*arg, cumo_<%=type_name%>_max_impl{});
 }
+<% end %>
 
+<% if kernel_part?("ptp") %>
 void cumo_<%=type_name%>_ptp_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, dtype, cumo_<%=type_name%>_ptp_impl>(*arg, cumo_<%=type_name%>_ptp_impl{});
 }
+<% end %>
 
+<% if kernel_part?("minmax") %>
 void cumo_<%=type_name%>_minmax_kernel_launch(cumo_na_reduction_arg_t* arg, cumo_na_iarray_t* out2)
 {
     cumo_reduce_pair_split<dtype, dtype, cumo_<%=type_name%>_minmax_impl>(*arg, *out2, cumo_<%=type_name%>_minmax_impl{});
 }
+<% end %>
 <% unless is_float %>
 
+<% if kernel_part?("mean") %>
 void cumo_<%=type_name%>_mean_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     double n = (double)(arg->in_indexer.total_size / arg->out_indexer.total_size);
     cumo_reduce_split<dtype, double, cumo_<%=type_name%>_mean_impl>(*arg, cumo_<%=type_name%>_mean_impl{n});
 }
+<% end %>
 
+<% if kernel_part?("var") %>
 void cumo_<%=type_name%>_var_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, double, cumo_<%=type_name%>_var_impl>(*arg, cumo_<%=type_name%>_var_impl{});
 }
+<% end %>
 
+<% if kernel_part?("stddev") %>
 void cumo_<%=type_name%>_stddev_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     cumo_reduce_split<dtype, double, cumo_<%=type_name%>_stddev_impl>(*arg, cumo_<%=type_name%>_stddev_impl{});
 }
+<% end %>
 
+<% if kernel_part?("rms") %>
 void cumo_<%=type_name%>_rms_kernel_launch(cumo_na_reduction_arg_t* arg)
 {
     double n = (double)(arg->in_indexer.total_size / arg->out_indexer.total_size);

data/ext/cumo/narray/gen/tmpl/sort_kernel.cu

@@ -0,0 +1,19 @@
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#include "cumo/sort_kernel.h"
+
+// sort_index and median sort with the same kernels, so their entry points are
+// made here too.
+CUMO_DEF_SORT(<%=type_name%>, dtype, <%=is_float%>)
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif

data/ext/cumo/narray/index.c

@@ -68,7 +68,7 @@ static void
 cumo_na_index_set_step(cumo_na_index_arg_t *q, int i, size_t n, size_t beg, ssize_t step)
 {
     q->n    = n;
-    q->beg  = beg;
+    q->beg  = n == 0 ? 0 : beg;
     q->step = step;
     q->idx  = NULL;
     q->reduce = 0;
@@ -178,6 +178,11 @@ cumo_na_parse_array(VALUE ary, int orig_dim, ssize_t size, cumo_na_index_arg_t *
     cudaError_t status;
     int n = RARRAY_LEN(ary);
 
+    if (n == 0) {
+        cumo_na_index_set_step(q, orig_dim, 0, 0, 1);
+        return;
+    }
+
     // A step names the one element a one-element subscript does, without a
     // device allocation, a kernel to fill it, or the synchronize a loop pays
     // to read that one entry back. at() is left out: it gathers through an
@@ -250,10 +255,16 @@ cumo_na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, cumo_na_index_ar
         if (CUMO_NA_SIZE(na) != (size_t)size) {
             rb_raise(rb_eIndexError, "Bit-NArray size mismatch");
         }
-        a = rb_funcall(a, cumo_id_where, 0);
-        CumoGetNArray(a,na);
+        if (size > 0) {
+            a = rb_funcall(a, cumo_id_where, 0);
+            CumoGetNArray(a,na);
+        }
     }
     n = CUMO_NA_SIZE(na);
+    if (n == 0) {
+        cumo_na_index_set_step(q, orig_dim, 0, 0, 1);
+        return;
+    }
     idx = cumo_na_new(cIndex,1,&n);
     cumo_na_store(idx,a);
 
@@ -301,6 +312,28 @@ cumo_na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, cumo_na_index_ar
     q->orig_dim = orig_dim;
 }
 
+static ssize_t
+cumo_na_range_count(ssize_t beg, ssize_t end, int excl, ssize_t step, ssize_t size)
+{
+    ssize_t last;
+
+    if (step > 0) {
+        if (excl ? end <= beg : end < beg) {
+            return (beg < 0 || beg > size || end < -1 || end > size) ? -1 : 0;
+        }
+        last = excl ? end - 1 : end;
+    } else {
+        if (excl ? end >= beg : end > beg) {
+            return (beg < -1 || beg >= size || end < -1 || end > size) ? -1 : 0;
+        }
+        last = excl ? end + 1 : end;
+    }
+    if (beg < 0 || beg >= size || last < 0 || last >= size) {
+        return -1;
+    }
+    return (last - beg) / step + 1;
+}
+
 static void
 cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
@@ -309,8 +342,8 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
     // caught that: a truncated count came out negative up to 2**32 and was
     // rounded to an empty view, and past that it came out positive and wrong.
     ssize_t n;
-    ssize_t beg, end, beg_orig, end_orig;
-    const char *dot = "..", *edot = "...";
+    ssize_t beg, end;
+    int excl;
 
 #ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
     rb_arithmetic_sequence_components_t x;
@@ -323,61 +356,34 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
         rb_raise(rb_eArgError, "step must not be zero");
     }
 
-    beg = beg_orig = NUM2SSIZET(x.begin);
-    if (beg < 0) {
-        beg += size;
-    }
+    beg = NUM2SSIZET(x.begin);
     if (T_NIL == TYPE(x.end)) { // endless range
-        end = size - 1;
-        if (RTEST(x.exclude_end)) {
-            dot = edot;
-        }
-        if (beg < 0 || beg >= size) {
-            rb_raise(rb_eRangeError,
-                     "%"SZF"d%s is out of range for size=%"SZF"d",
-                     beg_orig, dot, size);
-        }
+        end = step > 0 ? size - 1 : 0;
+        excl = 0;
     } else {
-        end = end_orig = NUM2SSIZET(x.end);
+        end = NUM2SSIZET(x.end);
         if (end < 0) {
             end += size;
         }
-        if (RTEST(x.exclude_end)) {
-            end--;
-            dot = edot;
-        }
-        if (beg < 0 || beg >= size || end < 0 || end >= size) {
-            rb_raise(rb_eRangeError,
-                     "%"SZF"d%s%"SZF"d is out of range for size=%"SZF"d",
-                     beg_orig, dot, end_orig, size);
-        }
+        excl = RTEST(x.exclude_end);
     }
 #else
-    VALUE excl_end;
-
-    beg = beg_orig = NUM2SSIZET(rb_funcall(range,cumo_id_beg,0));
-    if (beg < 0) {
-        beg += size;
-    }
-    end = end_orig = NUM2SSIZET(rb_funcall(range,cumo_id_end,0));
+    beg = NUM2SSIZET(rb_funcall(range,cumo_id_beg,0));
+    end = NUM2SSIZET(rb_funcall(range,cumo_id_end,0));
     if (end < 0) {
         end += size;
     }
-    excl_end = rb_funcall(range,cumo_id_exclude_end,0);
-    if (RTEST(excl_end)) {
-        end--;
-        dot = edot;
+    excl = RTEST(rb_funcall(range,cumo_id_exclude_end,0));
+#endif
+    if (beg < 0) {
+        beg += size;
     }
-    if (beg < 0 || beg >= size || end < 0 || end >= size) {
-        rb_raise(rb_eRangeError,
-                 "%"SZF"d%s%"SZF"d is out of range for size=%"SZF"d",
-                 beg_orig, dot, end_orig, size);
+    n = cumo_na_range_count(beg, end, excl, step, size);
+    if (n < 0) {
+        rb_raise(rb_eRangeError, "%"PRIsVALUE" is out of range for size=%"SZF"d",
+                 rb_inspect(range), size);
     }
-#endif
-    n = (end-beg)/step+1;
-    if (n<0) n=0;
     cumo_na_index_set_step(q,orig_dim,n,beg,step);
-
 }
 
 void
@@ -622,6 +628,9 @@ cumo_na_index_aref_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
         j++;
         total *= size;
     }
+    if (total == 0) {
+        na2->offset = 0;
+    }
     cumo_na_set_newaxis_strides(na2, newaxis, n_newaxis, j, elmsz);
     na2->base.size = total;
 }
@@ -696,10 +705,12 @@ cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
                 size_t  last;
                 stride1 = -stride1;
                 last = na1->base.shape[q[i].orig_dim] - 1;
-                if (na2->offset < last * stride1) {
-                    rb_raise(rb_eStandardError,"bug: negative offset");
+                if (na1->base.size > 0) {
+                    if (na2->offset < last * stride1) {
+                        rb_raise(rb_eStandardError,"bug: negative offset");
+                    }
+                    na2->offset -= last * stride1;
                 }
-                na2->offset -= last * stride1;
                 cumo_na_index_aref_naview_index_stride_last_kernel_launch(index, stride1, last, size);
             } else {
                 cumo_na_index_aref_naview_index_stride_kernel_launch(index, stride1, size);
@@ -727,10 +738,27 @@ cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
         j++;
         total *= size;
     }
+    if (total == 0) {
+        na2->offset = na1->offset;
+    }
     cumo_na_set_newaxis_strides(na2, newaxis, n_newaxis, j, elmsz);
     na2->base.size = total;
 }
 
+static size_t
+cumo_na_index_at_size(const cumo_na_index_arg_t *q, int ndim)
+{
+    int i;
+    size_t size = q[ndim-1].n;
+
+    for (i=0; i<ndim-1; i++) {
+        if (q[i].n != size) {
+            rb_raise(cumo_na_eShapeError, "index array sizes mismatch");
+        }
+    }
+    return size;
+}
+
 void cumo_na_index_at_nadata_index_stride_add_kernel_launch(size_t *idx, size_t *idx1, ssize_t s1, uint64_t n);
 void cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n);
 void cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n);
@@ -740,7 +768,7 @@ cumo_na_index_at_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
                      cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
 {
     int i;
-    size_t size = q[ndim-1].n;
+    size_t size = na2->base.size;
     ssize_t stride1;
     ssize_t *strides_na1;
     size_t  *index;
@@ -759,15 +787,6 @@ cumo_na_index_at_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
 
     for (i=ndim-1; i>=0; i--) {
         stride1 = strides_na1[q[i].orig_dim];
-        if (i==ndim-1) {
-            if (size == 0) {
-                rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
-            }
-        } else {
-            if (size != q[i].n) {
-                rb_raise(cumo_na_eShapeError, "index array sizes mismatch");
-            }
-        }
 
         if (q[i].idx != NULL) {
             if (i==ndim-1) {
@@ -787,8 +806,6 @@ cumo_na_index_at_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
         }
 
     }
-    na2->base.size = size;
-    na2->base.shape[0] = size;
 }
 
 void cumo_na_index_at_naview_index_index_index_add_kernel_launch(size_t *idx, size_t *idx1, size_t *idx2, uint64_t n);
@@ -801,7 +818,7 @@ cumo_na_index_at_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
 {
     int i;
     size_t  *index;
-    size_t size = q[ndim-1].n;
+    size_t size = na2->base.size;
 
     if (q[ndim-1].idx != NULL) {
         index = q[ndim-1].idx;
@@ -813,15 +830,6 @@ cumo_na_index_at_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
 
     for (i=ndim-1; i>=0; i--) {
         cumo_stridx_t sdx1 = na1->stridx[q[i].orig_dim];
-        if (i==ndim-1) {
-            if (size == 0) {
-                rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
-            }
-        } else {
-            if (size != q[i].n) {
-                rb_raise(cumo_na_eShapeError, "index array sizes mismatch");
-            }
-        }
 
         if (q[i].idx != NULL && CUMO_SDX_IS_INDEX(sdx1)) {
             // index <- index
@@ -899,8 +907,6 @@ cumo_na_index_at_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
             }
         }
     }
-    na2->base.size = size;
-    na2->base.shape[0] = size;
 }
 
 static int
@@ -981,6 +987,13 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
 
     elmsz = cumo_na_element_stride(self);
 
+    if (at_mode && ndim > 0) {
+        size_t size = cumo_na_index_at_size(q, ndim);
+        na2->base.size = size;
+        na2->base.shape[0] = size;
+        CUMO_SDX_SET_STRIDE(na2->stridx[0], elmsz);
+    }
+
     switch(na1->type) {
     case CUMO_NARRAY_DATA_T:
     case CUMO_NARRAY_FILEMAP_T:
@@ -989,7 +1002,9 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
             na2->base.size = 1;
         } else {
             if (at_mode) {
-                cumo_na_index_at_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+                if (na2->base.size > 0) {
+                    cumo_na_index_at_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+                }
             } else {
                 cumo_na_index_aref_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
             }
@@ -1005,7 +1020,9 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
             na2->offset = ((cumo_narray_view_t *)na1)->offset;
             na2->data = ((cumo_narray_view_t *)na1)->data;
             if (at_mode) {
-               cumo_na_index_at_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+                if (na2->base.size > 0) {
+                    cumo_na_index_at_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+                }
             } else {
                cumo_na_index_aref_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
             }
@@ -1201,9 +1218,6 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
     VALUE a;
 
     CumoGetNArray(self,na);
-    if (na->size == 0) {
-        rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
-    }
     idx = ALLOCA_N(ssize_t, argc);
     for (i=j=0; i<argc; i++) {
         a = argv[i];
@@ -1241,13 +1255,15 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
         pos = nv->offset;
         if (j == na->ndim) {
             for (i=j-1; i>=0; i--) {
-                x = cumo_na_range_check(idx[i], na->shape[i], i);
+                idx[i] = cumo_na_range_check(idx[i], na->shape[i], i);
+            }
+            for (i=j-1; i>=0; i--) {
                 sdx = nv->stridx[i];
                 if (CUMO_SDX_IS_INDEX(sdx)) {
                     cumo_na_index_wait_fill(nv);
-                    pos += CUMO_SDX_GET_INDEX(sdx)[x];
+                    pos += CUMO_SDX_GET_INDEX(sdx)[idx[i]];
                 } else {
-                    pos += CUMO_SDX_GET_STRIDE(sdx)*x;
+                    pos += CUMO_SDX_GET_STRIDE(sdx)*idx[i];
                 }
             }
             *pos_idx = pos;

data/ext/cumo/narray/narray.c

@@ -1820,6 +1820,9 @@ cumo_na_s_from_binary(int argc, VALUE *argv, VALUE type)
     VALUE vstr, vshape, vna;
     VALUE velmsz;
 
+    if (RTEST(rb_class_inherited_p(type, cumo_cRObject))) {
+        rb_raise(rb_eTypeError, "cannot restore %s from binary data", rb_class2name(type));
+    }
     narg = rb_scan_args(argc,argv,"11",&vstr,&vshape);
     Check_Type(vstr,T_STRING);
     str_len = RSTRING_LEN(vstr);
@@ -1931,6 +1934,9 @@ cumo_na_store_binary(int argc, VALUE *argv, VALUE self)
     VALUE velmsz;
     cumo_narray_t *na;
 
+    if (RTEST(rb_obj_is_kind_of(self, cumo_cRObject))) {
+        rb_raise(rb_eTypeError, "cannot store binary data to %s", rb_obj_classname(self));
+    }
     narg = rb_scan_args(argc,argv,"11",&vstr,&voffset);
     Check_Type(vstr,T_STRING);
     if (narg==2) {
@@ -2016,6 +2022,9 @@ cumo_na_to_binary(VALUE self)
     VALUE str;
     cumo_narray_t *na;
 
+    if (RTEST(rb_obj_is_kind_of(self, cumo_cRObject))) {
+        rb_raise(rb_eTypeError, "cannot convert %s into binary data", rb_obj_classname(self));
+    }
     CumoGetNArray(self,na);
     if (na->type == CUMO_NARRAY_VIEW_T &&
         !(cumo_na_view_offset_reaches_bytes(self) && cumo_na_check_contiguous(self)==Qtrue)) {

data/ext/cumo/narray/ndloop.c

@@ -53,6 +53,7 @@ typedef struct CUMO_NA_MD_LOOP {
                               // 3 for sum(), 1 for sum(axis: 1), 2 for sum(axis: [1,2])
     int   *trans_map;
     size_t sub_narray_len;    // elements the sub-narray of the current row reaches with, for loop_store_subnarray
+    VALUE  sub_narray;        // keeps the row's sub-narray, which may be a cast copy, visible to the GC until ndloop_release
     VALUE  vargs;
     VALUE  reduce;            // dimension indicies to reduce in reduction kernel (in bits), e.g., for an array of shape:
                               // [2,3,4], 111b for sum(), 010b for sum(axis: 1), 110b for sum(axis: [1,2])
@@ -893,6 +894,7 @@ ndloop_set_output(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, VALUE args)
                 }
                 LARG(lp,j).value = t;
                 LARG(lp,j).elmsz = sizeof(VALUE);
+                rb_ary_push(results, Qnil);
             } else {
                 rb_raise(rb_eRuntimeError,"ndloop_set_output: invalid for type");
             }
@@ -2546,6 +2548,7 @@ loop_store_subnarray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, int i0, size_t *c
     if (rb_obj_class(a) != a_type) {
         a = rb_funcall(a_type, cumo_id_cast, 1, a);
     }
+    lp->sub_narray = a;
     CumoGetNArray(a,na);
     if (na->ndim != nd-i0+1) {
         rb_raise(cumo_na_eShapeError, "mismatched dimension of sub-narray: "
@@ -2602,6 +2605,7 @@ loop_store_subnarray(cumo_ndfunc_t *nf, cumo_na_md_loop_t *lp, int i0, size_t *c
         }
     }
  loop_end:
+    LARG(lp,1).value = Qnil;
     LARG(lp,1).ptr = NULL;
     LARG(lp,1).shape = saved_shape;
     LARG(lp,1).elmsz = saved_elmsz;

data/ext/cumo/narray/step.c

@@ -271,8 +271,6 @@ cumo_na_step_sequence( VALUE obj, size_t *plen, double *pbeg, double *pstep )
 void
 Init_cumo_na_step()
 {
-    rb_define_alias(rb_cRange, "%", "step");
-
     cumo_id_beg  = rb_intern("begin");
     cumo_id_end  = rb_intern("end");
     cumo_id_len  = rb_intern("length");

data/lib/cumo/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Cumo
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 
   spec = Gem.loaded_specs["cumo"] if defined?(Gem)
   REVISION = (spec.metadata["cumo_revision"]&.dup&.freeze if spec && spec.full_gem_path == File.expand_path("../..", __dir__))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumo
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Naotoshi Seo
@@ -38,6 +38,7 @@ files:
 - Rakefile
 - cumo.gemspec
 - docs/src-tree.md
+- ext/cumo/cuda/cub.cu
 - ext/cumo/cuda/cublas.c
 - ext/cumo/cuda/cudnn.c
 - ext/cumo/cuda/cudnn_impl.cpp
@@ -78,6 +79,7 @@ files:
 - ext/cumo/include/cumo/reduce_kernel.h
 - ext/cumo/include/cumo/row_kernel.h
 - ext/cumo/include/cumo/row_method.h
+- ext/cumo/include/cumo/sort_kernel.h
 - ext/cumo/include/cumo/template.h
 - ext/cumo/include/cumo/template_kernel.h
 - ext/cumo/include/cumo/types/bf16_def.h
@@ -271,6 +273,7 @@ files:
 - ext/cumo/narray/gen/tmpl/softmax_kernel.cu
 - ext/cumo/narray/gen/tmpl/sort.c
 - ext/cumo/narray/gen/tmpl/sort_index.c
+- ext/cumo/narray/gen/tmpl/sort_kernel.cu
 - ext/cumo/narray/gen/tmpl/store.c
 - ext/cumo/narray/gen/tmpl/store_array.c
 - ext/cumo/narray/gen/tmpl/store_array_kernel.cu
@@ -334,7 +337,6 @@ files:
 - ext/cumo/narray/ndloop.c
 - ext/cumo/narray/ndloop_kernel.cu
 - ext/cumo/narray/rand.c
-- ext/cumo/narray/sort_kernel.cu
 - ext/cumo/narray/step.c
 - ext/cumo/narray/struct.c
 - lib/cumo.rb
@@ -370,7 +372,7 @@ metadata:
   changelog_uri: https://github.com/sonots/cumo/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/sonots/cumo/issues
   rubygems_mfa_required: 'true'
-  cumo_revision: v0.14.1
+  cumo_revision: v0.15.0
 rdoc_options: []
 require_paths:
 - lib