carray 3.0.5 → 3.0.6

data/ext/ca_obj_monop.c

@@ -453,8 +453,9 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
 /* Evaluate (GET) or write (PUT, writable views only) the cells a request
    names; `data` holds them packed. */
 static void
-ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
+ca_monop_eval_cells (void *node, const ca_lazy_req_t *req, void *data, int dir)
 {
+  CAMonOp *mo = (CAMonOp *) node;
   uint16_t op_chain[CA_MAX_LAZY_DEPTH];
   int chain_len = 0;
   CArray  *leaf;
@@ -641,6 +642,26 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
   }
 }
 
+/* A chain is evaluated from its leaf without evaluating the nodes under
+   the top one, so those nodes are recorded with it: a cell that holds an
+   expression over one of them is caught when it comes back, before a
+   longer chain over the same cells is built. */
+static void
+ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
+{
+  CArray *chain[CA_MAX_LAZY_DEPTH];
+  CArray *leaf = mo->parent;
+  int     nchain = 0;
+  while ( nchain < CA_MAX_LAZY_DEPTH &&
+          ( leaf->obj_type == CA_OBJ_MONOP ||
+            leaf->obj_type == CA_OBJ_LAZY_MARKER ) ) {
+    chain[nchain++] = leaf;
+    leaf = ((CAView *) leaf)->parent;
+  }
+  ca_lazy_eval_recorded(mo, 1, &leaf, nchain, chain, ca_monop_eval_cells,
+                        req, data, dir);
+}
+
 static void
 ca_monop_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                            ca_size_t *strides, void *data, int dir)
@@ -776,7 +797,7 @@ ca_monop_func_sync (void *ap)
     if ( ca->mask ) {
       ca_cast_block_with_mask(ca->elements, ca, ca->ptr,
                               ca->parent, ca->parent->ptr,
-                              (boolean8_t *) ca->parent->mask->ptr);
+                              (boolean8_t *) ca->mask->ptr);
     }
     else {
       ca_cast_block(ca->elements, ca, ca->ptr, ca->parent, ca->parent->ptr);
@@ -790,7 +811,9 @@ ca_monop_func_sync (void *ap)
     ca_byte_swap_buffer(ca->data_type, ca->bytes, ca->elements,
                         ca->parent->ptr);
   }
+  ca_view_pass_mask_to_parent(ca);
   ca_sync(ca->parent);
+  ca_view_sync_mask_after_parent(ca);
 }
 
 static void
@@ -847,6 +870,21 @@ ca_monop_func_create_mask (void *ap)
   }
 }
 
+/* For a writable cast: 1 and the data type it writes its parent in.  0 for
+   any other array. */
+int
+ca_monop_writable_cast_target (CArray *ca, int8_t *target)
+{
+  CAMonOp *mo = (CAMonOp *) ca;
+  if ( ca->obj_type != CA_OBJ_MONOP
+       || ! ca_monop_is_writable_view(mo->op_id)
+       || ! ca_monop_is_cast(mo->op_id) ) {
+    return 0;
+  }
+  *target = mo->parent->data_type;
+  return 1;
+}
+
 ca_operation_function_t ca_monop_func = {
   -1, /* CA_OBJ_MONOP, set at install time */
   CA_VIEW_ARRAY,

data/ext/ca_obj_object.c

@@ -249,7 +249,7 @@ ca_object_lend_restore (VALUE varg)
   return Qnil;
 }
 
