carray 3.0.1 → 3.0.3

data/ext/ca_obj_record.c

@@ -20,6 +20,7 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"
+#include "carray_internal.h"
 
 typedef struct {
   /* === CAView prefix === */
@@ -175,18 +176,6 @@ ca_record_func_allocate (void *ap)
   ca->ptr = ca->parent->ptr;
 }
 
-static void
-ca_record_func_create_mask (void *ap)
-{
-  CARecord *ca = (CARecord *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-  ca->mask = (CArray *) ca_refer_new(ca->parent->mask,
-                                      CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
-}
-
 ca_operation_function_t ca_record_func = {
   -1, /* CA_OBJ_RECORD — filled by ca_install_obj_type */
   CA_VIEW_ARRAY,
@@ -197,7 +186,7 @@ ca_operation_function_t ca_record_func = {
   ca_face_sync,
   ca_face_detach,
   ca_face_fill_data,
-  ca_record_func_create_mask,
+  ca_view_func_create_mask,
   ca_face_xfer_index,
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
@@ -230,6 +219,19 @@ ca_record_build (VALUE klass, VALUE data_class, VALUE parent_val)
              "CARecord requires a CA_FIXLEN parent (got data_type=%d)",
              parent_ca->data_type);
   }
+  /* Each record is read and written at the data_class's member offsets,
+     so the parent's cells have to be exactly that size. */
+  {
+    ca_size_t record_bytes =
+      NUM2SIZE(rb_const_get(data_class, rb_intern("DATA_SIZE")));
+    if ( parent_ca->bytes != record_bytes ) {
+      rb_raise(rb_eArgError,
+               "CARecord: %"PRIsVALUE" records are %lld bytes, the array's "
+               "elements are %lld bytes",
+               data_class, (long long) record_bytes,
+               (long long) parent_ca->bytes);
+    }
+  }
   ca  = ca_record_new(parent_ca, data_class);
   obj = TypedData_Wrap_Struct(klass, &carecord_data_type, ca);
   rb_ca_set_parent(obj, parent_val);
@@ -280,7 +282,9 @@ rb_ca_record_s_new (int argc, VALUE *argv, VALUE klass)
   }
   bytes = NUM2SIZE(rb_const_get(data_class, rb_intern("DATA_SIZE")));
 
-  parent_val = rb_carray_new(CA_FIXLEN, ndim, dim, bytes, NULL);
+  /* Zero-filled, as CArray.new is: a new record holds zeros, not the bytes
+     the allocator last handed out. */
+  parent_val = rb_carray_new_safe(CA_FIXLEN, ndim, dim, bytes, NULL);
   return ca_record_build(klass, data_class, parent_val);
 }
 
@@ -328,7 +332,7 @@ rb_ca_record_s_data_class_dsl (int argc, VALUE *argv, VALUE klass)
   }
   rb_scan_args(argc, argv, "1", &given);
   if ( ! NIL_P(current) ) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "data_class already fixed to %"PRIsVALUE
              "; CARecord subclass data_class is immutable once set",
              current);
@@ -352,11 +356,16 @@ rb_ca_record_initialize_copy (VALUE self, VALUE other)
 {
   CARecord *ca, *cs;
   TypedData_Get_Struct(self,  CARecord, &carecord_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CARecord, &carecord_data_type, cs);
   if ( ca_func[CA_OBJ_RECORD].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_RECORD, cs->parent->ndim);
   }
   ca_record_setup(ca, cs->parent, cs->data_class);
+  /* Marshal loads into an empty instance through here without copying
+     ivars, so the parent pin is set from `other`, not inherited. */
+  rb_ca_set_parent(self, rb_ca_parent(other));
+  rb_ivar_set(self, rb_intern("member"), rb_hash_new());
   return self;
 }
 
