carray 3.0.3 → 3.0.5

data/ext/carray_mask.c

@@ -37,16 +37,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 +78,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 +96,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 +111,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 +126,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 +143,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;
@@ -423,85 +431,221 @@ ca_create_mask_attach (VALUE arg)
 }
 
 CArray *
-ca_multi_parent_mask (CArray *p, CArray **standin)
+ca_mask_standin_new (CArray *parent)
 {
-  *standin = NULL;
-  if ( ! ca_has_mask(p) ) {
-    CArray *z = carray_new(CA_BOOLEAN, p->ndim, p->dim, 0, NULL);
-    MEMZERO(z->ptr, boolean8_t, z->elements);
-    if ( ca_is_readonly(p) ) {
-      ca_set_flag(z, CA_FLAG_READ_ONLY);
-    }
-    *standin = z;
-    return z;
+  CArray *z = carray_new(CA_BOOLEAN, parent->ndim, parent->dim, 0, NULL);
+  MEMZERO(z->ptr, boolean8_t, z->elements);
+  if ( ca_is_readonly(parent) ) {
+    ca_set_flag(z, CA_FLAG_READ_ONLY);
   }
-  ca_create_mask(p);
-  return p->mask;
+  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_multi_parent_mask_unmaskable (CArray *p)
+ca_mask_standin_parent_unmaskable (CArray *parent)
+{
+  return ca_is_value_array(parent) || ca_is_mask_array(parent);
+}
+
+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) ) {
+    return reading;
+  }
+  /* Not inside an attach window whose buffer is out: that buffer and the
+     detach to come are those of the stand-in.  The attach and allocate
+     slots run before the buffer is published, and may still give way. */
+  if ( CAVIEW(mask_view)->attach > 0 && mask_view->ptr != NULL ) {
+    return reading;
+  }
+  /* A read-only parent (a lazy expression, a broadcast) is never given a
+     mask by a write, but can still have one later through its operand or
+     root. */
+  if ( ! ca_has_mask(parent) ) {
+    return reading;
+  }
+  ca_create_mask(parent);
+  return ( parent->mask != NULL ) ? parent->mask : reading;
+}
+
+void
+ca_mask_standin_settle (CArray *parent, CArray *standin)
+{
+  volatile VALUE holder = 0;
+  boolean8_t    *z, one = 1;
+  ca_size_t     *addrs;
+  ca_size_t      i, m = 0, n;
+
+  if ( standin == NULL || ca_test_flag(standin, CA_FLAG_READ_ONLY) ) {
+    return;
+  }
+  z = (boolean8_t *) standin->ptr;
+  n = standin->elements;
+  for ( i = 0; i < n && ! z[i]; i++ ) ;
+  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. */
+  addrs = ALLOCV_N(ca_size_t, holder, n);
+  for ( ; i < n; i++ ) {
+    if ( z[i] ) {
+      addrs[m++] = i;
+    }
+  }
+  ca_fill_addrs(parent->mask, m, addrs, &one);
+  ALLOCV_END(holder);
+  MEMZERO(z, boolean8_t, n);
+}
+
+CArray *
+ca_multi_parent_mask (CArray *p, CArray **standin)
 {
-  return ca_is_value_array(p) || ca_is_mask_array(p);
+  *standin = NULL;
+  if ( ! ca_has_mask(p) ) {
+    *standin = ca_mask_standin_new(p);
+    return *standin;
+  }
+  ca_create_mask(p);
+  return p->mask;
 }
 
 void
 ca_multi_parent_mask_refresh (CArray *mask, CArray **parents,
-                              CArray **standins, int32_t n, int for_write)
+                              CArray **standins, int32_t n)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
   int32_t k;
-  /* Not inside an attach window: its buffer and its detach are those of
-     the parents it was opened with.  The attach and allocate slots run
-     before the buffer is published, and replace the stand-ins then. */
-  if ( standins == NULL || ( CAVIEW(mask)->attach > 0 && mask->ptr != NULL ) ) {
+  if ( standins == NULL ) {
     return;
   }
   /* A replaced stand-in stays allocated until the view is freed: a copy
      of the mask (dup) may still point at it. */
   for ( k = 0; k < n; k++ ) {
-    CArray *z = standins[k];
-    if ( z == NULL || mp->parents[k] != z
-         || ca_test_flag(z, CA_FLAG_READ_ONLY)
-         || ca_multi_parent_mask_unmaskable(parents[k]) ) {
-      continue;
-    }
-    if ( ! ( for_write || ca_has_mask(parents[k]) ) ) {
-      continue;
-    }
-    ca_create_mask(parents[k]);
-    mp->parents[k] = parents[k]->mask;
-    if ( k == 0 ) {
-      CAVIEW(mask)->parent = parents[k]->mask;
-    }
+    mp->parents[k] = ca_mask_standin_current(mask, mp->parents[k], parents[k],
+                                             standins[k]);
+  }
+  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;
+}
+
 void
