carray 3.0.2 → 3.0.4

data/ext/ca_obj_bitfield.c

@@ -12,6 +12,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 
 typedef struct {
   int16_t   obj_type;
@@ -32,6 +33,8 @@ typedef struct {
   ca_size_t   bit_offset;
   uint64_t  bit_mask;
   ca_size_t   bit_start;  /* original offset before endian adjustment */
+  ca_size_t   bit_length; /* width of the field in bits */
+  int8_t      sign_extend; /* the field is read as a signed integer */
 } CABitfield;
 
 static size_t
@@ -73,20 +76,6 @@ static int8_t CA_OBJ_BITFIELD;
 
 static VALUE rb_cCABitfield;
 
-static ca_size_t
-bitfield_bitlen (uint64_t bit_mask, ca_size_t bytes)
-{
-  ca_size_t bitsize = bytes * 8;
-  ca_size_t count = 0;
-  ca_size_t i;
-  for (i=0; i<bitsize; i++) {
-    if ( ( bit_mask >> i ) & 1 ) {
-      count++;
-    }
-  }
-  return count;
-}
-
 /* Generic per-cell fetch: load up to 8 bytes from src starting at
    byte_offset, mask with bit_mask, shift down by bit_offset, and
    write the low `dwrite` bytes of the result to dst.
@@ -100,8 +89,10 @@ static void
 bitfield_fetch(char *dst, ca_size_t dbytes,
                    char *src, ca_size_t sbytes,
                    ca_size_t byte_offset, ca_size_t bit_offset, uint64_t bit_mask,
+                   ca_size_t bit_length, int sign_extend,
                    ca_size_t elements)
 {
+  uint64_t sign = ( sign_extend && bit_length < 64 ) ? ( 1ULL << ( bit_length - 1 ) ) : 0;
   ca_size_t k;
   ca_size_t span = sbytes - byte_offset;
   if (span > 8) span = 8;
@@ -110,6 +101,9 @@ bitfield_fetch(char *dst, ca_size_t dbytes,
     uint64_t tmp = 0;
     memcpy(&tmp, src + k * sbytes + byte_offset, (size_t) span);
     uint64_t result = (tmp & bit_mask) >> bit_offset;
+    if ( result & sign ) {
+      result |= ~( ( sign << 1 ) - 1 );   /* the field's top bit is its sign */
+    }
     memcpy(dst + k * dbytes, &result, (size_t) dwrite);
   }
 }
@@ -142,12 +136,14 @@ bitfield_store(char *src, ca_size_t sbytes,
 
 /* ------------------------------------------------------------------- */
 
+/* `data_type` is the integer type the field is read as, or CA_NONE for
+   the narrowest unsigned type that holds it (boolean for one bit).  A
+   signed type reads the field's top bit as its sign. */
 int
 ca_bitfield_setup (CABitfield *ca, CArray *parent,
-                   ca_size_t offset, ca_size_t bitlen)
+                   ca_size_t offset, ca_size_t bitlen, int8_t data_type)
 {
   int8_t ndim;
-  int8_t data_type;
   ca_size_t bytes = 0, elements;
   ca_size_t bitsize;
   ca_size_t  byte_offset;
@@ -163,11 +159,37 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
     rb_raise(rb_eIndexError, "invalid bit length specified for bit field");
   }
 
