carray 3.0.0 → 3.0.2

data/ext/ca_obj_fake.c

@@ -462,6 +462,17 @@ rb_ca_fake_new (VALUE cary, int8_t data_type, ca_size_t bytes)
   CAFake *ca;
   rb_check_carray_object(cary);
   TypedData_Get_Struct(cary, CArray, &carray_data_type, parent);
+  if ( ca_is_face(parent) && ( data_type == CA_OBJECT
+                               || parent->data_type == CA_FIXLEN ) ) {
+    /* A Face's cells do not mean their storage bytes, so reading them
+       under another data_type hands back what the surface exists to hide.
+       Both ways down stay open and say which one they are.  A Numeric Face
+       is not one of these: its surface is its storage. */
+    rb_raise(rb_eTypeError,
+             "%s has no view of its values in another data_type: "
+             "#to_type gives the values, #parent.fake the raw storage",
+             rb_obj_classname(cary));
+  }
   ca  = ca_fake_new(parent, data_type, bytes);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);

data/ext/ca_obj_fixlen_string.c

@@ -91,11 +91,24 @@ ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent)
 
   ca->obj_type  = CA_OBJ_FIXLEN_STRING;
   ca->data_type = CA_FIXLEN;
-  /* ORDERABLE + COMPARABLE, and both hold by construction: this Face's surface
-     IS its storage, byte for byte (a cell decodes to its own bytes, padding
-     included), so the descent is the identity map.  memcmp order is therefore
-     String#<=> order for these cells, and byte equality is cell equality --
-     which is what the equality families need (docs/topics/CAFace.md §6.3).
+  /* ORDERABLE + COMPARABLE.  The descent is NOT the identity map -- the
+     scalar decode below strips trailing NUL -- but both flags still hold,
+     for a reason worth stating exactly, since it is what a Face author
+     copying this would need:
+
+       ORDERABLE: every cell is padded to the same K with NUL, and NUL is
+       the smallest byte, so memcmp on the padded cells orders them the same
+       way String#<=> orders the stripped strings (a prefix sorts before any
+       continuation, which is what the padding reproduces).  Stripping is
+       order-preserving; it is not order-irrelevant by being absent.
+
+       COMPARABLE: a String query is padded out to the cell width before it
+       is compared, so byte equality on the padded form is equality on the
+       stripped form -- for a query that fits.  A query longer than K is
+       truncated to its own first K bytes by that same padding step, and
+       then matches a cell it is not equal to.
+
+     Which is what the equality families need (docs/topics/CAFace.md §6.3).
      Without the flags the sort family still worked (it exempts CA_FIXLEN
      storage from the gate and orders by memcmp), but the value-hash family
      handed its results back as a plain fixlen array, and search refused a
@@ -202,7 +215,9 @@ ca_operation_function_t ca_fixlen_string_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_grid.c

@@ -478,9 +478,17 @@ ca_grid_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
      transposed leaf breaks this (cross-axis / non-multiple strides); fall back
      to per-cell delivery (correct, still no whole-view attach).  The wiring
      guards ndim == grid->ndim, so counts/strides have ndim entries here. */