@@ -401,7 +410,7 @@ ca_check_data_class (VALUE rtype)
 {
   if ( ! rb_obj_is_data_class(rtype) ) {
     VALUE inspect = rb_inspect(rtype);
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eTypeError,
              "<%s> is not a data_class, which should has the features\n" \
              " * constant data_class::DATA_SIZE    -> integer\n" \
              " * constant data_class::MEMBERS      -> array of string\n" \
@@ -429,6 +438,26 @@ ca_record_state_compatible (CArray *a, CArray *b)
   return (ra->data_class == rb->data_class) ? 1 : 0;
 }
 
+/* Write hook: a struct element becomes its bytes, on every store path (a
+   block or index store writes to the storage, below the Face, where the
+   element itself could not be cast).  A struct of another data_class is
+   refused; anything else is left to the fixlen store (a String is bytes). */
+static VALUE
+ca_record_element_to_storage (VALUE self, VALUE obj)
+{
+  volatile VALUE data_class = rb_ca_data_class(self);
+  if ( rb_obj_is_kind_of(obj, data_class) ) {
+    return rb_funcall(obj, rb_intern("encode"), 0);
+  }
+  if ( RB_TYPE_P(obj, T_OBJECT) && ! RB_TYPE_P(obj, T_STRING)
+       && RTEST(rb_obj_is_data_class(rb_obj_class(obj))) ) {
+    rb_raise(rb_eTypeError,
+             "a %"PRIsVALUE" is not an element of a record array of %"PRIsVALUE,
+             rb_obj_class(obj), data_class);
+  }
+  return obj;
+}
+
 /* ------------------------------------------------------------------------- */
 
 void
@@ -454,6 +483,12 @@ Init_ca_obj_record (void)
   ca_face_register_state_compatible(CA_OBJ_RECORD,
                                     ca_record_state_compatible);
 
+  /* The record's bytes are its members: a MemoryView consumer reads them
+     through the T{...} struct format built from the data_class. */
+  ca_face_register_memory_view(CA_OBJ_RECORD, 1);
+  ca_face_register_element_to_storage(CA_OBJ_RECORD,
+                                      ca_record_element_to_storage);
+
   rb_define_alloc_func(rb_cCARecord, rb_ca_record_s_allocate);
   rb_define_method(rb_cCARecord, "initialize_copy",
                                   rb_ca_record_initialize_copy, 1);

data/ext/ca_obj_reduce.c

@@ -162,6 +162,7 @@ static void
 ca_reduce_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                             ca_size_t *strides, void *data, int dir)
 {
+  if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   CAReduce  *ca = (CAReduce *) ap;
   int8_t     ndim = ca->ndim;
   ca_size_t  native[CA_RANK_MAX], idx[CA_RANK_MAX];
@@ -224,8 +225,7 @@ ca_reduce_func_sync (void *ap)
     ca_reduce_func_xfer_addrs(ca, 1, &i, p, CA_XFER_PUT);
     p++;
   }
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
 }
 
 static void
@@ -264,8 +264,7 @@ ca_reduce_func_fill_data (void *ap, void *ptr)
   for (i=0; i<ca->elements; i++) {
     ca_reduce_func_xfer_addrs(ca, 1, &i, ptr, CA_XFER_PUT);
   }
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
 }
 
 static void
@@ -273,10 +272,7 @@ ca_reduce_func_create_mask (void *ap)
 {
   CAReduce *ca = (CAReduce *) ap;
 
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
 
   ca->mask = (CArray *) ca_reduce_new(ca->parent->mask, ca->count, ca->offset);
 }
@@ -314,6 +310,7 @@ rb_ca_reduce_initialize_copy (VALUE self, VALUE other)
   CAReduce *ca, *cs;
 
   TypedData_Get_Struct(self,  CAReduce, &careduce_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAReduce, &careduce_data_type, cs);
 
   ca_reduce_setup(ca, cs->parent, cs->count, cs->offset);

data/ext/ca_obj_refer.c

@@ -79,29 +79,38 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   CA_CHECK_DIM(ndim, dim);
   CA_CHECK_BYTES(data_type, bytes);
 