-  if ( offset + bitlen -1 >= bitsize ) {
+  if ( offset < 0 || offset + bitlen -1 >= bitsize ) {
     rb_raise(rb_eIndexError, "invalid offset for bit field");
   }
 
-  if ( bitlen == 1 ) {
+  /* The bits of an object cell are a reference: writing them would leave
+     the cell pointing nowhere.  A complex cell is refused as bitarray
+     refuses it. */
+  if ( ca_is_object_type(parent) || ca_is_complex_type(parent) ) {
+    rb_raise(rb_eCADataTypeError, "invalid data_type for bitfield");
+  }
+
+  /* A field is read with one 8-byte load from the byte it starts in. */
+  if ( offset % 8 + bitlen > 64 ) {
+    rb_raise(rb_eIndexError,
+             "a bit field of %lld bits at bit %lld spans more than 8 bytes",
+             (long long) bitlen, (long long) offset);
+  }
+
+  if ( data_type != CA_NONE ) {
+    switch ( data_type ) {
+    case CA_BOOLEAN:
+    case CA_INT8:  case CA_UINT8:  case CA_INT16: case CA_UINT16:
+    case CA_INT32: case CA_UINT32: case CA_INT64: case CA_UINT64:
+      break;
+    default:
+      rb_raise(rb_eCADataTypeError,
+               "a bit field is read as an integer type, not <%s>",
+               ca_type_name[data_type]);
+    }
+  }
+  else if ( bitlen == 1 ) {
     data_type = CA_BOOLEAN;
   }
   else if ( bitlen <= 8 ) {
@@ -183,18 +205,20 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
     data_type = CA_UINT64;
   }
 
-  CA_CHECK_BYTES(data_type, bytes);
-
-  if ( bitlen > bytes * 8 ) {
-    rb_raise(rb_eArgError, "invalid bit length for specified data_type");
-  }
+  CA_CHECK_BYTES_GIVEN(data_type, bytes);
 
-  if ( ( data_type == CA_BOOLEAN ) && ( bitlen > 1 ) ) {
-    rb_raise(rb_eArgError, "invalid bit length for specified data_type");
+  if ( bitlen > bytes * 8 ||
+       ( ( data_type == CA_BOOLEAN ) && ( bitlen > 1 ) ) ) {
+    rb_raise(rb_eArgError, "a bit field of %lld bits does not fit <%s>",
+             (long long) bitlen, ca_type_name[data_type]);
   }
 
   if ( ca_endian == CA_BIG_ENDIAN ) {
-    byte_offset = parent->bytes - offset/8 - bytes;
+    /* The window is placed by the narrowest width that holds the field,
+       not by the type it is read as, which may be wider. */
+    ca_size_t window = ( bitlen <= 8 ) ? 1 : ( bitlen <= 16 ) ? 2 :
+                       ( bitlen <= 32 ) ? 4 : 8;
+    byte_offset = parent->bytes - offset/8 - window;
     bit_offset  = offset % 8;
     bit_mask    = 0;
     for (i=0; i<bitlen; i++) {
@@ -217,6 +241,12 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
     }
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_BITFIELD;
   ca->data_type = data_type;
   ca->flags     = 0;
@@ -237,21 +267,25 @@ ca_bitfield_setup (CABitfield *ca, CArray *parent,
   ca->bit_offset  = bit_offset;
   ca->bit_mask    = bit_mask;
   ca->bit_start   = offset;  /* preserve original offset for clone/copy */
+  ca->bit_length  = bitlen;
+  ca->sign_extend = ( data_type == CA_INT8  || data_type == CA_INT16 ||
+                      data_type == CA_INT32 || data_type == CA_INT64 );
 
   memcpy(ca->dim, parent->dim, ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
 
   return 0;
 }
 
 CABitfield *
-ca_bitfield_new (CArray *parent, ca_size_t offset, ca_size_t bitlen)
+ca_bitfield_new (CArray *parent, ca_size_t offset, ca_size_t bitlen,
+                 int8_t data_type)
 {
-  CABitfield *ca = (CABitfield *) ca_array_alloc(CA_OBJ_BITFIELD, parent->ndim);
-  ca_bitfield_setup(ca, parent, offset, bitlen);
+  CABitfield *ca;
+  ca_bitfield_setup(NULL, parent, offset, bitlen, data_type);
+  ca = (CABitfield *) ca_array_alloc(CA_OBJ_BITFIELD, parent->ndim);
+  ca_bitfield_setup(ca, parent, offset, bitlen, data_type);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -281,9 +315,8 @@ static void *
 ca_bitfield_func_clone (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
-  return ca_bitfield_new(ca->parent,
-                         ca->bit_start,
-                         bitfield_bitlen(ca->bit_mask, ca->bytes));
+  return ca_bitfield_new(ca->parent, ca->bit_start, ca->bit_length,
+                         ca->data_type);
 }
 
 /* Per-cell get/put: fetch the parent cell into a scratch buffer,
@@ -293,19 +326,21 @@ static void
 ca_bitfield_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
 {
   CABitfield *ca = (CABitfield *) ap;
-  char *v = xmalloc(ca->parent->bytes);
+  volatile VALUE holder;
+  char *v = ALLOCV_N(char, holder, ca->parent->bytes);
   ca_fetch_index(ca->parent, idx, v);
   if ( dir == CA_XFER_GET ) {
     memset(data, 0, ca->bytes);
     bitfield_fetch(data, ca->bytes, v, ca->parent->bytes,
-                   ca->byte_offset, ca->bit_offset, ca->bit_mask, 1);
+                   ca->byte_offset, ca->bit_offset, ca->bit_mask,
+                   ca->bit_length, ca->sign_extend, 1);
   }
   else {
     bitfield_store(data, ca->bytes, v, ca->parent->bytes,
                    ca->byte_offset, ca->bit_offset, ca->bit_mask, 1);
     ca_store_index(ca->parent, idx, v);
   }
-  xfree(v);
+  ALLOCV_END(holder);
 }
 
 /* Batched gather / scatter.  CABitfield is a 1:1 view (each parent
@@ -342,7 +377,8 @@ ca_bitfield_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
            directly from the attached parent. */
         memset(d, 0, n * ca->bytes);
         bitfield_fetch(d, ca->bytes, eff_parent->ptr, pbytes,
-                       ca->byte_offset, ca->bit_offset, ca->bit_mask, n);
+                       ca->byte_offset, ca->bit_offset, ca->bit_mask, 
+                       ca->bit_length, ca->sign_extend, n);
       } else {
         /* Bulk RMW directly against parent memory (bitfield_store
            preserves non-field bits). */
@@ -359,7 +395,8 @@ ca_bitfield_func_xfer_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
     for (i = 0; i < n; i++) {
       memset(d + i * ca->bytes, 0, ca->bytes);
       bitfield_fetch(d + i * ca->bytes, ca->bytes, v + i * pbytes, pbytes,
-                     ca->byte_offset, ca->bit_offset, ca->bit_mask, 1);
+                     ca->byte_offset, ca->bit_offset, ca->bit_mask, 
+                       ca->bit_length, ca->sign_extend, 1);
     }
   }
   else {
@@ -382,6 +419,7 @@ static void
 ca_bitfield_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;
   CABitfield *ca = (CABitfield *) ap;
   int8_t     ndim = ca->ndim;
   ca_size_t  native[CA_RANK_MAX], idx[CA_RANK_MAX];
@@ -412,7 +450,7 @@ ca_bitfield_func_allocate (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -420,7 +458,7 @@ ca_bitfield_func_attach (void *ap)
 {
   CABitfield *ca = (CABitfield *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_bitfield_attach(ca);
 }
 
@@ -467,7 +505,8 @@ ca_bitfield_func_xfer_all (void *ap, void *data, int dir)
     if ( dir == CA_XFER_GET ) {
       memset(d, 0, n * ca->bytes);
       bitfield_fetch(d, ca->bytes, eff_parent->ptr, pbytes,
-                     ca->byte_offset, ca->bit_offset, ca->bit_mask, n);
+                     ca->byte_offset, ca->bit_offset, ca->bit_mask, 
+                       ca->bit_length, ca->sign_extend, n);
     } else {
       bitfield_store(d, ca->bytes, eff_parent->ptr, pbytes,
                      ca->byte_offset, ca->bit_offset, ca->bit_mask, n);
@@ -491,7 +530,8 @@ ca_bitfield_func_xfer_all (void *ap, void *data, int dir)
       ca_xfer_stride(parent, pstarts, parent->dim, pnative, scratch, CA_XFER_GET);
       memset(d, 0, n * ca->bytes);
       bitfield_fetch(d, ca->bytes, scratch, pbytes,
-                     ca->byte_offset, ca->bit_offset, ca->bit_mask, n);
+                     ca->byte_offset, ca->bit_offset, ca->bit_mask, 
+                       ca->bit_length, ca->sign_extend, n);
     } else {
       /* CAREFUL: gather parent into scratch before splicing so the
          non-field bits are preserved across the RMW. */
@@ -510,8 +550,7 @@ ca_bitfield_func_fill_data (void *ap, void *ptr)
   CABitfield *ca = (CABitfield *) ap;
   ca_attach(ca->parent);
   ca_bitfield_fill(ca, ptr);
-  ca_sync(ca->parent);
-  ca_detach(ca->parent);
+  ca_sync_detach(ca->parent);
 }
 
 
@@ -542,20 +581,6 @@ ca_bitfield_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
   ca_fill_stride_via_addrs(ap, base, ndim, counts, steps, ptr);
 }
 
-static void
-ca_bitfield_func_create_mask (void *ap)
-{
-  CABitfield *ca = (CABitfield *) 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_bitfield_func = {
   -1, /* CA_OBJ_BITFIELD */
   CA_VIEW_ARRAY,
@@ -566,7 +591,7 @@ ca_operation_function_t ca_bitfield_func = {
   ca_bitfield_func_sync,
   ca_bitfield_func_detach,
   ca_bitfield_func_fill_data,
-  ca_bitfield_func_create_mask,
+  ca_view_func_create_mask,
   ca_bitfield_func_xfer_index,
   ca_bitfield_func_xfer_addrs,
   NULL,                       /* fold_stride: never fold — per-cell bit transform */
@@ -583,7 +608,8 @@ ca_bitfield_attach (CABitfield *ca)
 {
   memset(ca->ptr, 0, ca_length(ca));
   bitfield_fetch(ca->ptr, ca->bytes, ca->parent->ptr, ca->parent->bytes,
-                 ca->byte_offset, ca->bit_offset, ca->bit_mask, ca->elements);
+                 ca->byte_offset, ca->bit_offset, ca->bit_mask, 
+                       ca->bit_length, ca->sign_extend, ca->elements);
 }
 
 static void
@@ -614,14 +640,15 @@ ca_bitfield_fill (CABitfield *ca, char *ptr)
 /* ------------------------------------------------------------------- */
 
 VALUE
-rb_ca_bitfield_new (VALUE cary, ca_size_t offset, ca_size_t bitlen)
+rb_ca_bitfield_new (VALUE cary, ca_size_t offset, ca_size_t bitlen,
+                    int8_t data_type)
 {
   volatile VALUE obj;
   CArray *parent;
   CABitfield *ca;
   rb_check_carray_object(cary);
   TypedData_Get_Struct(cary, CArray, &carray_data_type, parent);
-  ca = ca_bitfield_new(parent, offset, bitlen);
+  ca = ca_bitfield_new(parent, offset, bitlen, data_type);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, cary);
   return obj;
@@ -641,6 +668,9 @@ rb_ca_bitfield (int argc, VALUE *argv, VALUE self)
 
   if ( TYPE(rrange) == T_FIXNUM ) {
     offset = NUM2INT(rrange);
+    if ( offset < 0 ) {
+      offset += ca->bytes * 8;
+    }
     bitlen = 1;
   }
   else {
@@ -651,7 +681,8 @@ rb_ca_bitfield (int argc, VALUE *argv, VALUE self)
     }
   }
 
-  return rb_ca_bitfield_new(self, offset, bitlen);
+  return rb_ca_bitfield_new(self, offset, bitlen,
+                            NIL_P(rtype) ? CA_NONE : rb_ca_guess_type(rtype));
 }
 
 static VALUE
@@ -667,14 +698,15 @@ rb_ca_bitfield_initialize_copy (VALUE self, VALUE other)
   CABitfield *ca, *cs;
 
   TypedData_Get_Struct(self,  CABitfield, &cabitfield_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CABitfield, &cabitfield_data_type, cs);
 
   if ( ca_func[CA_OBJ_BITFIELD].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_BITFIELD, cs->parent->ndim);
   }
-  ca_bitfield_setup(ca, cs->parent,
-                    cs->bit_start,
-                    bitfield_bitlen(cs->bit_mask, cs->bytes));
+  ca_bitfield_setup(ca, cs->parent, cs->bit_start, cs->bit_length,
+                    cs->data_type);
+  ca_view_inherit_mask((VALUE) ca);
 
   return self;
 }

data/ext/ca_obj_block.c

@@ -124,6 +124,12 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
     }
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   /* strides[k] = step[k] * Pi_{j>k} size0[j] * parent->bytes */
   suffix = parent->bytes;
   for (i = ndim - 1; i >= 0; i--) {
@@ -141,10 +147,9 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
     }
   }
 