-  for (k = 0; k < ndim; k++) {
-    if (strides[k] % gnative[k] != 0) { aligned = 0; break; }
-    src_step[k] = strides[k] / gnative[k];
+  /* The request is over the view's addresses, so a transposed / flat request
+     is legal and must not be composed axis-by-axis; see
+     ca_xfer_stride_request_is_axis_box (carray.h). */
+  if ( ! ca_xfer_stride_request_is_axis_box(g, starts, counts, strides) ) {
+    aligned = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if (strides[k] % gnative[k] != 0) { aligned = 0; break; }
+      src_step[k] = strides[k] / gnative[k];
+    }
   }
 
   if (!aligned) {

data/ext/ca_obj_meld.c

@@ -39,6 +39,8 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_attach_all */
+#include "ca_obj_face.h"       /* ca_face_state_portable */
 
 /* ------------------------------------------------------------------- */
 /* TypedData                                                            */
@@ -89,7 +91,7 @@ static ID id_parents;
 /* uniform check                                                        */
 /* ------------------------------------------------------------------- */
 
-/* Parents must share dtype, ndim, bytes, and all dims except meld_axis;
+/* Parents must share data type, ndim, bytes, and all dims except meld_axis;
    meld_axis lengths are the ragged dimension (may differ). */
 static void
 ca_meld_check_uniform (int32_t n_parents, CArray **parents, int8_t meld_axis)
@@ -150,6 +152,19 @@ ca_meld_setup (CAMeld *ca, int32_t n_parents, CArray **parents, int8_t meld_axis
   int32_t i;
   int8_t  a;
 
+  /* Pre-strip Face parents one level to storage, as CAStack does, so a
+     melded Face lifts to a single-Face chain (CATime[CAMeld[entity, ...]])
+     rather than a Face sitting on Face parents.  One level, not a full walk,
+     preserves any distinct Face a parent melded underneath.  A Face is
+     storage-transparent, so welding over storage reads the same bytes; the
+     lifted top Face (rb_ca_meld_s_new) carries the identity.  The @parents
+     accessor keeps the originals, which the callers set. */
+  for ( i = 0; i < n_parents; i++ ) {
+    if ( ca_is_face(parents[i]) ) {
+      parents[i] = CAVIEW(parents[i])->parent;
+    }
+  }
+
   ca_meld_check_uniform(n_parents, parents, meld_axis);
   ref = parents[0];
 
@@ -598,19 +613,9 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t   i;
   int      structural = 1;
 
-  /* Bound check on meld_axis */
-  {
-    ca_size_t req_lo = starts[ma];
-    ca_size_t req_hi = starts[ma] + counts[ma];
-    if ( req_lo < 0 || req_hi > ca->dim[ma] ) {
-      rb_raise(rb_eIndexError,
-               "CAMeld xfer_stride meld_axis (axis %d) [%lld, %lld) out of range [0, %lld)",
-               (int) ma, (long long) req_lo, (long long) req_hi, (long long) ca->dim[ma]);
-    }
-  }
-
   s = ca->bytes;
   for ( i = ca->ndim - 1; i >= 0; i-- ) { native[i] = s; s *= ca->dim[i]; }
+
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( strides[i] != native[i] ) { structural = 0; break; }
   }
@@ -619,6 +624,23 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_meld_xfer_stride_per_cell(ca, starts, counts, strides, data, dir);
     return;
   }