+  /* An object cell is a VALUE the GC marks: reading other bytes as one
+     marks garbage, and reading one as bytes exposes an address. */
   if (ca_is_object_type(parent) && data_type != CA_OBJECT) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eCADataTypeError,
              "object array can't be referred by other data type");
   }
+  if (! ca_is_object_type(parent) && data_type == CA_OBJECT) {
+    rb_raise(rb_eCADataTypeError,
+             "non-object array can't be referred as object data type");
+  }
   if (parent->elements && bytes > parent_bytes * parent->elements) {
-    rb_raise(rb_eRuntimeError, "bytes exceeds the data size of referent");
+    rb_raise(rb_eArgError, "bytes exceeds the data size of referent");
   }
   if (bytes < parent_bytes && parent_bytes % bytes != 0) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "bytes of reference array must be a multiple of that of referent");
   }
   if (bytes > parent_bytes && bytes % parent_bytes != 0) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "bytes of reference array must be a multiple of that of referent");
   }
   if (offset < 0) {
-    rb_raise(rb_eRuntimeError, "negative offset is not permitted for CARefer");
+    rb_raise(rb_eArgError, "negative offset is not permitted for CARefer");
+  }
+  elements = ca_shape_elements(ndim, dim, bytes);
+  if (offset > parent->elements) {
+    rb_raise(rb_eArgError,
+             "data size of reference array must not exceed that of referent");
   }
-  elements = 1;
-  for (i = 0; i < ndim; i++) elements *= dim[i];
   if ((bytes * elements + parent_bytes * offset) >
       (parent_bytes * parent->elements)) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "data size of reference array must not exceed that of referent");
   }
 
@@ -114,6 +123,12 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   /* base_offset is in bytes: `offset` is in parent-element units. */
   base_offset = offset * parent_bytes;
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   /* CAREFUL: initialise mask0 before ca_stride_setup — the setup
      may dispatch to ca_refer_func_create_mask, which writes to
      mask0.  Leaving it uninitialised risks freeing a garbage
@@ -134,7 +149,9 @@ ca_refer_new (CArray *parent,
               int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
               ca_size_t offset)
 {
-  CARefer *ca = (CARefer *) ca_array_alloc(CA_OBJ_REFER, ndim);
+  CARefer *ca;
+  ca_refer_setup(NULL, parent, data_type, ndim, dim, bytes, offset);
+  ca = (CARefer *) ca_array_alloc(CA_OBJ_REFER, ndim);
   ca_refer_setup(ca, parent, data_type, ndim, dim, bytes, offset);
   return ca;
 }
@@ -172,10 +189,7 @@ ca_refer_func_create_mask (void *ap)
   ca_size_t parent_bytes = ca->parent->bytes;
   ca_size_t parent_offset;
 
-  ca_update_mask(ca->parent);
-  if (! ca->parent->mask) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
 
   parent_offset = ca->base_offset / parent_bytes;
 
@@ -200,9 +214,12 @@ ca_refer_func_create_mask (void *ap)
     ca->mask0 =
       (CArray *) ca_repeat_new(ca->parent->mask, ca->parent->ndim + 1, count);
     ca_unset_flag(ca->mask0, CA_FLAG_READ_ONLY);
+    /* mask0 has ratio cells per parent element, so the offset is counted
+       in those. */
     ca->mask =
       (CArray *) ca_refer_new(ca->mask0,
-                              CA_BOOLEAN, ca->ndim, ca->dim, 0, parent_offset);
+                              CA_BOOLEAN, ca->ndim, ca->dim, 0,
+                              parent_offset * ratio);
   }
   else {
     /* Spanned reinterpret: ratio = bytes / parent_bytes parent
@@ -232,6 +249,7 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
 {
   CARefer *ca, *cs;
   TypedData_Get_Struct(self,  CARefer, &carefer_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CARefer, &carefer_data_type, cs);
   if ( ca_func[CA_OBJ_REFER].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_REFER, cs->ndim);
@@ -275,6 +293,34 @@ rb_ca_refer_initialize_copy (VALUE self, VALUE other)
  *   2. Match ranges of parent axes to new axes so element products
  *      agree.  Inside each matched range, root_strides must be
  *      inter-axis contiguous. */
+/* Three properties of an array are answered by walking its C parent chain:
+   ca_is_value_array, ca_is_readonly and ca_is_mask_array.  An array that is
+   built somewhere other than as a child of `src` -- a reshape that folds
+   onto the root, the copy that dup / clone makes -- does not have `src` on
+   that chain, so carry each property across from `src`.  Without this a
+   reshape or a dup of x.value reads the mask of x again (and takes UNDEF
+   into it), and a reshape of a broadcast view becomes writable. */
+void
+ca_keep_chain_flags (CArray *view, CArray *src)
+{
+  if ( ca_is_value_array(src) ) {
+    if ( view->mask ) {
+      ca_free(view->mask);
+      view->mask = NULL;
+    }
+    ca_set_flag(view, CA_FLAG_VALUE_ARRAY);
+  }
+  if ( ca_is_readonly(src) ) {
+    ca_set_flag(view, CA_FLAG_READ_ONLY);
+    if ( view->mask ) {
+      ca_set_flag(view->mask, CA_FLAG_READ_ONLY);
+    }
+  }
+  if ( ca_is_mask_array(src) ) {
+    ca_set_flag(view, CA_FLAG_MASK_ARRAY);
+  }
+}
+
 static int
 ca_reshape_try_strides (CArray *parent,
                         const ca_size_t *new_dim,
@@ -401,8 +447,11 @@ ca_reshape_try_strides (CArray *parent,
   return 1;
 }
 
+/* `refer` with its options given apart from argv, for callers in C that
+   build the options themselves (a Hash at the end of argv is read as
+   options only when the Ruby caller passed keywords). */
 static VALUE
-rb_ca_refer (int argc, VALUE *argv, VALUE self)
+rb_ca_refer_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
 {
   volatile VALUE obj = Qnil;
   CArray *ca;
@@ -415,7 +464,7 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if (argc == 0) {
+  if (argc == 0 && NIL_P(ropt)) {
     data_type = ca->data_type;
     bytes     = ca->bytes;
     ndim      = ca->ndim;
@@ -425,39 +474,57 @@ rb_ca_refer (int argc, VALUE *argv, VALUE self)
     rb_ca_set_parent(obj, self);
   }
   else {
-    volatile VALUE rtype, rdim, ropt, rbytes = Qnil, roffset = Qnil;
-    ropt = rb_pop_options(&argc, &argv);
+    volatile VALUE rtype, rdim, rbytes = Qnil, roffset = Qnil;
     rb_scan_args(argc, argv, "11", (VALUE *) &rtype, (VALUE *) &rdim);
     rb_scan_options(ropt, "bytes,offset", &rbytes, &roffset);
     if (NIL_P(rbytes)) rbytes = rb_ca_bytes(self);
     rb_ca_guess_type_and_bytes(rtype, rbytes, &data_type, &bytes);
     if (NIL_P(rdim)) {
       if (ca->bytes != bytes) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "specify dimension shape for different byte size");
       } else {
         rdim = rb_ca_dim(self);
       }
     }
     Check_Type(rdim, T_ARRAY);
+    CA_CHECK_RANK(RARRAY_LEN(rdim));   /* before dim[] is filled */
     ndim = RARRAY_LEN(rdim);
     for (i = 0; i < ndim; i++) dim[i] = NUM2SIZE(rb_ary_entry(rdim, i));
     if (! NIL_P(roffset)) offset = NUM2SIZE(roffset);
+    /* When rtype is a data_class the result is a record array.  It is
+       built on the storage, never on a Face, so that a Face stays on top
+       of the chain: re-reading a record array as its own data_class lifts
+       it (keeping its class), any other data_class wraps a new CARecord. */
+    if ( rb_obj_is_data_class(rtype) ) {
+      volatile VALUE base = rb_ca_strip_face_value(self);
+      CArray *base_ca;
+      TypedData_Get_Struct(base, CArray, &carray_data_type, base_ca);
+      cr = ca_refer_new(base_ca, data_type, ndim, dim, bytes, offset);
+      obj = ca_wrap_struct(cr);
+      rb_ca_set_parent(obj, base);
+      if ( ca->obj_type == CA_OBJ_RECORD
+           && rb_ca_data_class(self) == rtype ) {
+        return ca_face_lift(obj, self);
+      }
+      return rb_funcall(rb_const_get(rb_cObject, rb_intern("CARecord")),
+                        rb_intern("wrap"), 2, obj, rtype);
+    }
     cr = ca_refer_new((CArray *) ca, data_type, ndim, dim, bytes, offset);
     obj = ca_wrap_struct(cr);
     rb_ca_set_parent(obj, self);
-    /* When rtype is a data_class, wrap the result in CARecord so
-       the data_class is carried even if self is not itself a Face. */
-    if ( rb_obj_is_data_class(rtype) ) {
-      obj = rb_funcall(rb_const_get(rb_cObject, rb_intern("CARecord")),
-                       rb_intern("wrap"), 2, obj, rtype);
-      return obj;
-    }
   }
   CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 
+static VALUE
+rb_ca_refer (int argc, VALUE *argv, VALUE self)
+{
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  return rb_ca_refer_kw(argc, argv, ropt, self);
+}
+
 VALUE
 rb_ca_refer_new (VALUE self,
                  int8_t data_type, int8_t ndim, ca_size_t *dim, ca_size_t bytes,
@@ -483,7 +550,7 @@ rb_ca_refer_new (VALUE self,
   rb_ary_store(list, 2, ropt);
 
   {
-    volatile VALUE obj = rb_ca_refer(3, (VALUE *) RARRAY_CONST_PTR(list), self);
+    volatile VALUE obj = rb_ca_refer_kw(2, (VALUE *) RARRAY_CONST_PTR(list), ropt, self);
     CArray *co;
 
     /* CAREFUL: this is the internal builder -- some fifteen call sites want
@@ -535,6 +602,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
   CARefer *cr;
   ca_size_t new_dim[CA_RANK_MAX];
   ca_size_t prod = 1;
+  int overflow = 0, zero = 0;
   int placeholder_idx = -1;     /* axis with `-1` or `:~` infer placeholder */
   int i;
   volatile VALUE obj;
@@ -553,7 +621,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     if ( (FIXNUM_P(argv[i]) && FIX2LONG(argv[i]) == -1)
          || argv[i] == sym_tilde ) {
       if (placeholder_idx >= 0) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "reshape: only one auto-infer placeholder (-1 / :~) allowed");
       }
       placeholder_idx = i;
@@ -578,7 +646,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
         src = (i < ca->ndim) ? i : ca->ndim - (argc - i);
       }
       if (src < 0 || src >= ca->ndim) {
-        rb_raise(rb_eRuntimeError,
+        rb_raise(rb_eArgError,
                  "reshape: nil at axis %d has no source dim", i);
       }
       new_dim[i] = ca->dim[src];
@@ -586,13 +654,27 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     else {
       new_dim[i] = NUM2SIZE(argv[i]);
     }
-    prod *= new_dim[i];
+    /* A product too large to count cannot equal the element count; an
+       extent of zero anywhere makes it zero whatever it overflowed to. */
+    if ( __builtin_mul_overflow(prod, new_dim[i], &prod) ) {
+      overflow = 1;
+    }
+    if ( new_dim[i] == 0 ) {
+      zero = 1;
+    }
+  }
+  if ( zero ) {
+    prod = 0;
+  }
+  else if ( overflow ) {
+    rb_raise(rb_eArgError,
+             "reshape: the shape has more elements than an array can hold");
   }
 
   /* Resolve placeholder dim from the leftover total. */
   if (placeholder_idx >= 0) {
     if (prod == 0 || ca->elements % prod != 0) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "reshape: cannot infer dim for `-1` placeholder");
     }
     new_dim[placeholder_idx] = ca->elements / prod;
@@ -604,7 +686,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
        a subset), and on non-contiguous parents the compose-fold
        path corrupts data outright — hence the raise. */
     if (prod != ca->elements) {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "reshape: cannot reshape array of %lld elements into a shape "
                "of %lld elements (use -1 / :~ to infer a dim)",
                (long long) ca->elements, (long long) prod);
@@ -627,6 +709,7 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
                                    ca->data_type, ca->bytes,
                                    (int8_t) argc, new_dim,
                                    out_strides, out_base);
+      ca_keep_chain_flags((CArray *) cs, ca);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
       CA_WRAPPER_LIFT(obj, self, ca);
@@ -664,6 +747,7 @@ rb_ca_flatten (VALUE self)
       CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, out_root,
                                    ca->data_type, ca->bytes,
                                    1, dim, out_strides, out_base);
+      ca_keep_chain_flags((CArray *) cs, ca);
       obj = ca_wrap_struct(cs);
       rb_ca_set_parent(obj, self);
       CA_WRAPPER_LIFT(obj, self, ca);
@@ -725,7 +809,7 @@ rb_ca_insert_axis (int argc, VALUE *argv, VALUE self)
     gap_count[i] = 0;
   }
   for (i = 0; i < argc; i++) {
-    int raw = NUM2INT(argv[i]);
+    int raw = (int) ca_axis_integer(argv[i], "insert_axis");
     int g   = (raw < 0) ? raw + ngap : raw;
     if (g < 0 || g >= ngap) {
       rb_raise(rb_eArgError,

data/ext/ca_obj_remap.c

@@ -7,9 +7,9 @@
   Constraints:
   - ref.dim == idx.dim (same shape, same ndim, per-axis dim match)
   - idx.data_type == CA_SIZE (caller responsible)
-  - No public constructor — there is no `CArray#remap(idx)` or
-    `CARemap.new` surface; the class is only reachable via internal
-    helpers and the `ca[idx]` same-shape indexer fast path.
+  - No public constructor — there is no `CArray#remap(idx)` surface; a
+    view is built by internal helpers and the `ca[idx]` same-shape
+    indexer fast path.  `dup` / `clone` copy an existing one.
   - The CARemap Ruby class IS rb_define_class'd: visibility lets users
     see "this view came from a same-shape gather" when they inspect
     `.class`.  CA_OBJ_REMAP integer remains unexported as a Ruby
@@ -18,6 +18,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 
 typedef struct {
   int16_t   obj_type;
@@ -216,9 +217,7 @@ ca_remap_func_allocate (void *ap)
 static void
 ca_remap_func_attach (void *ap)
 {
-  CARemap *ca = (CARemap *) ap;
-  ca->ptr = xmalloc(ca_length(ca));
-  ca_remap_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
+  ca_axis_view_attach_owned(ap);
 }
 
 static void
@@ -265,10 +264,7 @@ static void
 ca_remap_func_create_mask (void *ap)
 {
   CARemap *ca = (CARemap *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   /* Mask is a CARemap over (parent->mask, idx) — same shape, boolean. */
   ca->mask = (CArray *) ca_remap_new(ca->parent->mask, ca->idx);
 }
@@ -282,7 +278,7 @@ ca_remap_func_create_mask (void *ap)
      2. ca_xfer_addrs(ca->idx, n, addrs, paddrs, GET)  — one batched
         read of the parent flat addresses through ca->idx's own
         xfer_addrs dispatcher (entity, view, view chain — all
-        transparent).
+        transparent), each address then checked against the parent.
      3. ca_xfer_addrs(ca->parent, n, paddrs, data, dir) — one batched
         gather/scatter of the user payload against parent.
 
@@ -295,13 +291,20 @@ ca_remap_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 {
   CARemap   *ca = (CARemap *) ap;
   ca_size_t *paddrs;
+  ca_size_t  i;
   volatile VALUE holder;
 
   if ( n == 0 ) return;
 
   paddrs = ALLOCV_N(ca_size_t, holder, n);
-  ca_xfer_addrs(ca->idx,    n, addrs,  paddrs, CA_XFER_GET);
-  ca_xfer_addrs(ca->parent, n, paddrs, data,   dir);
+  ca_xfer_addrs(ca->idx, n, addrs, paddrs, CA_XFER_GET);
+  /* idx is read live, so its values are checked here, not at
+     construction: negative counts from the end, out of range raises
+     before the parent is touched. */
+  for ( i = 0; i < n; i++ ) {
+    CA_CHECK_INDEX(paddrs[i], ca->parent->elements);
+  }
+  ca_xfer_addrs(ca->parent, n, paddrs, data, dir);
   ALLOCV_END(holder);
 }
 
@@ -329,6 +332,7 @@ static void
 ca_remap_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)
 {
+  if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   CARemap   *ca = (CARemap *) ap;
   int8_t     ndim = ca->ndim;
   ca_size_t  native[CA_RANK_MAX], idx[CA_RANK_MAX];
@@ -443,18 +447,54 @@ rb_ca_remap_mapper (VALUE self)
 }
 
 
+/* `dup` / `clone`.  CARemap has no allocator (Ruby cannot build one), so
+   Object#dup cannot copy it; these build the copy the way the indexer
+   does: a new view over the same parent and the same index array. */
+static VALUE
+rb_ca_remap_dup (VALUE self)
+{
+  return rb_ca_remap_new(rb_ca_parent(self),
+                         rb_ivar_get(self, rb_intern("remap_idx")));
+}
+
+static VALUE
+rb_ca_remap_clone (int argc, VALUE *argv, VALUE self)
+{
+  VALUE opts = Qnil, vfreeze = Qnil;
+  volatile VALUE obj;
+  rb_scan_args(argc, argv, "0:", &opts);
+  if ( ! NIL_P(opts) ) {
+    /* rb_get_kwargs refuses any key but freeze:, as Kernel#clone does. */
+    ID kw[1];
+    VALUE val[1];
+    kw[0] = rb_intern("freeze");
+    rb_get_kwargs(opts, kw, 0, 1, val);
+    if ( val[0] != Qundef ) {
+      vfreeze = val[0];
+    }
+  }
+  obj = rb_ca_remap_dup(self);
+  if ( RTEST(vfreeze) || ( NIL_P(vfreeze) && OBJ_FROZEN(self) ) ) {
+    rb_obj_freeze(obj);
+  }
+  return obj;
+}
+
 void
 Init_ca_obj_remap (void)
 {
   /* CARemap is a proper Ruby class so users can see "this view is a
-     per-element gather" on .class.  No allocator, no initialize, no
-     `new` reachable from Ruby — construction is C-internal only.
-     CA_OBJ_REMAP integer remains unexported (it's an internal type
-     tag, not user-meaningful). */
+     per-element gather" on .class.  A view is built from C only (the
+     indexer and sort / partition): there is no allocator, and `dup` /
+     `clone` are defined here instead of going through one.  CA_OBJ_REMAP
+     integer remains unexported (it's an internal type tag, not
+     user-meaningful). */
   rb_cCARemap     = rb_define_class("CARemap",     rb_cCAView);
   rb_cCARemapMask = rb_define_class("CARemapMask", rb_cCARemap);
   rb_undef_alloc_func(rb_cCARemap);
   rb_undef_alloc_func(rb_cCARemapMask);
+  rb_define_method(rb_cCARemap, "dup",   rb_ca_remap_dup,    0);
+  rb_define_method(rb_cCARemap, "clone", rb_ca_remap_clone, -1);
 
   ca_remap_func.struct_size = sizeof(CARemap);
   ca_remap_func.pool_bytes  = ca_remap_pool_bytes;