-  /* CAREFUL: the CABlock tail (offset / start / step / count / size0)
-     must be filled BEFORE ca_stride_setup.  ca_stride_setup may auto-
-     dispatch ca_create_mask when the parent has a mask, and
-     ca_block_func_create_mask reads those tail fields.
+  /* The CABlock tail (offset / start / step / count / size0) is filled
+     here; ca_block_func_create_mask reads it when the constructor takes
+     the parent's mask (ca_view_inherit_mask) after this setup.
 
      Pool path: start/step/count/size0 already point into _pool (wired
      by ca_block_pool_init); only memcpy the values.  Non-pool path:
@@ -161,10 +166,10 @@ ca_block_setup (CABlock *ca, CArray *parent, int8_t ndim, ca_size_t *dim,
   memcpy(ca->count, count, ndim * sizeof(ca_size_t));
   memcpy(ca->size0, dim,   ndim * sizeof(ca_size_t));
 
-  ca_stride_setup((CAStride *) ca, CA_OBJ_BLOCK, parent,
-                  parent->data_type, parent->bytes,
-                  ndim, count, strides,
-                  base_offset_elements * parent->bytes);
+  ca_stride_setup_view((CAStride *) ca, CA_OBJ_BLOCK, parent,
+                       parent->data_type, parent->bytes,
+                       ndim, count, strides,
+                       base_offset_elements * parent->bytes);
 
   return 0;
 }
@@ -174,8 +179,11 @@ ca_block_new (CArray *parent, int8_t ndim, ca_size_t *dim,
               ca_size_t *start, ca_size_t *step, ca_size_t *count,
               ca_size_t offset)
 {
-  CABlock *ca = (CABlock *) ca_array_alloc(CA_OBJ_BLOCK, ndim);
+  CABlock *ca;
+  ca_block_setup(NULL, parent, ndim, dim, start, step, count, offset);
+  ca = (CABlock *) ca_array_alloc(CA_OBJ_BLOCK, ndim);
   ca_block_setup(ca, parent, ndim, dim, start, step, count, offset);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -254,6 +262,7 @@ rb_cb_initialize_copy (VALUE self, VALUE other)
 {
   CABlock *ca, *cs;
   TypedData_Get_Struct(self,  CABlock, &cablock_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CABlock, &cablock_data_type, cs);
   /* `self` was created by rb_cb_s_allocate (TypedData_Make_Struct) with
      ca->_pool == NULL.  Wire up the pool before ca_block_setup so the
@@ -264,6 +273,7 @@ rb_cb_initialize_copy (VALUE self, VALUE other)
   }
   ca_block_setup(ca, cs->parent, cs->ndim, cs->size0,
                  cs->start, cs->step, cs->count, cs->offset);
+  ca_view_inherit_mask((VALUE) ca);
   rb_ca_set_parent(self, rb_ca_parent(other));
   return self;
 }

data/ext/ca_obj_byte_swap.c

@@ -13,6 +13,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_iter_substrate.h"  /* ca_xfer_stride_transform_fused */
 #include "ca_monop_dispatch.h"  /* CA_MONOP_BYTE_SWAP dispatch id */
 #include "ca_obj_face.h"        /* CA_FACE_LIFT_IF_FACE for CARecord parent */