+
+  /* Bound check on meld_axis, after the gate and not before it.  Only once
+     strides == native is established does request axis ma mean view axis ma;
+     asked earlier, strides[ma] / native[ma] is not a step along the meld axis
+     and legal requests get rejected.  Inside the gate the step is 1, so the
+     region is starts[ma] .. starts[ma] + counts[ma].  ca_meld_xfer_stride_ma_
+     internal below is handed no strides at all and depends on both facts. */
+  {
+    ca_size_t req_lo = starts[ma];
+    ca_size_t req_hi = starts[ma] + counts[ma];
+    if ( counts[ma] > 0 && ( req_lo < 0 || req_hi > ca->dim[ma] ) ) {
+      rb_raise(rb_eIndexError,
+               "CAMeld xfer_stride meld_axis (axis %d) [%lld, %lld) out of range [0, %lld)",
+               (int) ma, (long long) req_lo, (long long) req_hi, (long long) ca->dim[ma]);
+    }
+  }
+
   if ( ma == 0 ) {
     ca_meld_xfer_stride_ma0(ca, starts, counts, strides, data, dir);
   } else {
@@ -765,10 +787,7 @@ static void
 ca_meld_func_allocate (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
 }
 
@@ -776,10 +795,7 @@ static void
 ca_meld_func_attach (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
   ca_meld_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
 }
@@ -882,6 +898,17 @@ ca_operation_function_t ca_meld_func = {
 /* Ruby surface                                                         */
 /* ------------------------------------------------------------------- */
 
+/* One-level strip of a Face VALUE to its storage-side parent (non-Face as-is).
+   Keeps the @parent ivar in step with the pre-stripped C parents, so the
+   Ruby-visible chain of a melded Face is single-Face too. */
+static VALUE
+ca_meld_face_parent1 (VALUE v)
+{
+  CArray *c;
+  TypedData_Get_Struct(v, CArray, &carray_data_type, c);
+  return ca_is_face(c) ? rb_ca_parent(v) : v;
+}
+
 VALUE
 rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
 {
@@ -905,7 +932,7 @@ rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
   ca  = ca_meld_new((int32_t) n, parents, meld_axis);
   obj = ca_wrap_struct(ca);
   rb_ivar_set(obj, id_parents, rb_ary_dup(parents_ary));
-  rb_ca_set_parent(obj, rb_ary_entry(parents_ary, 0));
+  rb_ca_set_parent(obj, ca_meld_face_parent1(rb_ary_entry(parents_ary, 0)));
   ALLOCV_END(holder);
   return obj;
 }
@@ -962,11 +989,86 @@ rb_ca_meld_initialize (int argc, VALUE *argv, VALUE self)
   }
   ca_meld_setup(ca, (int32_t) n, parents, meld_axis);
   rb_ivar_set(self, id_parents, rb_ary_dup(list));
-  rb_ca_set_parent(self, rb_ary_entry(list, 0));
+  rb_ca_set_parent(self, ca_meld_face_parent1(rb_ary_entry(list, 0)));
   ALLOCV_END(holder);
   return self;
 }
 