-ca_multi_parent_mask_check (CArray *mask, CArray **parents,
-                            CArray **standins, int32_t n)
+ca_multi_parent_mask_refuse_first (CArray *mask, CArray **parents,
+                                   CArray **standins, int32_t n,
+                                   VALUE (*body)(VALUE), VALUE arg)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
-  int32_t k;
+  volatile VALUE h_blank = 0, h_saved = 0;
+  ca_mp_trial_t t;
+  int32_t k, refused = -1;
   if ( standins == NULL ) {
     return;
   }
   for ( k = 0; k < n; k++ ) {
-    CArray    *z = standins[k];
+    if ( standins[k] != NULL && mp->parents[k] == standins[k]
+         && ca_mask_standin_parent_unmaskable(parents[k]) ) {
+      break;
+    }
+  }
+  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 ( z == NULL || mp->parents[k] != z
-         || ! ca_multi_parent_mask_unmaskable(parents[k]) ) {
+    if ( standins[k] == NULL || t.saved[k] != standins[k]
+         || ! ca_mask_standin_parent_unmaskable(parents[k]) ) {
       continue;
     }
     for ( i = 0; i < z->elements && ! ((boolean8_t *) z->ptr)[i]; i++ ) ;
-    if ( i == z->elements ) {
-      continue;
+    if ( i < z->elements ) {
+      refused = k;
     }
-    MEMZERO(z->ptr, boolean8_t, z->elements);
+  }
+  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[k]) ? "value" : "mask");
+             ca_is_value_array(parents[refused]) ? "value" : "mask");
   }
 }
 
@@ -510,26 +654,20 @@ ca_multi_parent_mask_settle (CArray *mask, CArray **parents,
                              CArray **standins, int32_t n)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
-  int32_t k;
+  int32_t k, pass;
   if ( standins == NULL ) {
     return;
   }
-  ca_multi_parent_mask_check(mask, parents, standins, n);
-  for ( k = 0; k < n; k++ ) {
-    CArray    *z = standins[k];
-    ca_size_t  i;
-    if ( z == NULL || mp->parents[k] != z
-         || ca_test_flag(z, CA_FLAG_READ_ONLY)
-         || ca_multi_parent_mask_unmaskable(parents[k]) ) {
-      continue;
-    }
-    for ( i = 0; i < z->elements && ! ((boolean8_t *) z->ptr)[i]; i++ ) ;
-    if ( i == z->elements ) {
-      continue;
+  /* 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;
+      }
+      ca_mask_standin_settle(parents[k], standins[k]);
     }
-    ca_create_mask(parents[k]);
-    ca_xfer_all(parents[k]->mask, z->ptr, CA_XFER_PUT);
-    MEMZERO(z->ptr, boolean8_t, z->elements);
   }
 }
 
@@ -553,6 +691,10 @@ ca_create_mask (void *ap)
   }
 
   ca_func[ca->obj_type].create_mask(ca);
+  if ( ! ca->mask ) {
+    /* a lazy expression with no masked operand has no mask to make */
+    return;
+  }
   ca_set_flag(ca->mask, CA_FLAG_MASK_ARRAY); /* set array as mask array */
   if ( ca_is_view(ca) ) {
     if ( CAVIEW(ca)->attach ) {
@@ -561,6 +703,7 @@ ca_create_mask (void *ap)
          then comes off again, since the view's sync and detach would
          find it attached to nothing. */
       int tag = 0;
+      /* protect: the mask comes off its view before it is freed */
       rb_protect(ca_create_mask_attach, (VALUE) ca->mask, &tag);
       if ( tag ) {
         CArray *mask = ca->mask;
@@ -606,6 +749,13 @@ ca_setup_mask (void *ap, CArray *mask)
 {
   CArray *ca = (CArray *) ap;
 
+  if ( mask ) {
+    if ( ! ca_is_boolean_type(mask) ) {
+      rb_raise(rb_eCADataTypeError, "a mask is a boolean array");
+    }
+    ca_check_same_elements(ca, mask);
+  }
+
   ca_update_mask(ca);
 
   if ( mask ) {
@@ -685,6 +835,21 @@ ca_copy_mask_overlay_core (CArray *ca, ca_size_t elements, int n,
   char *modes;
   int i, some_has_mask = 0;
 
+  if ( elements > ca->elements ) {
+    elements = ca->elements;
+  }
+
+  /* An array source is read cell by cell over the destination's cells;
+     a scalar source's one cell applies to all of them. */
+  for (i=0; i<n; i++) {
+    cs = slist[i];
+    if ( cs && ! ca_is_scalar(cs) && cs->elements < elements ) {
+      rb_raise(rb_eArgError,
+               "mask source has %lld elements, fewer than the %lld of the destination",
+               (long long) cs->elements, (long long) elements);
+    }
+  }
+
   for (i=0; i<n; i++) {
     if ( slist[i] && ca_has_mask(slist[i]) ) {
       some_has_mask = 1;
@@ -703,10 +868,6 @@ ca_copy_mask_overlay_core (CArray *ca, ca_size_t elements, int n,
     return;
   }
 
-  if ( elements > ca->elements ) {
-    elements = ca->elements;
-  }
-
   o.list     = ALLOCA_N(CArray *, n + 1);
   o.snap     = ALLOCA_N(boolean8_t *, n);
   o.att      = ALLOCA_N(CArray *, n);
@@ -900,6 +1061,10 @@ ca_unmask (void *ap, char *fill_value)
 {
   CArray *ca = (CArray *) ap;
 
+  if ( ca_is_readonly(ca) ) {
+    ca_refuse_read_only();
+  }
+
   ca_update_mask(ca);
   if ( ca->mask ) {
     if ( ! fill_value ) {
@@ -1258,6 +1423,72 @@ rb_ca_mask_array (VALUE self)
   }
 }
 
+/* dup / clone of a mask.  The mask of a view is a view over its parent's
+   mask, and its dup, like the dup of any view, is another view onto the
+   same parent mask: it follows later changes and a write to it lands in
+   the parent's mask (copy makes a mask of its own).  A mask over a cast, a
+   byte swap, a Face or a lazy expression is shown as CArrayMask, whose
+   allocator makes an entity, so Object#dup would copy its cells; it is
+   rebuilt here from its own view instead.  The mask of an entity is an
+   entity and is copied. */
+static VALUE
+ca_mask_view_dup (VALUE self)
+{
+  volatile VALUE obj;
+  const rb_data_type_t *type;
+  CArray *ca, *cp;
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  cp = (CArray *) ca_func[ca->obj_type].clone(ca);
+  ca_keep_chain_flags(cp, ca);
+  type = ca_typeddata[ca->obj_type];
+  if ( type->function.dfree != ca_free ) {
+    type = &carray_data_type;     /* the copy is this object's to free */
+  }
+  obj = TypedData_Wrap_Struct(rb_obj_class(self), type, cp);
+  rb_ivar_set(obj, rb_intern("masked_array"),
+              rb_ivar_get(self, rb_intern("masked_array")));
+  return obj;
+}
+
+static VALUE
+rb_ca_mask_dup (VALUE self)
+{
+  CArray *ca;
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ! ca_is_view(ca) ) {
+    return rb_call_super(0, NULL);
+  }
+  return ca_mask_view_dup(self);
+}
+
+static VALUE
+rb_ca_mask_clone (int argc, VALUE *argv, VALUE self)
+{
+  VALUE opts = Qnil, vfreeze = Qnil;
+  volatile VALUE obj;
+  CArray *ca;
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ! ca_is_view(ca) ) {
+    return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
+  }
+  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 = ca_mask_view_dup(self);
+  if ( RTEST(vfreeze) || ( NIL_P(vfreeze) && OBJ_FROZEN(self) ) ) {
+    rb_obj_freeze(obj);
+  }
+  return obj;
+}
+
 /* @overload mask= (new_mask)
 
 (Mask, Modification) 
@@ -1491,14 +1722,9 @@ rb_ca_mask_fill (VALUE self, VALUE fval)
   return rb_ca_unmask_method(1, &fval, self);
 }
 
-/* @overload unmask_copy (fill_value = nil)
-
-(Masking, Conversion)
-Returns new unmasked array.
-If the optional argument <code>fill_value</code> is given,
-the masked elements are filled by <code>fill_value</code>.
-The returned array doesn't have the mask array.
-*/
+/* A copy without the mask: with a fill value, the masked cells hold it.
+   Behind rb_ca_unmask_copy / rb_ca_mask_fill_copy (C only; the Ruby
+   surface is strip_mask). */
 
 static VALUE
 rb_ca_unmask_copy_method (int argc, VALUE *argv, VALUE self)
@@ -1654,6 +1880,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)
@@ -1677,6 +1916,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 {
@@ -1720,6 +1960,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 {
@@ -1758,6 +1999,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 {
@@ -1801,6 +2043,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 {
@@ -2048,11 +2291,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];
@@ -2202,7 +2443,7 @@ rb_ca_inherit_mask_replace_ruby (int argc, VALUE *argv, VALUE self)
 void
 Init_carray_mask (void)
 {
-  rb_define_private_method(rb_cCArray, "__create_mask__", rb_ca_create_mask, 0);
+  rb_define_private_method(rb_cCArray, "add_mask", rb_ca_create_mask, 0);
   /*
   rb_define_private_method(rb_cCArray, "__update_mask__", rb_ca_update_mask, 0);
   */
@@ -2213,6 +2454,8 @@ Init_carray_mask (void)
 
   rb_define_method(rb_cCArray, "value",         rb_ca_value_array, 0);
   rb_define_method(rb_cCArray, "mask",          rb_ca_mask_array, 0);
+  rb_define_method(rb_cCArrayMask, "dup",   rb_ca_mask_dup,    0);
+  rb_define_method(rb_cCArrayMask, "clone", rb_ca_mask_clone, -1);
   rb_define_method(rb_cCArray, "mask=",         rb_ca_set_mask, 1);
   rb_define_method(rb_cCArray, "is_masked",     rb_ca_is_masked, 0);
   rb_define_method(rb_cCArray, "is_not_masked", rb_ca_is_not_masked, 0);