-static void
+static VALUE
 ca_object_call_lending (CAObject *ca, void *ptr, const char *mid)
 {
   ca_object_lend_t l;
@@ -272,7 +272,7 @@ ca_object_call_lending (CAObject *ca, void *ptr, const char *mid)
   data->ptr = (char *) ptr;
   rb_ensure(ca_object_lend_body, (VALUE) &l,
             ca_object_lend_restore, (VALUE) &l);
-  RB_GC_GUARD(l.wrap);
+  return l.wrap;
 }
 
 /* Calls recv.mid(*argv), where some of argv are transient wraps of a
@@ -889,11 +889,10 @@ ca_object_mask_bytes (CAObject *ca)
   return (boolean8_t *) ca->mask->ptr;
 }
 
-/* Whether the mask of this object comes from its mask_* hooks.  Then a
-   fetched value says nothing about the mask: a cell the hooks mask stays
-   masked when its value is read, and only a fetcher answering UNDEF marks
-   one.  Without hooks the mask is what the fetches have answered, so a
-   value fetched clears the cell. */
+/* Whether the mask of this object comes from its mask_* hooks.  A fetched
+   value says nothing about the mask either way: a cell masked -- by the
+   hooks, or without hooks by a write of UNDEF or `mask =` -- stays masked
+   when its value is read, and only a fetcher answering UNDEF marks one. */
 static int
 ca_object_mask_from_hooks (CAObject *ca)
 {
@@ -922,9 +921,6 @@ ca_object_xfer_addr_one (CAObject *ca, ca_size_t addr, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[addr] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -944,9 +940,6 @@ ca_object_xfer_addr_one (CAObject *ca, ca_size_t addr, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[ca_index2addr(ca->mask, idx)] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -990,9 +983,6 @@ ca_object_xfer_index_one (CAObject *ca, ca_size_t *idx, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[ca_index2addr(ca->mask, idx)] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -1008,9 +998,6 @@ ca_object_xfer_index_one (CAObject *ca, ca_size_t *idx, void *ptr, int dir)
         }
       }
       else {
-        if ( ! ca_object_mask_from_hooks(ca) && ca_has_mask(ca) ) {
-          ca_object_mask_bytes(ca)[addr] = 0;
-        }
         rb_ca_obj2ptr(ca->self, rval, ptr);
       }
     }
@@ -1094,6 +1081,34 @@ ca_object_copy_bare_restore (VALUE arg)
   return Qnil;
 }
 
+/* copy_data of an object with no mask yet: an UNDEF the call writes lands
+   on a mask of the wrap's own, which the wrap takes away with it.  The
+   cells it marks are masked on the object, as a fetcher answering UNDEF
+   masks its cell, so a bulk read and a cell read give the same answer. */
+static void
+ca_object_adopt_undef_cells (CAObject *ca, VALUE wrap)
+{
+  CArray *wm = ((CArray *) DATA_PTR(wrap))->mask;
+  boolean8_t *bits;
+  ca_size_t i, n;
+  if ( wm == NULL || wm->ptr == NULL ) {
+    return;
+  }
+  n = ( wm->elements < ca->elements ) ? wm->elements : ca->elements;
+  for ( i = 0; i < n && ! wm->ptr[i]; i++ ) {
+    ;
+  }
+  if ( i == n ) {
+    return;
+  }
+  ca_create_mask(ca);
+  bits = ca_object_mask_bytes(ca);
+  for ( ; i < n; i++ ) {
+    if ( wm->ptr[i] ) bits[i] = 1;
+  }
+  RB_GC_GUARD(wrap);
+}
+
 static void
 ca_object_dispatch_copy (CAObject *ca, void *ptr)
 {
@@ -1108,7 +1123,26 @@ ca_object_dispatch_copy (CAObject *ca, void *ptr)
                 ca_object_copy_bare_restore, (VALUE) &c);
       return;
     }
-    ca_object_call_lending(ca, ptr, "copy_data");
+    if ( ca->data->mask != NULL ) {
+      /* Without hooks the mask is the object's own: a store of the values
+         into the array copy_data is handed (d[] = src) would clear it, so
+         the cells it held masked are masked again after the call, beside
+         those the call marks. */
+      CArray *m = ca->data->mask;
+      volatile VALUE vkept = rb_str_new(m->ptr, (long) m->elements);
+      const char *kept;
+      ca_size_t i;
+      ca_object_call_lending(ca, ptr, "copy_data");
+      kept = RSTRING_PTR(vkept);
+      m = ca->data->mask;
+      for ( i = 0; m != NULL && i < m->elements; i++ ) {
+        if ( kept[i] ) m->ptr[i] = 1;
+      }
+      RB_GC_GUARD(vkept);
+      return;
+    }
+    ca_object_adopt_undef_cells(ca,
+                                ca_object_call_lending(ca, ptr, "copy_data"));
   }
   else {
     ca_size_t addr;

data/ext/ca_obj_reduce.c

@@ -127,7 +127,11 @@ ca_reduce_func_clone (void *ap)
 /* addr-list logic lives in xfer_addrs: GET = OR-reduce `count` adjacent parent
    bytes per addr; PUT = broadcast the value to all `count` parent cells.
    fetch_addr/store_addr forward (n==1), xfer_index = index2addr then xfer_addrs.
-   All forward to a single home; the legacy slots are removed at step 5. */
+
+   A true PUT onto a cell that already reads true leaves the parent cells
+   as they are.  Every sync of a view over a CAReduce sends back its cells,
+   changed or not; broadcasting an unchanged true would mask the parent
+   cells under it that were not masked. */
 static void
 ca_reduce_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
                            void *data, int dir)