+/* CAMeld.new(list, axis: 0) -- Class#new override, the twin of
+   rb_ca_stack_s_new.  A melded view has one surface over many parents, so a
+   homogeneous Face list is treated the way CAStack treats it: refuse a Face
+   whose state is per-parent (the cells of parent i are only readable against
+   parent i's own state -- a CAConstString's cells are byte ranges into ITS
+   buffer), and lift the rest so the Face survives the weld.
+
+   Without this meld was the one multi-parent constructor that neither asked
+   nor lifted: it returned the raw storage of whatever it was given, which for
+   CAConstString meant 16-byte (start,end) pairs presented as the string cells,
+   and for CATime meant raw int64 ticks.  Both looked like data.
+
+   Doing it here rather than in CArray.meld covers CAFrame.meld and a direct
+   CAMeld.new by the same check. */
+static VALUE
+rb_ca_meld_s_new (int argc, VALUE *argv, VALUE klass)
+{
+  VALUE list, kwargs;
+  long n, i;
+  int  all_face = 1;
+  VALUE face_class = Qnil;
+  CArray *ref_face = NULL;
+  VALUE obj;
+
+  rb_scan_args(argc, argv, "1:", &list, &kwargs);
+  Check_Type(list, T_ARRAY);
+  n = RARRAY_LEN(list);
+  if ( n <= 0 ) {
+    rb_raise(rb_eArgError, "CAMeld.new requires at least one parent");
+  }
+
+  for ( i = 0; i < n; i++ ) {
+    VALUE p = rb_ary_entry(list, i);
+    CArray *ca;
+    rb_check_carray_object(p);
+    TypedData_Get_Struct(p, CArray, &carray_data_type, ca);
+    if ( !ca_is_face(ca) ) { all_face = 0; break; }
+    if ( i == 0 ) {
+      face_class = rb_obj_class(p);
+      ref_face   = ca;
+    } else if ( rb_obj_class(p) != face_class ) {
+      all_face = 0; break;
+    }
+  }
+
+  /* A single parent has nothing to weld against, so its Face rides the
+     chain as it always did; refuse and lift only apply from two up. */
+  if ( all_face && n > 1
+       && !ca_face_state_portable(ref_face->obj_type, face_class) ) {
+    rb_raise(rb_eArgError,
+             "CAMeld.new: %s state is not portable across multiple "
+             "parents (= per-parent storage like CAConstString's buffer); "
+             "strip Face with .parent if a storage-level CAMeld is intended",
+             rb_class2name(face_class));
+  }
+
+  obj = rb_obj_alloc(klass);
+  rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS);
+
+  if ( !all_face || n < 2 ) return obj;
+
+  for ( i = 1; i < n; i++ ) {
+    VALUE p = rb_ary_entry(list, i);
+    CArray *ca;
+    TypedData_Get_Struct(p, CArray, &carray_data_type, ca);
+    if ( !ca_face_state_compatible(rb_ary_entry(list, 0), ref_face, p, ca) ) {
+      rb_raise(rb_eArgError,
+               "CAMeld.new: Face state mismatch across parents "
+               "(= %s instance at index %ld differs in state from index 0)",
+               rb_class2name(face_class), i);
+    }
+  }
+  return ca_face_lift(obj, rb_ary_entry(list, 0));
+}
+
 static VALUE
 rb_ca_meld_n_parents (VALUE self)
 {
@@ -1022,6 +1124,7 @@ Init_ca_obj_meld (void)
   id_parents = rb_intern("parents");
 
   rb_define_alloc_func(rb_cCAMeld, rb_ca_meld_s_allocate);
+  rb_define_singleton_method(rb_cCAMeld, "new", rb_ca_meld_s_new, -1);
   rb_define_method(rb_cCAMeld, "initialize",
                                       rb_ca_meld_initialize, -1);
   rb_define_method(rb_cCAMeld, "initialize_copy",

data/ext/ca_obj_moncmp.c

@@ -2,7 +2,7 @@
 
   CAMonCmp — lazy monadic element-wise comparison view: is_nan /
   is_inf / is_finite / is_invalid / signbit.  Output data_type =
-  CA_BOOLEAN (1 byte); operand keeps its native data_type (per-dtype
+  CA_BOOLEAN (1 byte); operand keeps its native data_type (per-type
   kernels cover integer as well, so is_nan / is_inf on integer parents
   return const-false and is_finite const-true without a cast layer).
 
@@ -20,7 +20,7 @@
   Peak scratch: 1 operand-data_type slab.
 
   Mask propagation:
-    Per-dtype moncmp kernels write only at non-masked positions, so
+    Per-type moncmp kernels write only at non-masked positions, so
     the standard create_mask = parent.mask machinery carries mask bits
     to the caller-visible result.  No in-flight mask handling in
     xfer_stride.
@@ -121,9 +121,8 @@ ca_moncmp_setup (CAMonCmp *ca, CArray *parent, uint16_t op_id)
 
   memcpy(ca->dim, parent->dim, parent->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here: ca_has_mask creates a view's mask on
+     demand from its parent's. */
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
@@ -252,6 +251,8 @@ ca_moncmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   int8_t    k;
   void     *scratch;
   ca_size_t operand_bytes;
+  ca_size_t operand_strides[CA_RANK_MAX];
+  int       is_contig;
 
   if ( dir != CA_XFER_GET ) {
     rb_raise(rb_eRuntimeError, "CAMonCmp is read-only (xfer_stride PUT)");
@@ -263,26 +264,44 @@ ca_moncmp_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
 
   operand_bytes = mc->parent->bytes;
 
+  /* The operand's cell is operand_bytes wide where this view's is one byte
+     (CA_BOOLEAN), so the caller's strides have to be restated at the
+     operand's cell size before the pull; strides[k] / bytes is the index
+     step, which is what the two spaces share.
+
+     is_contig says the caller asked for the row-major slab that xfer_all
+     and attach send.  Only then does the parent's own buffer hold the
+     wanted cells in the packed order the kernel reads them in, so it is
+     also the only case the leaf in-place path is good for. */
+  {
+    ca_size_t native = mc->bytes;
+    is_contig = 1;
+    for ( k = mc->ndim - 1; k >= 0; k-- ) {
+      operand_strides[k] = strides[k] / mc->bytes * operand_bytes;
+      if ( strides[k] != native ) {
+        is_contig = 0;
+      }
+      native *= mc->dim[k];
+    }
+  }
+
   /* === 1. pull parent (leaf-opt or scratch) === */
   int scratch_is_inplace = 0;
   {
     char *inplace = NULL;
-    if ( ca_moncmp_try_leaf_inplace(mc->parent, starts, counts,
+    if ( is_contig &&
+         ca_moncmp_try_leaf_inplace(mc->parent, starts, counts,
                                      operand_bytes, &inplace) ) {
       scratch = inplace;
       scratch_is_inplace = 1;
       ca_moncmp_leaf_inplace_count++;
     }
     else {
-      ca_size_t scratch_strides[CA_RANK_MAX];
-      ca_size_t s = operand_bytes;
-      for ( k = mc->ndim - 1; k >= 0; k-- ) {
-        scratch_strides[k] = s;
-        s *= counts[k];
-      }
-      scratch = ca_lazy_arena_acquire(slab_n * operand_bytes);
+      scratch = ( mc->parent->data_type == CA_OBJECT )
+                  ? ca_lazy_arena_acquire_object(slab_n)
+                  : ca_lazy_arena_acquire(slab_n * operand_bytes);
       ca_moncmp_scratch_acquire_count++;
-      ca_xfer_stride(mc->parent, starts, counts, scratch_strides, scratch,
+      ca_xfer_stride(mc->parent, starts, counts, operand_strides, scratch,
                      CA_XFER_GET);
     }
   }

data/ext/ca_obj_monop.c

@@ -207,9 +207,9 @@ ca_monop_setup (CAMonOp *ca, CArray *parent, uint16_t op_id)
 
   memcpy(ca->dim, parent->dim, parent->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here: ca_has_mask creates a view's mask on
+     demand from its parent's, so an expression whose mask nobody reads
+     never allocates one. */
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -380,8 +380,8 @@ ca_size_t ca_monop_materialise_call_count = 0;
    but they are unobservable: the output mask is built separately via
    the attach lifecycle (ca_monop_func_create_mask + parent.mask
    CARefer), so reads of masked cells return UNDEF regardless of byte
-   contents.  This is the design license stated in CLAUDE.md
-   §"design premises" ("mask is not a protection mechanism").
+   contents.  The mask marks cells as undefined; it does not guard their
+   bytes, so writing garbage into a masked cell is licensed.
 
    A "partial mask slow path" (= a cell-wise branch to skip masked-cell
    compute) is a possible future micro-optimisation; it is not done
@@ -461,7 +461,9 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
     }
   }
   (void) holder;
-  scratch = ca_lazy_arena_acquire(total_bytes);
+  scratch = ( leaf->data_type == CA_OBJECT )
+              ? ca_lazy_arena_acquire_object(slab_n)
+              : ca_lazy_arena_acquire(total_bytes);
   ca_monop_scratch_acquire_count++;
   ca_xfer_stride(leaf, starts, counts, parent_strides, scratch, CA_XFER_GET);
 
@@ -615,7 +617,9 @@ ca_monop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
          → data (in target data_type).  Required because in-place cast
          would overlap source/dest reads when target_bytes > src_bytes
          (forward-walk reads cells past their own write boundary). */
-      scratch = ca_lazy_arena_acquire(total_bytes);
+      scratch = ( cur_dt == CA_OBJECT )
+                  ? ca_lazy_arena_acquire_object(slab_n)
+                  : ca_lazy_arena_acquire(total_bytes);
       ca_monop_scratch_acquire_count++;
       memcpy(scratch, data, total_bytes);
       ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
@@ -728,6 +732,14 @@ ca_monop_func_attach (void *ap)
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
   for ( k = 0; k < ca->ndim; k++ ) starts[k] = 0;
+  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
+     soon as the view is, so it must not be handed to the GC as raw
+     xmalloc garbage. */
+  if ( ca->data_type == CA_OBJECT ) {
+    VALUE *p = (VALUE *) ca->ptr;
+    ca_size_t i;
+    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+  }
   ca_monop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 

data/ext/ca_obj_object.c

@@ -352,8 +352,11 @@ ca_objmask_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   if ( n == 0 ) return;
 
   if ( rb_obj_respond_to(ca->array, mid_block, Qtrue) ) {
-    int aligned = 1;
-    for ( k = 0; k < ndim; k++ ) {
+    /* The request is over the view's addresses, so a transposed / flat
+       request is legal; the per-axis copy_block dispatch below would
+       misread it.  See ca_xfer_stride_request_is_axis_box (carray.h). */
+    int aligned = ca_xfer_stride_request_is_axis_box(ca, starts, counts, strides);
+    for ( k = 0; aligned && k < ndim; k++ ) {
       if ( strides[k] <= 0 || strides[k] % native[k] != 0 ) { aligned = 0; break; }
       steps[k] = strides[k] / native[k];
     }
@@ -735,6 +738,14 @@ ca_object_dispatch_fill (CAObject *ca, void *ptr)
     volatile VALUE rval = rb_ca_ptr2obj(ca->self, ptr);
     rb_funcall(ca->self, rb_intern("fill_data"), 1, rval);
   }
+  else if ( rb_obj_respond_to(ca->self, rb_intern("fill_block"), Qtrue)
+            || rb_obj_respond_to(ca->self, rb_intern("fill_addrs"), Qtrue) ) {
+    /* An author who wrote the region slots but not fill_data would otherwise
+       get the per-cell default for the one request that is easiest to batch.
+       Hand the whole extent to the region path, which reaches `fill_block` in
+       one call or `fill_addrs` in address windows. */
+    ca_fill_stride_whole(ca, ptr);
+  }
   else {
     ca_size_t addr;
     for ( addr = 0; addr < ca->elements; addr++ ) {
@@ -937,8 +948,11 @@ ca_object_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
        before the % check
      - given %==0 + >0, strides/native >= 1 holds automatically */
   if ( rb_obj_respond_to(ca->self, mid_block, Qtrue) ) {
-    int aligned = 1;
-    for ( k = 0; k < ndim; k++ ) {
+    /* The request is over the view's addresses, so a transposed / flat
+       request is legal; the per-axis copy_block dispatch below would
+       misread it.  See ca_xfer_stride_request_is_axis_box (carray.h). */
+    int aligned = ca_xfer_stride_request_is_axis_box(ca, starts, counts, strides);
+    for ( k = 0; aligned && k < ndim; k++ ) {
       if ( strides[k] <= 0 || strides[k] % native[k] != 0 ) { aligned = 0; break; }
       steps[k] = strides[k] / native[k];   /* >= 1 by construction */
     }
@@ -1001,6 +1015,93 @@ ca_object_func_fill_data (void *ap, void *ptr)
   ca_object_dispatch_fill((CAObject *) ap, ptr);
 }
 
+/* Partial fill.  fill_data carries no region and can only say "fill
+   everything I cover", so before these two slots existed the only way to
+   fill part of a CAObject was the per-cell default -- one store_addr per
+   cell.  The region arrives in the view's own address space.  With
+   `fill_block` defined (and the region an axis-aligned forward sub-box of
+   self) it becomes one call; with `fill_addrs` defined it becomes one call
+   per address window.  With neither defined the behaviour is exactly the
+   old default, so an existing subclass sees no change. */
+static void
+ca_object_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
+{
+  CAObject *ca = (CAObject *) ap;
+  ID        mid = rb_intern("fill_addrs");
+
+  if ( ca_is_face(ca) ) {
+    ca_face_fill_addrs(ap, n, addrs, ptr);
+    return;
+  }
+
+  if ( n > 0 && rb_obj_respond_to(ca->self, mid, Qtrue) ) {
+    volatile VALUE raddrs, rval;
+    ca_size_t dim1[1] = { n };
+    raddrs = ca_object_wrap_transient(CA_SIZE, sizeof(ca_size_t),
+                                      1, dim1, addrs, CA_XFER_PUT);
+    rval = rb_ca_ptr2obj(ca->self, ptr);
+    rb_funcall(ca->self, mid, 2, raddrs, rval);
+    return;
+  }
+
+  ca_fill_addrs_default(ap, n, addrs, ptr);
+}
+
+/* Gate: one region axis per view axis, forward, and a whole number of
+   elements per step.  native is strictly decreasing, so steps[k] =
+   m_k * native[k] with m_k >= 1 admits only the identity permutation --
+   transpose, negative and zero (broadcast) steps, sub-element steps and
+   dimension-dropping regions all fail it and take the addrs route.  The
+   bound check then confirms the decomposed box lies inside self. */
+static void
+ca_object_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
+                            ca_size_t *counts, ca_size_t *steps, void *ptr)
+{
+  CAObject  *ca = (CAObject *) ap;
+  ca_size_t  native[CA_RANK_MAX], istep[CA_RANK_MAX], start[CA_RANK_MAX];
+  ca_size_t  s;
+  int8_t     k;
+  ID         mid = rb_intern("fill_block");
+
+  if ( ca_is_face(ca) ) {
+    ca_face_fill_stride(ap, base, ndim, counts, steps, ptr);
+    return;
+  }
+
+  if ( ndim == ca->ndim && rb_obj_respond_to(ca->self, mid, Qtrue) ) {
+    int aligned = 1;
+    s = 1;
+    for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
+    for ( k = 0; k < ndim; k++ ) {
+      if ( steps[k] <= 0 || steps[k] % native[k] != 0 ) { aligned = 0; break; }
+      istep[k] = steps[k] / native[k];
+      start[k] = ( base / native[k] ) % ca->dim[k];
+      if ( start[k] + ( counts[k] - 1 ) * istep[k] >= ca->dim[k] ) {
+        aligned = 0;
+        break;
+      }
+    }
+    if ( aligned ) {
+      volatile VALUE rstarts, rcounts, rsteps, rval;
+      rstarts = rb_ary_new_capa(ndim);
+      rcounts = rb_ary_new_capa(ndim);
+      rsteps  = rb_ary_new_capa(ndim);
+      for ( k = 0; k < ndim; k++ ) {
+        rb_ary_push(rstarts, SIZE2NUM(start[k]));
+        rb_ary_push(rcounts, SIZE2NUM(counts[k]));
+        rb_ary_push(rsteps,  SIZE2NUM(istep[k]));
+      }
+      rval = rb_ca_ptr2obj(ca->self, ptr);
+      rb_funcall(ca->self, mid, 4, rstarts, rcounts, rsteps, rval);
+      return;
+    }
+  }
+
+  /* addrs route: address windows -> ca_fill_addrs -> `fill_addrs` when the
+     author defined it, else the per-cell default. */
+  ca_fill_stride_via_addrs(ap, base, ndim, counts, steps, ptr);
+}
+
 static void
 ca_object_func_create_mask (void *ap)
 {
@@ -1050,6 +1151,8 @@ ca_operation_function_t ca_object_func = {
   NULL,                       /* fold_stride: never-fold (callback boundary) */
   ca_object_func_xfer_stride,
   ca_object_func_xfer_all,
+  .fill_addrs  = ca_object_func_fill_addrs,
+  .fill_stride = ca_object_func_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_record.c

@@ -202,7 +202,9 @@ ca_operation_function_t ca_record_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */