carray 3.0.0 → 3.0.1

data/ext/carray_call_cfunc.h

@@ -16,6 +16,18 @@
 #ifndef CARRAY_CALL_CFUNC_H
 #define CARRAY_CALL_CFUNC_H
 
+/* Chunk callback for the ca_call_cslab_N family.  `base` and `stride` are
+   one entry per operand, in the order the operands were passed; `n` is the
+   number of cells in this chunk; `m0` is the chunk's slice of the mask,
+   one byte per cell, or NULL when no INPUT carried a mask.  The arity does
+   not appear in the signature -- the operands arrive through `base` -- so
+   one typedef serves every arity. */
+typedef void (*ca_cslab_t) (char **base, ca_size_t *stride, ca_size_t n,
+                            const boolean8_t *m0);
+
+typedef void (*ca_cslab_r_t) (char **base, ca_size_t *stride, ca_size_t n,
+                              const boolean8_t *m0, void *userdata);
+
 VALUE
 ca_call_cfunc_1 (void (*func)(void *p0), const char *fsync,
                             VALUE rcx0);
@@ -157,4 +169,145 @@ ca_call_cfunc_3_2_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t
 VALUE
 ca_call_cfunc_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, void (*mathfunc)(void*, void*, void*, void*, void*, void*, void *userdata), volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
 
+VALUE
+ca_call_cslab_1 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0);
+
+VALUE
+ca_call_cslab_2 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1);
+
+VALUE
+ca_call_cslab_3 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2);
+
+VALUE
+ca_call_cslab_4 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3);
+
+VALUE
+ca_call_cslab_5 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4);
+
+VALUE
+ca_call_cslab_6 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5);
+
+VALUE
+ca_call_cslab_7 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6);
+
+VALUE
+ca_call_cslab_1_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_2_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_3_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_4_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_5_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_6_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_7_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_1_1 (int8_t dty, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_1_2 (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_1_3 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_1_4 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4);
+
+VALUE
+ca_call_cslab_1_5 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5);
+
+VALUE
+ca_call_cslab_1_6 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6);
+
+VALUE
+ca_call_cslab_2_1 (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_2_2 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_2_3 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_2_4 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4);
+
+VALUE
+ca_call_cslab_3_1 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_3_2 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_3_3 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_1_1_r (int8_t dty, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_1_2_r (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_1_3_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
+VALUE
+ca_call_cslab_1_4_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata);
+
+VALUE
+ca_call_cslab_1_5_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, void *userdata);
+
+VALUE
+ca_call_cslab_1_6_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6, void *userdata);
+
+VALUE
+ca_call_cslab_2_1_r (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_2_2_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_2_3_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
+VALUE
+ca_call_cslab_2_4_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata);
+
+VALUE
+ca_call_cslab_3_1_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_3_2_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
 #endif /* CARRAY_CALL_CFUNC_H */

data/ext/carray_cast.c

@@ -2,9 +2,11 @@
 
   Cast surface (3 layers):
 
-    to_<type>     `a.to_int32` etc.  Returns a fresh entity CArray
-                  of the target data_type.  Independent storage from
-                  `self`.
+    <type>        `a.int32` etc., and the general `a.to_type(:int32)`.
+                  Returns a fresh entity CArray of the target
+                  data_type.  Independent storage from `self`.  (The
+                  C functions are named rb_ca_to_<type>, but the
+                  methods they register carry no `to_` prefix.)
 
     as_<type>     `a.as_int32` etc.  Returns a writable CAMonOp view
                   that reinterprets `self` cell-by-cell at the target
@@ -773,16 +775,62 @@ extern VALUE rb_ca_monop_build (VALUE cary, uint16_t op_id);
 /* Forward declaration: clip kernel (ext/carray_kernels.c, generated).  */
 extern VALUE rb_ca_clip (VALUE self, VALUE lo, VALUE hi);
 
+/* Which surface asked for a type-adapt view.  A Face's cells do not mean
+   their storage bytes and there is no view that decodes them, so each
+   caller says what it does instead of reinterpreting the storage.  */
+enum {
+  CA_ADAPT_VIEW,        /* as_type: the values are behind #to_type */
+  CA_ADAPT_READONLY,    /* wrap_readonly: the eager conversion is the answer */
+  CA_ADAPT_WRITABLE     /* wrap_writable: writes have nowhere to land */
+};
+
 /* Routes a type-adapt view request to CAMonOp(cast_<dt>) when the
    target is a plain numeric data_type (NOT CA_FIXLEN, NOT CA_OBJECT,
    and `rtype` is not a Class).  Falls back to CAFake
    (`rb_ca_fake_type`) for CA_FIXLEN sizing, CA_OBJECT, and class-rtype
    data_class overlay cases.
    Called by rb_ca_as_type_internal, rb_ca_wrap_readonly, and
-   rb_ca_wrap_writable in this file.  */
+   rb_ca_wrap_writable in this file.
+
+   A Face whose surface is not its storage reaches neither: reinterpreting
+   the storage would hand back the bytes the surface exists to hide (the
+   serial instead of the time, the descriptor instead of the string).
+   wrap_readonly, which already returns entities for its non-CArray inputs,
+   answers with the eager conversion #to_type performs -- the surface values,
+   or the Face's own #to_numeric for a numeric target.  as_type and
+   wrap_writable have no honest answer and say so.  */
 static VALUE
-ca_type_adapt_view (VALUE obj, VALUE rtype, int8_t data_type)
+ca_type_adapt_view (VALUE obj, VALUE rtype, int8_t data_type, int mode)
 {
+  CArray *ca;
+
+  TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
+
+  /* Same split the eager cast makes: :object is the Face's surface for every
+     Face, and a NonNumeric Face (CA_FIXLEN surface) has no reading of its
+     storage as a number either.  A Numeric Face falls through, because there
+     its surface *is* its storage and the ordinary cast below is right.  */
+  if ( ca_is_face(ca) && ( data_type == CA_OBJECT
+                           || ca->data_type == CA_FIXLEN ) ) {
+    VALUE args[1];
+    switch ( mode ) {
+    case CA_ADAPT_READONLY:
+      args[0] = rtype;
+      return rb_ca_to_type_internal(1, args, obj);
+    case CA_ADAPT_WRITABLE:
+      rb_raise(rb_eTypeError,
+               "%s has no writable view in another data_type: the writes "
+               "would land on the storage its surface hides -- wrap "
+               "#parent to reach that storage",
+               rb_obj_classname(obj));
+    default:
+      rb_raise(rb_eTypeError,
+               "%s has no view of its values in another data_type: "
+               "#to_type gives the values, #parent the raw storage",
+               rb_obj_classname(obj));
+    }
+  }
+
   if ( data_type != CA_FIXLEN
        && data_type != CA_OBJECT
        && TYPE(rtype) != T_CLASS ) {
@@ -815,7 +863,7 @@ rb_ca_as_type_internal (int argc, VALUE *argv, VALUE self)
   /* Natural-width cast: dispatch via helper (CAMonOp for numeric,
      CAFake for CA_FIXLEN sizing / CA_OBJECT / class-rtype). */
   if ( bytes == (ca_size_t) ca_sizeof[data_type] ) {
-    obj = ca_type_adapt_view(self, rtype, data_type);
+    obj = ca_type_adapt_view(self, rtype, data_type, CA_ADAPT_VIEW);
     return obj;
   }
 
@@ -1075,7 +1123,7 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, rtype, data_type);
+      obj = ca_type_adapt_view(obj, rtype, data_type, CA_ADAPT_WRITABLE);
     }
   }
   else if ( NIL_P(obj) ) {                          /* obj == nil */
@@ -1113,7 +1161,8 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_WRITABLE);
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
@@ -1130,7 +1179,8 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_WRITABLE);
     }
   }
   else {
@@ -1171,7 +1221,7 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, rtype, data_type);
+      obj = ca_type_adapt_view(obj, rtype, data_type, CA_ADAPT_READONLY);
     }
   }
   else if ( rb_obj_is_kind_of(obj, rb_cNumeric) ) {  /* number */
@@ -1193,7 +1243,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else if ( TYPE(obj) == T_STRING ) {                /* string */
@@ -1234,7 +1285,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
@@ -1247,7 +1299,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else {                                           /* object */
@@ -1400,16 +1453,6 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
   TypedData_Get_Struct(*self, CArray, &carray_data_type, ca);
   TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
 
-  if ( ca->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *self = ca_ubrep_bind_with(*self, *other);
-    TypedData_Get_Struct(*self, CArray, &carray_data_type, ca);
-  }
-
-  if ( cb->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *other = ca_ubrep_bind_with(*other, *self);
-    TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
-  }
-
   /* Implicit size-1 broadcasting (case A only).  No-op if either side
      is scalar, ndim differs, or shapes are already equal.  If shapes
      are incompatible (neither side is 1 nor equal on some axis), also
@@ -1806,11 +1849,6 @@ rb_ca_cast_other (VALUE *self, volatile VALUE *other)
 
   TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
 
-  if ( cb->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *other = ca_ubrep_bind_with(*other, *self);
-    TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
-  }
-
   test1 = ca_cast_table[cb->data_type][ca->data_type];
 
   if ( test1 == 0 ) {
@@ -1845,8 +1883,8 @@ rb_ca_cast_with (VALUE self, VALUE other)
 }
 
 /* -----------------------------------------------------------------------
-   clip_<dtype> family — clip into the target dtype's representable
-   range, then cast.  Sugar for `clip(lo, hi).as_<dtype>`.
+   clip_<type> family — clip into the target data type's representable
+   range, then cast.  Sugar for `clip(lo, hi).as_<type>`.
 ----------------------------------------------------------------------- */
 
 #define CLIP_CAST_FUNC(name, lo_expr, hi_expr, cast_func) \
@@ -1873,7 +1911,7 @@ CLIP_CAST_FUNC(clip_uint32, INT2NUM(0),                       UINT2NUM(429496729
    an overflowing float source (e.g. 1e20) to 2^64 and the subsequent cast to
    uint64 wraps around to 0.  For floating-point sources we take a saturating
    path: compare in float space against 2^64 (which IS representable) and
-   saturate to UINT64_MAX above it and 0 below zero.  Other source dtypes use
+   saturate to UINT64_MAX above it and 0 below zero.  Other source data types use
    the plain clip-then-cast path. */
 static VALUE
 rb_ca_clip_uint64 (VALUE self)

data/ext/carray_conversion.c

@@ -7,7 +7,7 @@
   Siblings:
     carray_copy.c        — CArray-to-CArray copy / template family
     carray_element.c     — element-level fetch/store (rb_ca_ptr2obj / obj2ptr)
-    carray_cast_func.c   — dtype cast table used by rb_ca_ptr2obj
+    carray_cast_func.c   — data type cast table used by rb_ca_ptr2obj
 
 ---------------------------------------------------------------------------- */
 
@@ -16,15 +16,15 @@
 #include "ruby/io.h"
 
 /* to_a dispatch:
-     numeric / boolean dtype + entity or attach-able view -> fast path
-       (dtype-direct leaf loop over the attached contig buffer)
+     numeric / boolean data type + entity or attach-able view -> fast path
+       (data type-direct leaf loop over the attached contig buffer)
      CA_OBJECT / CA_FIXLEN                                -> universal
        (rb_ca_fetch_index per cell; ptr is VALUE or byte string, not
         directly castable through the leaf switch)
 
    Masked cells materialise as CA_UNDEF on both paths. */
 
-/* Leaf macro: dtype-specialized inner loop.  Produces `n` VALUE objects
+/* Leaf macro: data type-specialized inner loop.  Produces `n` VALUE objects
    from a contig ptr base + element width, storing into `dst` (Ruby Array). */
 #define TO_A_LEAF_LOOP(T, TO_VALUE) do { \
   const T *src = (const T *) base; \
@@ -42,7 +42,7 @@
 
 #define TO_A_DISPATCH_LEAF(LOOP) do { \
   ca_size_t li; \
-  switch ( dtype ) { \
+  switch ( data_type ) { \
   case CA_FLOAT64: LOOP(double,   rb_float_new); break; \
   case CA_FLOAT32: LOOP(float,    rb_float_new); break; \
   case CA_INT64:   LOOP(int64_t,  LL2NUM);       break; \
@@ -67,13 +67,13 @@
     } \
     break; \
   default: \
-    rb_bug("to_a fast path: unexpected dtype %d", dtype); \
+    rb_bug("to_a fast path: unexpected data type %d", data_type); \
   } \
 } while (0)
 
 #define TO_A_DISPATCH_LEAF_MASKED(LOOP) do { \
   ca_size_t li; \
-  switch ( dtype ) { \
+  switch ( data_type ) { \
   case CA_FLOAT64: LOOP(double,   rb_float_new); break; \
   case CA_FLOAT32: LOOP(float,    rb_float_new); break; \
   case CA_INT64:   LOOP(int64_t,  LL2NUM);       break; \
@@ -95,7 +95,7 @@
     } \
     break; \
   default: \
-    rb_bug("to_a fast path masked: unexpected dtype %d", dtype); \
+    rb_bug("to_a fast path masked: unexpected data type %d", data_type); \
   } \
 } while (0)
 
@@ -105,7 +105,7 @@
 static void
 to_a_fast_recurse (CArray *ca, int32_t level, const char *base,
                    const boolean8_t *mask_base, VALUE dst,
-                   int dtype, ca_size_t bytes, int has_mask)
+                   int data_type, ca_size_t bytes, int has_mask)
 {
   ca_size_t i, n, slab_elements, slab_bytes;
 
@@ -135,7 +135,7 @@ to_a_fast_recurse (CArray *ca, int32_t level, const char *base,
     to_a_fast_recurse(ca, level + 1,
                       base + i * slab_bytes,
                       has_mask ? mask_base + i * slab_elements : NULL,
-                      child, dtype, bytes, has_mask);
+                      child, data_type, bytes, has_mask);
   }
 }
 
@@ -172,8 +172,8 @@ rb_ca_to_a_loop_universal (VALUE self, int32_t level, ca_size_t *idx, VALUE ary)
  * ndim-1 nesting: shape [2, 3] -> 2-element Array of 3-element Arrays.
  * Masked cells become CA_UNDEF; the mask itself is not preserved on the
  * result.  ca_attach(self) supplies a contig row-major buffer for the
- * fast path, so all view kinds land in the dtype-direct leaf loop when
- * the dtype is numeric or boolean; CA_OBJECT / CA_FIXLEN fall through
+ * fast path, so all view kinds land in the data type-direct leaf loop when
+ * the data type is numeric or boolean; CA_OBJECT / CA_FIXLEN fall through
  * to the universal fetch_index walk. */
 VALUE
 rb_ca_to_a (VALUE self)
@@ -181,7 +181,7 @@ rb_ca_to_a (VALUE self)
   volatile VALUE ary;
   CArray *ca;
   ca_size_t idx[CA_RANK_MAX];
-  int dtype, fast_eligible;
+  int data_type, fast_eligible;
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
   ary = rb_ca_is_empty(self) ? rb_ary_new() : rb_ary_new2(ca->dim[0]);
@@ -199,22 +199,22 @@ rb_ca_to_a (VALUE self)
      numeric-storage Face -- CATimedelta serials instead of CATimedelta
      Elements -- while ca[i] / each / to_type(:object) all decode.  The
      universal loop goes through rb_ca_fetch_addr, which decodes. */
-  dtype = ca->data_type;
+  data_type = ca->data_type;
   fast_eligible = (ca->elements > 0)
                   && ( ! ca_is_face(ca) )
-                  && (dtype == CA_FLOAT64 || dtype == CA_FLOAT32
-                      || dtype == CA_INT64   || dtype == CA_INT32
-                      || dtype == CA_INT16   || dtype == CA_INT8
-                      || dtype == CA_UINT64  || dtype == CA_UINT32
-                      || dtype == CA_UINT16  || dtype == CA_UINT8
-                      || dtype == CA_BOOLEAN);
+                  && (data_type == CA_FLOAT64 || data_type == CA_FLOAT32
+                      || data_type == CA_INT64   || data_type == CA_INT32
+                      || data_type == CA_INT16   || data_type == CA_INT8
+                      || data_type == CA_UINT64  || data_type == CA_UINT32
+                      || data_type == CA_UINT16  || data_type == CA_UINT8
+                      || data_type == CA_BOOLEAN);
 
   if ( fast_eligible ) {
     int has_mask = (ca->mask != NULL);
     const boolean8_t *mask_base = has_mask
         ? (const boolean8_t *) ca->mask->ptr : NULL;
     to_a_fast_recurse(ca, 0, ca->ptr, mask_base, ary,
-                      dtype, ca->bytes, has_mask);
+                      data_type, ca->bytes, has_mask);
   }
   else if ( ca->elements > 0 ) {
     rb_ca_to_a_loop_universal(self, 0, idx, ary);
@@ -229,7 +229,7 @@ rb_ca_to_a (VALUE self)
 #undef TO_A_DISPATCH_LEAF_MASKED
 
 /* CArray#convert(data_type=nil, bytes: nil) { |elem| ... } — map every cell
- * through the block, into a new array whose dtype is chosen by argv via
+ * through the block, into a new array whose data type is chosen by argv via
  * CArray#template (shape is inherited from self).
  *
  * Masked cells skip the block; if the block returns CA_UNDEF, the

data/ext/carray_copy.c

@@ -10,6 +10,7 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"   /* CA_FACE_LIFT_IF_FACE */
+#include "carray_internal.h"   /* ca_gc_hold_push / ca_gc_hold_pop_to */
 #include <stdarg.h>
 
 /* ------------------------------------------------------------------- */
@@ -57,9 +58,18 @@ VALUE
 rb_ca_copy (VALUE self)
 {
   volatile VALUE obj;
-  CArray *ca;
+  CArray *ca, *co;
+  int guard = -1;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  obj = ca_wrap_struct(ca_copy(ca));
+  co = ca_copy(ca);
+  /* The copy holds VALUEs that so far exist only in co->ptr, and
+     ca_wrap_struct allocates.  Keep them reachable until the wrapper
+     that owns them exists. */
+  if ( ca_is_object_type(co) ) {
+    guard = ca_gc_hold_push(co->ptr, co->elements);
+  }
+  obj = ca_wrap_struct(co);
+  ca_gc_hold_pop_to(guard);
   CA_FACE_LIFT_IF_FACE(obj, self, ca);
   return obj;
 }

data/ext/carray_core.c

@@ -231,7 +231,6 @@ ca_cast_table2[CA_NTYPE][CA_NTYPE] = {
     * CASelect
     * CAObject
     * CARepeat
-    * CAUnboundRepeat
 */
 
 void
@@ -243,7 +242,6 @@ ca_init_obj_type (void)
   extern ca_operation_function_t ca_select_func;
   extern ca_operation_function_t ca_object_func;
   extern ca_operation_function_t ca_stride_func;
-  extern ca_operation_function_t ca_ubrep_func;
 
   /* CArray */
   ca_func[CA_OBJ_ARRAY]       = ca_array_func;
@@ -309,12 +307,6 @@ ca_init_obj_type (void)
   ca_mask_class[CA_OBJ_REPEAT] = rb_cCARepeatMask;
   ca_mask_typeddata[CA_OBJ_REPEAT] = &castride_mask_data_type;
 
-  /* CAUnboundRepeat */
-  ca_func[CA_OBJ_UNBOUND_REPEAT]  = ca_ubrep_func;
-  ca_class[CA_OBJ_UNBOUND_REPEAT] = rb_cCAUnboundRepeat;
-  ca_typeddata[CA_OBJ_UNBOUND_REPEAT] = &caunboundrepeat_data_type;
-  ca_mask_class[CA_OBJ_UNBOUND_REPEAT] = rb_cCAUnboundRepeatMask;
-  ca_mask_typeddata[CA_OBJ_UNBOUND_REPEAT] = &caunboundrepeat_mask_data_type;
 
   ca_obj_num = 9;
 }
@@ -432,11 +424,22 @@ ca_attach_is_alias (void *ap)
 {
   CArray *ca = (CArray *) ap;
   extern ca_operation_function_t ca_stride_func;
+  extern ca_operation_function_t ca_lazy_marker_func;
   extern int ca_stride_is_contiguous (CAStride *ca);
   extern int ca_stride_attach_aliases_root (CAStride *ca);
 
   if ( ca == NULL ) return 0;
   if ( ca_is_entity(ca) )  return 1;
+
+  /* CALazyMarker's attach is literally `ca->ptr = ca->parent->ptr` after
+     attaching the parent — it adds no layout of its own — so it aliases
+     exactly when its parent does.  Without this a marker looks expensive
+     to every caller and views built on it fall onto materialising paths,
+     even though there is nothing between the marker and real memory. */
+  if ( ca_func[ca->obj_type].attach == ca_lazy_marker_func.attach ) {
+    return ca_attach_is_alias(((CAView *) ca)->parent);
+  }
+
   /* CAStride family share ca_stride_func.attach (= ca_stride_func_attach).
      The alias-attach fast path is taken iff composed strides are
      row-major contiguous.  ca_stride_is_contiguous checks the leaf
@@ -1399,6 +1402,30 @@ ca_xfer_strided_walk (char            *src_base,
   }
 }
 
+/* See the comment on the prototype in carray.h. */
+int
+ca_xfer_stride_request_is_axis_box (void *ap, ca_size_t *starts,
+                                    ca_size_t *counts, ca_size_t *strides)
+{
+  CArray   *ca = (CArray *) ap;
+  ca_size_t native[CA_RANK_MAX];
+  ca_size_t s = ca->bytes;
+  int8_t    ndim = ca->ndim, k;
+
+  for ( k = ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
+
+  for ( k = 0; k < ndim; k++ ) {
+    ca_size_t q;
+    if ( counts[k] <= 1 ) continue;          /* moves nothing */
+    if ( strides[k] <= 0 ) return 0;         /* zero / negative: not an axis walk */
+    if ( strides[k] % native[k] != 0 ) return 0;
+    q = strides[k] / native[k];
+    if ( q < 1 ) return 0;
+    if ( starts[k] + (counts[k] - 1) * q >= ca->dim[k] ) return 0;   /* runs off axis k */
+  }
+  return 1;
+}
+
 static void
 ca_xfer_stride_dispatch (CArray *ca, ca_size_t *starts, ca_size_t *counts,
                          ca_size_t *strides, void *data, int dir)
@@ -1532,10 +1559,12 @@ ca_xfer_all_body (VALUE arg)
   return Qnil;
 }
 
+/* `arg` carries the hold depth to unwind to, so nested ca_xfer_all calls
+   each drop their own hold rather than the whole stack. */
 static VALUE
 ca_xfer_all_ensure (VALUE arg)
 {
-  (void) arg;
+  ca_gc_hold_pop_to(NUM2INT(arg));
   ca_lazy_arena_exit();
   return Qnil;
 }
@@ -1545,6 +1574,7 @@ ca_xfer_all (void *ap, void *data, int dir)
 {
   CArray *ca = (CArray *) ap;
   ca_xfer_all_args_t args;
+  int guard = -1;
   if ( ! ca_func[ca->obj_type].xfer_all ) {
     rb_raise(rb_eRuntimeError,
              "[BUG] xfer_all not defined for object type <%i>",
@@ -1562,8 +1592,25 @@ ca_xfer_all (void *ap, void *data, int dir)
      next entry. */
   ca_lazy_arena_enter();
   args.ca = ca; args.data = data; args.dir = dir;
+
+  /* A CA_OBJECT cell is a VALUE, and this buffer belongs to no Ruby
+     object yet -- it is the destination `copy` will hand out, or a
+     view's own freshly allocated one.  The object lane calls rb_funcall
+     per cell, so a collection partway through would free what has been
+     written so far.  ca_xfer_all is the whole-view entry, so the window
+     is exactly ca->elements contiguous cells: the one place where the
+     extent is known without trusting a caller's strides.  Sub-windows
+     written by nested transfers land inside it. */
+  if ( ca->data_type == CA_OBJECT && dir == CA_XFER_GET ) {
+    if ( data != (void *) ca->ptr ) {
+      VALUE *p = (VALUE *) data;
+      ca_size_t i;
+      for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+    }
+    guard = ca_gc_hold_push(data, ca->elements);
+  }
   rb_ensure(ca_xfer_all_body, (VALUE) &args,
-            ca_xfer_all_ensure, Qnil);
+            ca_xfer_all_ensure, INT2NUM(guard));
 }
 
 /* ------------------------------------------------------------------- */

data/ext/carray_count.c

@@ -2,7 +2,7 @@
 
   CArray#count dispatcher (= value-comparison family entry point).
   Hand-routed because the dispatch decision depends on (self.data_type,
-  v's runtime class), which the per-dtype mkkernel kernels can't see;
+  v's runtime class), which the per-type mkkernel kernels can't see;
   the actual counting is delegated to the kernel-iterator helpers
   listed below.