carray 3.0.4 → 3.0.6

data/ext/carray_mask.c

@@ -13,6 +13,7 @@
 #include "carray.h"
 #include "carray_internal.h"   /* ca_lazy_arena_* */
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE for the mask-lift path */
+#include <ruby/ractor.h>
 
 /* ============================================================================
  *  Word-bulk mask substrate helpers.
@@ -37,16 +38,32 @@
 #define CA_MASK_WORD_BYTES 8
 #define CA_MASK_WORD_LSB   0x0101010101010101ULL
 
+/* A mask may start at any byte (a window or a block view offsets it), so a
+   word is read and written through memcpy, never through a uint64_t
+   pointer; the compiler still lowers each to a single load or store.  */
+static inline uint64_t
+ca_mask_word_load (const boolean8_t *p)
+{
+  uint64_t w;
+  memcpy(&w, p, sizeof(w));
+  return w;
+}
+
+static inline void
+ca_mask_word_store (boolean8_t *p, uint64_t w)
+{
+  memcpy(p, &w, sizeof(w));
+}
+
 /* ma[i] |= ms[i] for i in [0, n)  -- used by ca_copy_mask_overlay_n */
 static inline void
 ca_mask_word_or (boolean8_t *ma, const boolean8_t *ms, ca_size_t n)
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  uint64_t       *wa = (uint64_t *)       ma;
-  const uint64_t *ws = (const uint64_t *) ms;
   for (i = 0; i < nw; i++) {
-    wa[i] |= ws[i];
+    ca_mask_word_store(ma + i*CA_MASK_WORD_BYTES,
+                       ca_mask_word_load(ma + i*CA_MASK_WORD_BYTES) | ca_mask_word_load(ms + i*CA_MASK_WORD_BYTES));
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     ma[i] |= ms[i];
@@ -62,11 +79,9 @@ ca_mask_word_and (boolean8_t       *md,
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  uint64_t       *wd = (uint64_t *)       md;
-  const uint64_t *wa = (const uint64_t *) ma;
-  const uint64_t *wb = (const uint64_t *) mb;
   for (i = 0; i < nw; i++) {
-    wd[i] = wa[i] & wb[i];
+    ca_mask_word_store(md + i*CA_MASK_WORD_BYTES,
+                       ca_mask_word_load(ma + i*CA_MASK_WORD_BYTES) & ca_mask_word_load(mb + i*CA_MASK_WORD_BYTES));
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     md[i] = ma[i] & mb[i];
@@ -82,11 +97,9 @@ ca_mask_word_xor (boolean8_t       *md,
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  uint64_t       *wd = (uint64_t *)       md;
-  const uint64_t *wa = (const uint64_t *) ma;
-  const uint64_t *wb = (const uint64_t *) mb;
   for (i = 0; i < nw; i++) {
-    wd[i] = wa[i] ^ wb[i];
+    ca_mask_word_store(md + i*CA_MASK_WORD_BYTES,
+                       ca_mask_word_load(ma + i*CA_MASK_WORD_BYTES) ^ ca_mask_word_load(mb + i*CA_MASK_WORD_BYTES));
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     md[i] = ma[i] ^ mb[i];
@@ -99,10 +112,8 @@ ca_mask_word_not (boolean8_t *md, const boolean8_t *ms, ca_size_t n)
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  uint64_t       *wd = (uint64_t *)       md;
-  const uint64_t *ws = (const uint64_t *) ms;
   for (i = 0; i < nw; i++) {
-    wd[i] = ws[i] ^ CA_MASK_WORD_LSB;
+    ca_mask_word_store(md + i*CA_MASK_WORD_BYTES, ca_mask_word_load(ms + i*CA_MASK_WORD_BYTES) ^ CA_MASK_WORD_LSB);
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     md[i] = ms[i] ^ (boolean8_t) 1;
@@ -116,9 +127,8 @@ ca_mask_word_any (const boolean8_t *m, ca_size_t n)
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  const uint64_t *w  = (const uint64_t *) m;
   for (i = 0; i < nw; i++) {
-    if ( w[i] != 0 ) return 1;
+    if ( ca_mask_word_load(m + i*CA_MASK_WORD_BYTES) != 0 ) return 1;
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     if ( m[i] ) return 1;
@@ -134,9 +144,8 @@ ca_mask_word_all_set (const boolean8_t *m, ca_size_t n)
 {
   ca_size_t       nw = n / CA_MASK_WORD_BYTES;
   ca_size_t       i;
-  const uint64_t *w  = (const uint64_t *) m;
   for (i = 0; i < nw; i++) {
-    if ( w[i] != CA_MASK_WORD_LSB ) return 0;
+    if ( ca_mask_word_load(m + i*CA_MASK_WORD_BYTES) != CA_MASK_WORD_LSB ) return 0;
   }
   for (i = nw * CA_MASK_WORD_BYTES; i < n; i++) {
     if ( ! m[i] ) return 0;
@@ -293,7 +302,13 @@ ca_has_mask (void *ap)
   if ( ca->mask ) {                /* mask array already created */
     return 1;
   }
-  else if ( ca_is_value_array(ca) ) {
+  else if ( ca_test_flag(ca, CA_FLAG_VALUE_ARRAY) ) {
+    /* Only this array's own mark, not ca_is_value_array, which walks to
+       the root and would make every level of a view pay again for the
+       levels above it.  A view below a value array still answers 0: it
+       asks its parent, and the question reaches the marked array.  No
+       level in between has a mask, since ca_create_mask refuses one for
+       anything below a value array. */
     return 0;                     /* array itself is returned by CArray#value */
   }
   else if ( ca_is_entity(ca) ) {   /* entity array */
@@ -308,6 +323,11 @@ ca_has_mask (void *ap)
       }
       return 0;
     }
+    /* The one level that answers without asking its parent: a value
+       array above it has to be looked for here. */
+    if ( ca_is_value_array(ca) ) {
+      return 0;
+    }
     if ( rb_obj_respond_to(co->self, rb_intern("mask_created?"), Qtrue) ) {
       return RTEST(rb_funcall(co->self, rb_intern("mask_created?"), 0));
     }
@@ -404,6 +424,45 @@ ca_view_func_create_mask (void *ap)
                                      CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
 }
 
+/* The sync slot of a view whose mask came from ca_view_func_create_mask
+   calls this after syncing its parent.  The view's mask is a refer over
+   the parent's mask, and when the parent's mask is itself a view, both
+   hold a buffer while the window is open; the refer writes past the
+   parent's buffer to the root.  Syncing the parent then writes its
+   buffer, from before the view's mask was written, back over the root,
+   so the view's mask is synced once more. */
+
+/* The sync slot of a view that maps its cells one to one onto its parent's
+   (a fake, a cast, a byte swap, a Face) calls this before syncing its
+   parent.  The view's mask may have been written past the parent's mask
+   buffer, straight to the root (by a view over it), so the parent's
+   buffer can still hold the bits from before.  The parent's own sync
+   decides from that buffer which cells it sends back, so the view's bits
+   are copied into it first. */
+
+void
+ca_view_pass_mask_to_parent (void *ap)
+{
+  CAView *ca = (CAView *) ap;
+  if ( ca->mask != NULL && ca->mask->ptr != NULL
+       && ca->parent->mask != NULL && ca->parent->mask->ptr != NULL
+       && ca->mask->ptr != ca->parent->mask->ptr
+       && ca->elements == ca->parent->elements ) {
+    memmove(ca->parent->mask->ptr, ca->mask->ptr, (size_t) ca->elements);
+  }
+}
+
+void
+ca_view_sync_mask_after_parent (void *ap)
+{
+  CAView *ca = (CAView *) ap;
+  if ( ca->mask != NULL && ca->mask->ptr != NULL
+       && ca->parent->mask != NULL && ca->parent->mask->ptr != NULL
+       && ca_is_view(ca->parent->mask) ) {
+    ca_sync(ca->mask);
+  }
+}
+
 /* create mask array if array has mask but has not mask array */
 
 void
@@ -433,20 +492,27 @@ ca_mask_standin_new (CArray *parent)
   return z;
 }
 
-/* A value array or a mask array: a parent that can never be given a mask,
-   whose stand-in therefore stays in place for good. */
-static int
-ca_mask_standin_parent_unmaskable (CArray *parent)
+/* A stack or meld refuses a value array or a mask array as a part: such an
+   array can have no mask, and a part of a stack or meld is an array like
+   any other, which can. */
+void
+ca_multi_parent_check_part (CArray *part, const char *name)
 {
-  return ca_is_value_array(parent) || ca_is_mask_array(parent);
+  if ( ca_is_value_array(part) ) {
+    rb_raise(rb_eArgError,
+             "%s: a value array can have no mask and can not be a part", name);
+  }
+  if ( ca_is_mask_array(part) ) {
+    rb_raise(rb_eArgError,
+             "%s: a mask array can have no mask and can not be a part", name);
+  }
 }
 
 CArray *
 ca_mask_standin_current (CArray *mask_view, CArray *reading, CArray *parent,
                          CArray *standin)
 {
-  if ( standin == NULL || reading != standin
-       || ca_mask_standin_parent_unmaskable(parent) ) {
+  if ( standin == NULL || reading != standin ) {
     return reading;
   }
   /* Not inside an attach window whose buffer is out: that buffer and the
@@ -482,23 +548,21 @@ ca_mask_standin_settle (CArray *parent, CArray *standin)
   if ( i == n ) {
     return;
   }
-  if ( ca_mask_standin_parent_unmaskable(parent) ) {
-    MEMZERO(z, boolean8_t, n);
-    rb_raise(rb_eTypeError, "can not create mask array for the %s array",
-             ca_is_value_array(parent) ? "value" : "mask");
-  }
-  ca_create_mask(parent);
   /* The trues are added to the parent's mask, not copied over it: the
-     parent may have come to have masked cells of its own meanwhile. */
+     parent may have come to have masked cells of its own meanwhile.  The
+     stand-in is cleared before the parent is asked for a mask, so a
+     parent that refuses one leaves it all false, as its readers take it
+     to be at rest. */
   addrs = ALLOCV_N(ca_size_t, holder, n);
   for ( ; i < n; i++ ) {
     if ( z[i] ) {
       addrs[m++] = i;
     }
   }
+  MEMZERO(z, boolean8_t, n);
+  ca_create_mask(parent);
   ca_fill_addrs(parent->mask, m, addrs, &one);
   ALLOCV_END(holder);
-  MEMZERO(z, boolean8_t, n);
 }
 
 CArray *
@@ -531,114 +595,37 @@ ca_multi_parent_mask_refresh (CArray *mask, CArray **parents,
   CAVIEW(mask)->parent = mp->parents[0];
 }
 
-typedef struct {
-  CArray  *mask;
-  CArray **blanks;
-  CArray **saved;
-  CArray  *saved_parent;
-  int32_t  n;
-  int      finished;
-  VALUE  (*body)(VALUE);
-  VALUE    arg;
-} ca_mp_trial_t;
-
-static VALUE
-ca_mp_trial_body (VALUE p)
-{
-  ca_mp_trial_t *t = (ca_mp_trial_t *) p;
-  t->body(t->arg);
-  t->finished = 1;
-  return Qnil;
-}
-
-static void
-ca_mp_trial_free_blanks (ca_mp_trial_t *t)
-{
-  int32_t k;
-  for ( k = 0; k < t->n; k++ ) {
-    ca_free(t->blanks[k]);
-    t->blanks[k] = NULL;
-  }
-}
-
-static VALUE
-ca_mp_trial_restore (VALUE p)
-{
-  ca_mp_trial_t *t = (ca_mp_trial_t *) p;
-  CAMultiParent *mp = (CAMultiParent *) t->mask;
-  int32_t k;
-  for ( k = 0; k < t->n; k++ ) {
-    mp->parents[k] = t->saved[k];
-  }
-  CAVIEW(t->mask)->parent = t->saved_parent;
-  if ( ! t->finished ) {
-    ca_mp_trial_free_blanks(t);
-  }
-  return Qnil;
-}
-
+/* Before a write that puts a true into the mask of a stack or meld (not one
+   with its buffer out): each part still reading its stand-in that shares
+   its root with another part is given its own mask, and the write goes to
+   those parts' masks in their order.  Parts that share cells then take the
+   write of the last of them, as they do for values; through stand-ins,
+   settled afterwards, the trues would be added together.  A part that
+   shares nothing keeps its stand-in, and gets no mask from falses. */
 void
-ca_multi_parent_mask_refuse_first (CArray *mask, CArray **parents,
-                                   CArray **standins, int32_t n,
-                                   VALUE (*body)(VALUE), VALUE arg)
+ca_multi_parent_mask_adopt (CArray *mask, CArray **parents,
+                            CArray **standins, int32_t n)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
-  volatile VALUE h_blank = 0, h_saved = 0;
-  ca_mp_trial_t t;
-  int32_t k, refused = -1;
-  if ( standins == NULL ) {
+  int32_t k, j;
+  if ( standins == NULL || mask->ptr != NULL ) {
     return;
   }
   for ( k = 0; k < n; k++ ) {
-    if ( standins[k] != NULL && mp->parents[k] == standins[k]
-         && ca_mask_standin_parent_unmaskable(parents[k]) ) {
-      break;
+    if ( standins[k] == NULL || mp->parents[k] != standins[k]
+         || ca_test_flag(standins[k], CA_FLAG_READ_ONLY) ) {
+      continue;
     }
-  }
-  if ( k == n ) {
-    return;
-  }
-  t.mask         = mask;
-  t.n            = n;
-  t.finished     = 0;
-  t.body         = body;
-  t.arg          = arg;
-  t.saved_parent = CAVIEW(mask)->parent;
-  t.blanks       = ALLOCV_N(CArray *, h_blank, n);
-  t.saved        = ALLOCV_N(CArray *, h_saved, n);
-  for ( k = 0; k < n; k++ ) {
-    t.blanks[k] = NULL;
-  }
-  for ( k = 0; k < n; k++ ) {
-    CArray *m = mp->parents[k];
-    t.saved[k]  = m;
-    t.blanks[k] = carray_new(CA_BOOLEAN, m->ndim, m->dim, 0, NULL);
-    MEMZERO(t.blanks[k]->ptr, boolean8_t, t.blanks[k]->elements);
-  }
-  for ( k = 0; k < n; k++ ) {
-    mp->parents[k] = t.blanks[k];
-  }
-  CAVIEW(mask)->parent = t.blanks[0];
-  rb_ensure(ca_mp_trial_body, (VALUE) &t, ca_mp_trial_restore, (VALUE) &t);
-  for ( k = 0; k < n && refused < 0; k++ ) {
-    CArray    *z = t.blanks[k];
-    ca_size_t  i;
-    if ( standins[k] == NULL || t.saved[k] != standins[k]
-         || ! ca_mask_standin_parent_unmaskable(parents[k]) ) {
+    for ( j = 0; j < n && ( j == k || ! ca_shares_root(parents[j], parents[k]) ); j++ ) ;
+    if ( j == n ) {
       continue;
     }
-    for ( i = 0; i < z->elements && ! ((boolean8_t *) z->ptr)[i]; i++ ) ;
-    if ( i < z->elements ) {
-      refused = k;
+    ca_create_mask(parents[k]);
+    if ( parents[k]->mask != NULL ) {
+      mp->parents[k] = parents[k]->mask;
     }
   }
-  ca_mp_trial_free_blanks(&t);
-  ALLOCV_END(h_blank);
-  ALLOCV_END(h_saved);
-  if ( refused >= 0 ) {
-    rb_raise(rb_eTypeError, "can not create mask array for the %s array",
-             ca_is_value_array(parents[refused]) ? "value" : "mask");
-  }
+  CAVIEW(mask)->parent = mp->parents[0];
 }
 
 void
@@ -646,18 +633,12 @@ ca_multi_parent_mask_settle (CArray *mask, CArray **parents,
                              CArray **standins, int32_t n)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
-  int32_t k, pass;
+  int32_t k;
   if ( standins == NULL ) {
     return;
   }
-  /* The parts that can have no mask first, so that a refused true leaves
-     the other parts as they were. */
-  for ( pass = 0; pass < 2; pass++ ) {
-    for ( k = 0; k < n; k++ ) {
-      if ( standins[k] == NULL || mp->parents[k] != standins[k]
-           || ca_mask_standin_parent_unmaskable(parents[k]) != ( pass == 0 ) ) {
-        continue;
-      }
+  for ( k = 0; k < n; k++ ) {
+    if ( standins[k] != NULL && mp->parents[k] == standins[k] ) {
       ca_mask_standin_settle(parents[k], standins[k]);
     }
   }
@@ -789,6 +770,9 @@ typedef struct {
   int          k;         /* entries in list */
   int          ns;        /* sources */
   ca_size_t    elements;
+  CArray      *dest;      /* the destination */
+  int          overwrite; /* clear the destination's mask first */
+  char        *modes;     /* attach modes, one per entry of list */
 } ca_mask_overlay_t;
 
 static VALUE
@@ -815,6 +799,31 @@ ca_mask_overlay_body (VALUE arg)
   return Qnil;
 }
 
+/* Clear the destination's mask if asked, and OR the sources into it. */
+static VALUE
+ca_mask_overlay_write (VALUE arg)
+{
+  ca_mask_overlay_t *o = (ca_mask_overlay_t *) arg;
+  CArray *ca = o->dest;
+  int i;
+  if ( o->overwrite ) {
+    boolean8_t zero = 0;
+    ca_fill(ca->mask, &zero);
+  }
+  o->k = 0;
+  o->list[o->k]    = ca->mask;
+  o->modes[o->k++] = 'w';
+  for (i=0; i<o->ns; i++) {
+    if ( o->att[i] ) {
+      o->list[o->k]    = o->att[i];
+      o->modes[o->k++] = 'r';
+    }
+  }
+  o->modes[o->k] = '\0';
+  ca_attach_window(o->k, o->list, o->modes, ca_mask_overlay_body, arg);
+  return Qnil;
+}
+
 /* overwrite: the destination's mask is cleared before the sources are
    OR'd in (and left alone when it has none and no source has a mask). */
 static void
@@ -899,22 +908,10 @@ ca_copy_mask_overlay_core (CArray *ca, ca_size_t elements, int n,
   }
 
   ca_create_mask(ca);
-  if ( overwrite ) {
-    boolean8_t zero = 0;
-    ca_fill(ca->mask, &zero);
-  }
-
-  o.k = 0;
-  o.list[o.k]  = ca->mask;
-  modes[o.k++] = 'w';
-  for (i=0; i<o.ns; i++) {
-    if ( o.att[i] ) {
-      o.list[o.k]  = o.att[i];
-      modes[o.k++] = 'r';
-    }
-  }
-  modes[o.k] = '\0';
-  ca_attach_window(o.k, o.list, modes, ca_mask_overlay_body, (VALUE) &o);
+  o.dest      = ca;
+  o.overwrite = overwrite;
+  o.modes     = modes;
+  ca_mask_overlay_write((VALUE) &o);
 
   for (i=0; i<n; i++) {
     if ( holders[i] ) {
@@ -1840,7 +1837,9 @@ ca_mask_copy_where (VALUE self, int argc, VALUE *argv)
   obj = rb_ca_copy(self);
   memcpy(all_args, argv, argc * sizeof(VALUE));
   all_args[argc] = CA_UNDEF;
-  rb_funcallv(obj, rb_intern("[]="), argc + 1, all_args);
+  /* a CScalar takes no index; its one-cell view does */
+  rb_funcallv(ca_is_scalar(ca) ? rb_funcall(obj, rb_intern("flatten"), 0) : obj,
+              rb_intern("[]="), argc + 1, all_args);
   return obj;
 }
 
@@ -1872,6 +1871,19 @@ rb_ca_mask_where (int argc, VALUE *argv, VALUE self)
   return ca_mask_copy_where(self, argc, argv);
 }
 
+/* inherit_mask's sources are read cell by cell over self, so an array
+   source has self's number of cells (a scalar's one cell applies to all). */
+static void
+ca_inherit_mask_check_source (CArray *ca, CArray *cs)
+{
+  if ( ! ca_is_scalar(cs) && cs->elements != ca->elements ) {
+    rb_raise(rb_eArgError,
+             "%s: mask source has %lld elements, the receiver %lld",
+             ca_calling_method_name(),
+             (long long) cs->elements, (long long) ca->elements);
+  }
+}
+
 /* @overload inherit_mask (*others):
 
 (Masking, Destructive)
@@ -1895,6 +1907,7 @@ rb_ca_inherit_mask_method (int argc, VALUE *argv, VALUE self)
   for (i=0; i<argc; i++) {
     if ( rb_obj_is_carray(argv[i]) ) {
       TypedData_Get_Struct(argv[i], CArray, &carray_data_type, cs);
+      ca_inherit_mask_check_source(ca, cs);
       slist[i] = cs;
     }
     else {
@@ -1938,6 +1951,7 @@ rb_ca_inherit_mask (VALUE self, int n, ...)
     other = va_arg(rothers, VALUE);
     if ( rb_obj_is_carray(other) ) {
       TypedData_Get_Struct(other, CArray, &carray_data_type, cs);
+      ca_inherit_mask_check_source(ca, cs);
       slist[i] = cs;
     }
     else {
@@ -1976,6 +1990,7 @@ rb_ca_inherit_mask_replace_method (int argc, VALUE *argv, VALUE self)
   for (i=0; i<argc; i++) {
     if ( rb_obj_is_carray(argv[i]) ) {
       TypedData_Get_Struct(argv[i], CArray, &carray_data_type, cs);
+      ca_inherit_mask_check_source(ca, cs);
       slist[i] = cs;
     }
     else {
@@ -2019,6 +2034,7 @@ rb_ca_inherit_mask_replace (VALUE self, int n, ...)
     other = va_arg(rothers, VALUE);
     if ( rb_obj_is_carray(other) ) {
       TypedData_Get_Struct(other, CArray, &carray_data_type, cs);
+      ca_inherit_mask_check_source(ca, cs);
       slist[i] = cs;
     }
     else {
@@ -2266,11 +2282,9 @@ ca_binop_bit_or_i_boolean8_fast (ca_size_t n, boolean8_t *m,
        accumulating; here we need 3-arg). */
     ca_size_t       nw = n / CA_MASK_WORD_BYTES;
     ca_size_t       j;
-    uint64_t       *wd = (uint64_t *)       q3;
-    const uint64_t *wa = (const uint64_t *) q1;
-    const uint64_t *wb = (const uint64_t *) q2;
     for (j = 0; j < nw; j++) {
-      wd[j] = wa[j] | wb[j];
+      ca_mask_word_store(q3 + j*CA_MASK_WORD_BYTES,
+                         ca_mask_word_load(q1 + j*CA_MASK_WORD_BYTES) | ca_mask_word_load(q2 + j*CA_MASK_WORD_BYTES));
     }
     for (j = nw * CA_MASK_WORD_BYTES; j < n; j++) {
       q3[j] = q1[j] | q2[j];

data/ext/carray_median_percentile.c

@@ -907,10 +907,10 @@ rb_ca_median_m_body (int argc, VALUE *argv, VALUE self)
     if ( n == 0 ) return mp_axis_all_masked(self, axis, keep_axis);
     /* mask / min_count / fill_value require the per-fiber select (each fiber
        has its own n_present); the plain partition path assumes a uniform n.
-       Switch      ca_fast_paths_enabled(): off, the per-fiber select. */
+       Switch      ca_fast_path(CA_SC_MEDIAN_PARTITION): off, the per-fiber select. */
     VALUE res;
     if ( RTEST(rb_ca_has_mask(self)) || min_count > 0 || !NIL_P(fill_value)
-         || ! ca_fast_paths_enabled() )
+         || ! ca_fast_path(CA_SC_MEDIAN_PARTITION) )
       res = is_obj
         ? median_object_axis_masked(self, axis, min_count, fill_value, keep_axis)
         : median_axis_masked(self, axis, min_count, fill_value, keep_axis);
@@ -1364,9 +1364,9 @@ rb_ca_percentile_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
     /* mask / min_count / fill_value require the per-fiber select (each fiber
        has its own n_present); the plain partition/sort path assumes a
        uniform n.  These paths bake keep_axis into the reduced output.
-       Switch      ca_fast_paths_enabled(): off, the per-fiber select. */
+       Switch      ca_fast_path(CA_SC_PERCENTILE_PARTITION): off, the per-fiber select. */
     int per_fiber = RTEST(rb_ca_has_mask(self)) || min_count > 0
-                    || !NIL_P(fill_value) || ! ca_fast_paths_enabled();
+                    || !NIL_P(fill_value) || ! ca_fast_path(CA_SC_PERCENTILE_PARTITION);
     if ( !is_obj ) {
       result = per_fiber
         ? pct_axis_masked(self, pers, axis, method, min_count, fill_value, keep_axis)

data/ext/carray_memory_view.c

@@ -202,7 +202,9 @@ ca_mv_record_member_spec (VALUE info, char *out, size_t outlen,
    a member it has no item for (see above), or members that overlap or come
    out of offset order (a union).
 
-   The result is frozen and cached on the data_class.  It is an ordinary
+   The result is frozen and cached on the data_class.  Only the main Ractor
+   may set an instance variable on a class, so another Ractor builds the
+   format each time until the main one has cached it.  It is an ordinary
    String that compaction can move, so a view takes a copy of its bytes
    rather than its pointer (ca_mv_get). */
 static VALUE
@@ -245,11 +247,11 @@ ca_mv_struct_format_for_data_class (VALUE data_class)
   }
 
   rb_obj_freeze(buf);
-  rb_ivar_set(data_class, iv, buf);
+  if (ca_in_main_ractor()) rb_ivar_set(data_class, iv, buf);
   return buf;
 
 unsupported:
-  rb_ivar_set(data_class, iv, Qfalse);
+  if (ca_in_main_ractor()) rb_ivar_set(data_class, iv, Qfalse);
   return Qnil;
 }
 
@@ -900,7 +902,7 @@ ca_mv_release (VALUE obj, rb_memory_view_t *view)
 }
 
 /* ---------------- importer ----------------
-   Two-tier API mirroring numo-narray-memoryview:
+   Two-tier API:
 
      CArray.from_memory_view(obj)  -> CArray  (copy, independent buffer)
      CArray.wrap_memory_view(obj)  -> CAWrap  (zero-copy, shared memory)
@@ -1410,7 +1412,7 @@ ca_mv_wrap_body (VALUE arg)
                            a->target_class);
   rb_ivar_set(wrap, rb_intern("memory_view_source"), a->obj);
   rb_ivar_set(wrap, rb_intern("memory_view_holder"), a->data_holder_obj);
-  ca_mv_extract(wrap, &ca);
+  GetCArray(wrap, ca);
   if ( v->readonly ) {
     ca_set_flag(ca, CA_FLAG_READ_ONLY);
   }
@@ -1527,7 +1529,7 @@ ca_mv_from_body (VALUE arg)
 
   result = rb_carray_new(data_type, d->ndim, d->dim,
                          ca_mv_carray_bytes_for(data_type, v->item_size), NULL);
-  ca_mv_extract(result, &ca);
+  GetCArray(result, ca);
 
   if ( d->contiguous ) {
     memcpy(ca->ptr, v->data, (size_t) ca_length(ca));
@@ -1621,9 +1623,13 @@ rb_ca_s_memory_view_reject_reason (VALUE klass, VALUE obj)
                              "producer cannot express yet (nested struct, "
                              "CArray template, :fixlen, or :object)");
     }
-    return rb_sprintf("element data_type (%d) is not exportable via memory_view "
-                      "(CA_FIXLEN without data_class / CA_OBJECT)",
-                      ca->data_type);
+    if (ca->data_type == CA_OBJECT) {
+      return rb_str_new_cstr("an object array holds Ruby objects, not bytes "
+                             "a consumer can read; convert it with to_type "
+                             "first");
+    }
+    return rb_sprintf("data_type %s has no MemoryView format",
+                      ca_type_name[ca->data_type]);
   }
   if (ca_has_mask(ca)) {
     return rb_str_new_cstr("array has a mask; use arr.value (mask-ignoring CARefer) "