@@ -147,6 +151,16 @@ ca_reduce_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
       *(char*)cell = v;
     }
     else {
+      if ( *(char *) cell ) {
+        char q, v = 0;
+        for (i=0; i<ca->count; i++) {
+          ca_fetch_addr(ca->parent, addr*ca->count + i + ca->offset, &q);
+          if ( q ) { v = 1; break; }
+        }
+        if ( v ) {
+          continue;
+        }
+      }
       for (i=0; i<ca->count; i++) {
         ca_store_addr(ca->parent, addr*ca->count + i + ca->offset, cell);
       }

data/ext/ca_obj_refer.c

@@ -16,6 +16,7 @@
 #include "carray.h"
 #include "carray_internal.h"   /* per-obj_type view constructors */
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE for CARecord parent */
+#include "ruby/thread_native.h"
 
 extern ca_operation_function_t ca_stride_func;
 
@@ -145,9 +146,10 @@ ca_refer_setup (CARefer *ca, CArray *parent,
   ca_stride_setup_view((CAStride *) ca, CA_OBJ_REFER, parent,
                        data_type, bytes, ndim, dim, strides, base_offset);
 
-  /* A refer of a scalar stays one only while it has the one cell: read as
-     narrower elements it is an array of several. */
-  if (ca_is_scalar(parent) && ca->elements == 1) {
+  /* A refer of a scalar stays one only while it is one cell along one
+     axis, as a scalar is: read as narrower elements it is an array of
+     several, and read under another shape it is an array of that shape. */
+  if (ca_is_scalar(parent) && ca->elements == 1 && ca->ndim == 1) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
   return 0;
@@ -336,6 +338,59 @@ ca_keep_chain_flags (CArray *view, CArray *src)
   }
 }
 
+/* The sources of folded views (CA_FLAG_FOLDED), keyed by the view.  Views are
+   made and freed in any Ractor, so the table is taken under a lock. */
+static st_table *ca_fold_sources;
+static rb_nativethread_lock_t ca_fold_lock;
+
+void
+ca_fold_note_source (CArray *view, CArray *src)
+{
+  rb_native_mutex_lock(&ca_fold_lock);
+  st_insert(ca_fold_sources, (st_data_t) view, (st_data_t) src);
+  rb_native_mutex_unlock(&ca_fold_lock);
+  ca_set_flag(view, CA_FLAG_FOLDED);
+}
+
+CArray *
+ca_fold_source (CArray *view)
+{
+  st_data_t src = 0;
+  rb_native_mutex_lock(&ca_fold_lock);
+  st_lookup(ca_fold_sources, (st_data_t) view, &src);
+  rb_native_mutex_unlock(&ca_fold_lock);
+  return (CArray *) src;
+}
+
+void
+ca_fold_forget (CArray *view)
+{
+  st_data_t key = (st_data_t) view;
+  rb_native_mutex_lock(&ca_fold_lock);
+  st_delete(ca_fold_sources, &key, NULL);
+  rb_native_mutex_unlock(&ca_fold_lock);
+}
+
+/* Builds the folded view of `ca` for reshape / flatten: a CAStride over
+   `root`.  When `ca` is not `root` itself, it is recorded as the view's
+   source. */
+static VALUE
+ca_reshape_folded (VALUE self, CArray *ca, CArray *root, int8_t ndim,
+                   ca_size_t *dim, ca_size_t *strides, ca_size_t base)
+{
+  volatile VALUE obj;
+  CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, root, ca->data_type, ca->bytes,
+                               ndim, dim, strides, base);
+  ca_keep_chain_flags((CArray *) cs, ca);
+  obj = ca_wrap_struct(cs);
+  rb_ca_set_parent(obj, self);
+  if ( root != ca ) {
+    ca_fold_note_source((CArray *) cs, ca);
+  }
+  CA_WRAPPER_LIFT(obj, self, ca);
+  return obj;
+}
+
 static int
 ca_reshape_try_strides (CArray *parent,
                         const ca_size_t *new_dim,
@@ -721,15 +776,8 @@ rb_ca_reshape (int argc, VALUE *argv, VALUE self)
     ca_size_t out_base;
     if (ca_reshape_try_strides(ca, new_dim, (int8_t) argc,
                                &out_root, out_strides, &out_base)) {
-      CAStride *cs = ca_stride_new(CA_OBJ_STRIDE, out_root,
-                                   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);
-      return obj;
+      return ca_reshape_folded(self, ca, out_root, (int8_t) argc, new_dim,
+                               out_strides, out_base);
     }
   }
 