@@ -192,12 +193,18 @@ VALUE rb_cCAByteSwap;
 int
 ca_byte_swap_setup (CAByteSwap *ca, CArray *parent, VALUE data_class)
 {
-  CA_CHECK_DATA_TYPE(parent->data_type);
+  CA_CHECK_DATA_TYPE_GIVEN(parent->data_type);
 
   if ( parent->data_type == CA_OBJECT ) {
     rb_raise(rb_eCADataTypeError, "object array can't be byte-swapped");
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_BYTE_SWAP;
   ca->data_type = parent->data_type;
   ca->flags     = 0;
@@ -216,9 +223,6 @@ ca_byte_swap_setup (CAByteSwap *ca, CArray *parent, VALUE data_class)
   ca->nosync    = 0;
   ca->data_class = data_class;   /* Qnil if parent has no data_class */
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
@@ -229,8 +233,11 @@ ca_byte_swap_setup (CAByteSwap *ca, CArray *parent, VALUE data_class)
 CAByteSwap *
 ca_byte_swap_new (CArray *parent, VALUE data_class)
 {
-  CAByteSwap *ca = (CAByteSwap *) ca_array_alloc(CA_OBJ_BYTE_SWAP, parent->ndim);
+  CAByteSwap *ca;
+  ca_byte_swap_setup(NULL, parent, data_class);
+  ca = (CAByteSwap *) ca_array_alloc(CA_OBJ_BYTE_SWAP, parent->ndim);
   ca_byte_swap_setup(ca, parent, data_class);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -319,12 +326,12 @@ ca_byte_swap_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
     ca_byte_swap_apply_one(ca, (char *) data);
   }
   else {
-    char v[32];
-    char *buf = (ca->bytes <= 32) ? v : xmalloc(ca->bytes);
+    volatile VALUE holder;
+    char *buf = ALLOCV_N(char, holder, ca->bytes);
     memcpy(buf, data, ca->bytes);
     ca_byte_swap_apply_one(ca, buf);
     ca_store_index(ca->parent, idx, buf);
-    if ( buf != v ) xfree(buf);
+    ALLOCV_END(holder);
   }
 }
 
@@ -405,6 +412,7 @@ static void
 ca_byte_swap_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;
   CAByteSwap *ca = (CAByteSwap *) ap;
   char      *d = (char *) data;
   int        is_struct = ( ca->data_type == CA_FIXLEN && RTEST(ca->data_class) );
@@ -454,7 +462,7 @@ ca_byte_swap_func_allocate (void *ap)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -462,7 +470,7 @@ ca_byte_swap_func_attach (void *ap)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   memcpy(ca->ptr, ca->parent->ptr, ca_length(ca));
   ca_byte_swap_apply(ca, ca->ptr);
 }