@@ -760,14 +808,8 @@ rb_ca_flatten (VALUE self)
     ca_size_t out_strides[1];
     ca_size_t out_base;
     if (ca_reshape_try_strides(ca, dim, 1, &out_root, out_strides, &out_base)) {
-      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);
-      return obj;
+      return ca_reshape_folded(self, ca, out_root, 1, dim,
+                               out_strides, out_base);
     }
   }
 
@@ -847,6 +889,9 @@ Init_ca_obj_refer (void)
   /* rb_cCARefer, CA_OBJ_REFER are defined in ruby_carray.c /
      carray_core.c.  Build the custom op table and override the
      baseline registration installed by Init_carray_core. */
+  ca_fold_sources = st_init_numtable();
+  rb_native_mutex_initialize(&ca_fold_lock);
+
   ca_refer_func = ca_stride_func;
   ca_refer_func.free_object = free_ca_refer;
   ca_refer_func.clone       = ca_refer_func_clone;

data/ext/ca_obj_remap.c

@@ -304,8 +304,9 @@ ca_remap_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
 
   paddrs = ALLOCV_N(ca_size_t, holder, n);
   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
+  /* idx is read-only once the view holds it, but its values are still
+     checked on every transfer (the private without_read_only_flag can
+     lift the flag): 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);
@@ -366,9 +367,19 @@ ca_remap_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   ALLOCV_END(holder);
 }
 
-/* xfer_all: whole-view delivery.  Sequential view-flat addresses
-   [0..elements) routed through xfer_addrs -- one ALLOCV for the addr
-   list, then two batched ca_xfer_addrs calls inside xfer_addrs.
+/* xfer_all: whole-view delivery.  The whole view reads every cell of idx
+   in order, so when idx holds its cells in memory those cells are the
+   parent addresses: they are checked in one pass, a negative one counting
+   from the end of the parent.
+
+   idx itself is handed to the parent only when the parent holds its cells
+   in memory and shares no root with idx: that transfer is a plain copy, so
+   no Ruby runs while the parent reads the list and a scatter cannot
+   rewrite it.  Any other parent (a view, a CAObject whose hooks run Ruby)
+   gets a copy of the addresses taken in the checking pass, so nothing it
+   does can change an address after it was checked, or change idx.
+   Without idx in memory, the sequential view-flat addresses [0..elements)
+   go through xfer_addrs.
 
    No ca_attach(parent) / ca_attach(idx). */
 static void
@@ -382,6 +393,46 @@ ca_remap_func_xfer_all (void *ap, void *data, int dir)
 
   if ( n == 0 ) return;
 
+  if ( ca->idx->ptr ) {
+    ca_size_t *iaddrs = (ca_size_t *) ca->idx->ptr;
+    ca_size_t  pn = ca->parent->elements;
+    ca_size_t *paddrs;
+
+    if ( ca->parent->ptr && ! ca_shares_root(ca->parent, ca->idx) ) {
+      int lendable = 1;
+      for ( i = 0; i < n; i++ ) {
+        ca_size_t a = iaddrs[i];
+        if ( a < 0 ) {
+          lendable = 0;
+          a += pn;
+        }
+        if ( a < 0 || a >= pn ) {
+          ca_index_out_of_range(iaddrs[i], pn, "index");
+        }
+      }
+      if ( lendable ) {
+        ca_xfer_addrs(ca->parent, n, iaddrs, data, dir);
+        return;
+      }
+    }
+
+    paddrs = ALLOCV_N(ca_size_t, holder, n);
+    for ( i = 0; i < n; i++ ) {
+      ca_size_t a = iaddrs[i];
+      if ( a < 0 ) {
+        a += pn;
+      }
+      if ( a < 0 || a >= pn ) {
+        ALLOCV_END(holder);
+        ca_index_out_of_range(iaddrs[i], pn, "index");
+      }
+      paddrs[i] = a;
+    }
+    ca_xfer_addrs(ca->parent, n, paddrs, data, dir);
+    ALLOCV_END(holder);
+    return;
+  }
+
   vaddrs = ALLOCV_N(ca_size_t, holder, n);
   for ( i = 0; i < n; i++ ) vaddrs[i] = i;
   ca_remap_func_xfer_addrs(ca, n, vaddrs, data, dir);
@@ -417,7 +468,13 @@ ca_operation_function_t ca_remap_func = {
    carray_partition.c).  Callers are expected to have already checked the
    routing preconditions (same shape, idx data_type == CA_SIZE);
    ca_remap_setup raises ArgumentError on mismatch as a defensive