@@ -471,10 +479,17 @@ static void
 ca_byte_swap_func_sync (void *ap)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  /* Swap is involutive, so applying it once to the view buffer
-     restores the parent byte order before the copy-back. */
-  ca_byte_swap_apply(ca, ca->ptr);
-  memcpy(ca->parent->ptr, ca->ptr, ca_length(ca));
+  /* Swap is involutive, so applying it once to a copy of the view buffer
+     restores the parent byte order.  Not the view buffer in place: the
+     window stays open after a sync, and a second sync (a stack holding
+     this view twice) would swap it again.  The swap of a record calls
+     Ruby, so it runs on the copy and reaches the parent only whole. */
+  volatile VALUE holder;
+  char *tmp = ALLOCV_N(char, holder, ca_length(ca));
+  memcpy(tmp, ca->ptr, ca_length(ca));
+  ca_byte_swap_apply(ca, tmp);
+  memcpy(ca->parent->ptr, tmp, ca_length(ca));
+  ALLOCV_END(holder);
   ca_sync(ca->parent);
 }
 
@@ -509,8 +524,8 @@ static void
 ca_byte_swap_func_fill_data (void *ap, void *ptr)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  char v[32];
-  char *buf = (ca->bytes <= 32) ? v : xmalloc(ca->bytes);
+  volatile VALUE holder;
+  char *buf = ALLOCV_N(char, holder, ca->bytes);
   memcpy(buf, ptr, ca->bytes);
   if ( !ca_byte_swap_apply_one(ca, buf) ) {
     /* Bare CA_FIXLEN fill: broadcast the raw bytes into the view
@@ -523,13 +538,12 @@ ca_byte_swap_func_fill_data (void *ap, void *ptr)
         memcpy(ca->ptr + i * ca->bytes, ptr, ca->bytes);
       }
     }
-    ca_sync(ca);
-    ca_detach(ca);
-    if ( buf != v ) xfree(buf);
+    ca_sync_detach(ca);
+    ALLOCV_END(holder);
     return;
   }
   ca_fill(ca->parent, buf);
-  if ( buf != v ) xfree(buf);
+  ALLOCV_END(holder);
 }
 
 /* fill_data with a region.  Swapping is per value, not per cell, so the one
@@ -543,8 +557,8 @@ ca_byte_swap_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
                                ca_size_t *counts, ca_size_t *steps, void *ptr)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  char v[32];
-  char *buf = (ca->bytes <= 32) ? v : xmalloc(ca->bytes);
+  volatile VALUE holder;
+  char *buf = ALLOCV_N(char, holder, ca->bytes);
   memcpy(buf, ptr, ca->bytes);
   if ( ca_byte_swap_apply_one(ca, buf) ) {
     ca_fill_stride(ca->parent, base, ndim, counts, steps, buf);
@@ -552,7 +566,7 @@ ca_byte_swap_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
   else {
     ca_fill_stride_default(ca, base, ndim, counts, steps, ptr);
   }
-  if ( buf != v ) xfree(buf);
+  ALLOCV_END(holder);
 }
 
 static void
@@ -560,8 +574,8 @@ ca_byte_swap_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
                               void *ptr)
 {
   CAByteSwap *ca = (CAByteSwap *) ap;
-  char v[32];
-  char *buf = (ca->bytes <= 32) ? v : xmalloc(ca->bytes);
+  volatile VALUE holder;
+  char *buf = ALLOCV_N(char, holder, ca->bytes);
   memcpy(buf, ptr, ca->bytes);
   if ( ca_byte_swap_apply_one(ca, buf) ) {
     ca_fill_addrs(ca->parent, n, addrs, buf);
@@ -569,23 +583,7 @@ ca_byte_swap_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs,
   else {
     ca_fill_addrs_default(ca, n, addrs, ptr);
   }
-  if ( buf != v ) xfree(buf);
-}
-
-static void
-ca_byte_swap_func_create_mask (void *ap)
-{
-  CAByteSwap *ca = (CAByteSwap *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-  /* Mask is byte-wide (boolean), so the swap is a no-op for the
-     mask itself.  Share the parent's mask via a CARefer to keep the
-     two in lockstep. */
-  ca->mask =
-    (CArray *) ca_refer_new(ca->parent->mask,
-                            CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
+  ALLOCV_END(holder);
 }
 
 ca_operation_function_t ca_byte_swap_func = {
@@ -598,7 +596,7 @@ ca_operation_function_t ca_byte_swap_func = {
   ca_byte_swap_func_sync,
   ca_byte_swap_func_detach,
   ca_byte_swap_func_fill_data,
-  ca_byte_swap_func_create_mask,
+  ca_view_func_create_mask,
   ca_byte_swap_func_xfer_index,
   ca_byte_swap_func_xfer_addrs,
   NULL,                       /* fold_stride: never fold — value-conversion boundary */
@@ -658,11 +656,13 @@ rb_ca_byte_swap_initialize_copy (VALUE self, VALUE other)
 {
   CAByteSwap *ca, *cs;
   TypedData_Get_Struct(self,  CAByteSwap, &cabyteswap_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAByteSwap, &cabyteswap_data_type, cs);
   if ( ca_func[CA_OBJ_BYTE_SWAP].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_BYTE_SWAP, cs->parent->ndim);
   }
   ca_byte_swap_setup(ca, cs->parent, cs->data_class);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -732,10 +732,9 @@ rb_ca_swap_bytes_bang (VALUE self)
   }
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
-  ca_attach(ca);
+  ca_attach(ca);   /* window: nothing raises inside */
   ca_byte_swap_buffer(ca->data_type, ca->bytes, ca->elements, ca->ptr);
-  ca_sync(ca);
-  ca_detach(ca);
+  ca_sync_detach(ca);
   return self;
 }