-   fallback. */
+   fallback.
+
+   The view takes rmapper over: every caller hands a fresh array no one
+   else holds, and it is marked read-only here, so the mapping a view was
+   made with cannot be rewritten through #mapper.  CAGrid and CASelect
+   keep their indices where Ruby cannot reach them; this is the same
+   promise for an index array that stays visible. */
 VALUE
 rb_ca_remap_new (VALUE cary, VALUE rmapper)
 {
@@ -437,13 +494,14 @@ rb_ca_remap_new (VALUE cary, VALUE rmapper)
      covers the view's.  ca->idx is a raw pointer into idx's struct;
      keeping rmapper reachable through the view keeps it alive. */
   rb_ivar_set(obj, rb_intern("remap_idx"), rmapper);
+  rb_ca_set_read_only_flag(rmapper);
   return obj;
 }
 
-/* Read-only accessor for the per-cell index CArray that defines this
-   CARemap's mapping: the array the view reads.  For ca[mapper] it is a
-   copy of mapper taken at the call, so a later change to mapper does
-   not reach the view.  Companion to
+/* Accessor for the per-cell index CArray that defines this CARemap's
+   mapping: the array the view reads, itself read-only.  For ca[mapper]
+   it is a copy of mapper taken at the call, so a later change to mapper
+   does not reach the view.  Companion to
    CABlock#start / CAStride#strides / CAWindow#count etc. — the view
    hierarchy is preserved so each named view class exposes its own
    defining semantic state. */
@@ -526,6 +584,7 @@ Init_ca_obj_remap (void)
                                      rb_cCARemapMask,
                                      &caremap_mask_data_type,
                                      &ca_remap_func, sizeof(ca_remap_func));
+  ca_register_cell_moving_view(CA_OBJ_REMAP);
 
   /* Defining semantic state accessor — companion to CABlock#start /
      CAStride#strides / CAWindow#count.  The hierarchy-preserving

data/ext/ca_obj_roll.c

@@ -733,6 +733,7 @@ Init_ca_obj_roll (void)
                                     &caroll_data_type,
                                     rb_cCARollMask,
                                     &caroll_mask_data_type, &ca_roll_func, sizeof(ca_roll_func));
+  ca_register_cell_moving_view(CA_OBJ_ROLL);
   rb_define_const(rb_cObject, "CA_OBJ_ROLL", INT2NUM(CA_OBJ_ROLL));
 
   rb_define_method(rb_cCArray, "roll", rb_ca_roll, -1);

data/ext/ca_obj_select.c

@@ -205,7 +205,9 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  if ( ca_is_scalar(snapshot) ) {
+  /* A selection of a scalar is one only while it picks the cell: a scalar
+     is one cell along one axis. */
+  if ( ca_is_scalar(snapshot) && ca->elements == 1 ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
 
@@ -668,6 +670,7 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
 void
 Init_ca_obj_select (void)
 {
+  ca_register_cell_moving_view(CA_OBJ_SELECT);
   /* rb_cCASelect and CA_OBJ_SELECT are defined in ruby_carray.c;
      this file only registers the constant + allocator. */
   rb_define_const(rb_cObject, "CA_OBJ_SELECT", INT2NUM(CA_OBJ_SELECT));

data/ext/ca_obj_select_axis.c

@@ -1238,6 +1238,7 @@ Init_ca_obj_select_axis (void)
                                            rb_cCASelectAxisMask,
                                            &caselectaxis_mask_data_type,
                                            &ca_select_axis_func, sizeof(ca_select_axis_func));
+  ca_register_cell_moving_view(CA_OBJ_SELECT_AXIS);
   rb_define_const(rb_cObject, "CA_OBJ_SELECT_AXIS", INT2NUM(CA_OBJ_SELECT_AXIS));
 
   rb_define_alloc_func(rb_cCASelectAxis, rb_ca_select_axis_s_allocate);

data/ext/ca_obj_shift.c

@@ -363,6 +363,7 @@ Init_ca_obj_shift (void)
                                      &cashift_data_type,
                                      rb_cCAShiftMask,
                                      &cashift_mask_data_type, &ca_shift_func, sizeof(ca_shift_func));
+  ca_register_cell_moving_view(CA_OBJ_SHIFT);
   rb_define_const(rb_cObject, "CA_OBJ_SHIFT", INT2NUM(CA_OBJ_SHIFT));
 
   rb_define_method(rb_cCArray, "shift", rb_ca_shift, -1);