carray 3.0.2 → 3.0.3

data/ext/carray_address_basis.c

@@ -1,4 +1,5 @@
 #include "carray.h"
+#include "carray_internal.h"
 
 /* ---------------------------------------------------------------------------
 
@@ -8,8 +9,8 @@
   writes a[i] from its own loop, so what it needs from CArray is not element
   delivery but an addressing basis: a pointer, already shifted to cell zero,
   and one byte stride per axis.  That is why this does not sit on the kernel
-  iterator (per-cell / per-slab delivery, and no N-ary form) or on the sweep
-  ELEMENT family (which flattens the array and cannot recover the axis
+  iterator (per-cell / per-slab delivery, and no N-ary form) or on the
+  call_cfunc families (which flatten the array and cannot recover the axis
   structure a stencil needs).
 
   This is a runtime facility at the same layer as ca_attach, not a user
@@ -79,6 +80,8 @@ typedef struct {
   VALUE      bases;
   VALUE      box_starts;      /* per array, per axis; nil for "all of it" */
   VALUE      box_counts;
+  int        body_done;       /* the block returned without raising */
+  volatile VALUE put_error;   /* the first write-back that raised, or nil */
 } open_state;
 
 /* The view's own row-major byte layout, which is the address space
@@ -94,6 +97,15 @@ native_steps (CArray *ca, ca_size_t *steps)
   }
 }
 
+/* Whether [start, start + count) leaves [0, dim).  Written so that no sum
+   is formed: a start and a count near the top of the integer range add up
+   to a negative number, which `start + count > dim` lets through. */
+static int
+outside_axis (ca_size_t start, ca_size_t count, ca_size_t dim)
+{
+  return start < 0 || count < 0 || start > dim || count > dim - start;
+}
+
 /* Checks one array's box description, all of it: that it is one start and one
    count per axis, that they are numbers, and that the box they describe is
    inside the array.
@@ -124,9 +136,11 @@ verify_box (VALUE box_starts, VALUE box_counts, int index, CArray *ca)
              "this array has %d", (int) ca->ndim);
   }
   for ( k = 0; k < ca->ndim; k++ ) {
-    ca_size_t start = NUM2LL(rb_ary_entry(starts, k));
-    ca_size_t count = NUM2LL(rb_ary_entry(counts, k));
-    if ( start < 0 || count < 0 || start + count > ca->dim[k] ) {
+    ca_size_t start = ca_integer_arg(rb_ary_entry(starts, k), "a region start",
+                                     "CArray::AddressBasis.open");
+    ca_size_t count = ca_integer_arg(rb_ary_entry(counts, k), "a region count",
+                                     "CArray::AddressBasis.open");
+    if ( outside_axis(start, count, ca->dim[k]) ) {
       rb_raise(rb_eArgError,
                "the requested region falls outside the array on axis %d", (int) k);
     }
@@ -156,7 +170,7 @@ read_box (open_state *state, int index, CArray *ca,
       starts[k] = NUM2LL(rb_ary_entry(per_array_start, k));
       counts[k] = NUM2LL(rb_ary_entry(per_array_count, k));
     }
-    if ( starts[k] < 0 || counts[k] < 0 || starts[k] + counts[k] > ca->dim[k] ) {
+    if ( outside_axis(starts[k], counts[k], ca->dim[k]) ) {
       rb_raise(rb_eArgError,
                "the requested region falls outside the array on axis %d", (int) k);
     }
@@ -217,6 +231,28 @@ folds_to_an_entity (CArray *ca)
   return ca_is_entity(root);
 }
 
+/* A view that reinterprets the element size -- refer(CA_INT32, ...) over
+   a float64 array -- gets a mask of its own shape, but one mask cell of it
+   covers a fraction of a parent cell, so writing cell i's mask also marks
+   its neighbour.  A per-cell kernel writes cells independently and cannot
+   express that.  Checked for every tier: a box transfer moves the same
+   mask, and the neighbour is marked when it is written back. */
+static void
+verify_mask_cells (VALUE object, CArray *ca)
+{
+  CArray   *root;
+  ca_size_t strides[CA_RANK_MAX];
+  ca_size_t base = 0;
+  if ( ! ca->mask || ! ca_is_stride_family(ca) ) return;
+  ca_stride_compose_to_root((CAStride *) ca, &root, strides, &base);
+  if ( ca->bytes != root->bytes ) {
+    rb_raise(rb_eArgError,
+             "%"PRIsVALUE" reinterprets the element size and carries a mask; "
+             "its mask cells do not map one to one onto the parent's",
+             rb_obj_class(object));
+  }
+}
+
 static int
 tier_for (CArray *ca)
 {
@@ -239,7 +275,7 @@ acquire_basis (open_state *state, int index, ca_size_t *strides)
   switch ( state->tier[index] ) {
   case TIER_ENTITY: {
     CArray *root = ca;
-    ca_attach(root);
+    ca_attach(root);   /* window: released by open_ensure */
     state->roots[index] = root;
     state->attached_root[index] = 1;
     row_major_strides(ca, strides);
@@ -250,18 +286,7 @@ acquire_basis (open_state *state, int index, ca_size_t *strides)
   case TIER_STRIDE: {
     CArray *root;
     ca_stride_compose_to_root((CAStride *) ca, &root, strides, &base);
-    /* A view that reinterprets the element size -- refer(CA_INT32, ...) over
-       a float64 array -- gets a mask of its own shape, but one mask cell of
-       it covers a fraction of a parent cell, so writing cell i's mask also
-       marks its neighbour.  A per-cell kernel writes cells independently and
-       cannot express that. */
-    if ( ca->mask && ca->bytes != root->bytes ) {
-      rb_raise(rb_eArgError,
-               "%"PRIsVALUE" reinterprets the element size and carries a mask; "
-               "its mask cells do not map one to one onto the parent's",
-               rb_obj_class(rb_ary_entry(state->arrays, index)));
-    }
-    ca_attach(root);
+    ca_attach(root);   /* window: released by open_ensure */
     state->roots[index] = root;
     state->attached_root[index] = 1;
     pointer = root->ptr + base;
@@ -287,12 +312,26 @@ acquire_basis (open_state *state, int index, ca_size_t *strides)
       step *= counts[k];
     }
 
-    buffer = ALLOC_N(char, (elements > 0 ? elements : 1) * ca->bytes);
+    /* Recorded before the read: the read can raise, and open_ensure
+       frees what state->region holds.  The counts stay zero until the
+       read is done, so a buffer that was never filled is not written
+       back. */
+    /* A writable box keeps a second copy of what it read, so that the
+       write-back can send only the cells the kernel changed (see
+       put_changed). */
+    buffer = ALLOC_N(char, (state->writable[index] ? 2 : 1)
+                           * (elements > 0 ? elements : 1) * ca->bytes);
+    for ( k = 0; k < ca->ndim; k++ ) {
+      state->region_count[index * CA_RANK_MAX + k] = 0;
+    }
+    state->region[index] = buffer;
     if ( elements > 0 ) {
       ca_xfer_stride(ca, starts, counts, steps, buffer, CA_XFER_GET);
+      if ( state->writable[index] ) {
+        memcpy(buffer + elements * ca->bytes, buffer, elements * ca->bytes);
+      }
     }
 
-    state->region[index] = buffer;
     for ( k = 0; k < ca->ndim; k++ ) {
       state->region_start[index * CA_RANK_MAX + k] = starts[k];
       state->region_count[index * CA_RANK_MAX + k] = counts[k];
@@ -350,10 +389,73 @@ open_body (VALUE argument)
     }
     rb_ary_push(state->bases, basis);
   }
-  return rb_yield(state->bases);
+  {
+    VALUE result = rb_yield(state->bases);
+    state->body_done = 1;
+    return result;
+  }
+}
+
+typedef struct {
+  CArray    *ca;
+  ca_size_t *start;
+  ca_size_t *count;
+  ca_size_t *steps;
+  char      *data;
+  char      *read;      /* the box as it was read */
+} write_back_args;
+
+/* Sends back the cells whose bytes differ from what was read, one run
+   along the last axis at a time.  Sending the whole box would also send the
+   cells the kernel never wrote, and those do not come back unchanged
+   through a view that converts -- a float64 array seen through an int32
+   view reads 1.75 as 1 and would be left holding 1.0.  It would also
+   overwrite what the kernel wrote to the same cells through another basis
+   that addresses them in place. */
+static VALUE
+write_back (VALUE argument)
+{
+  write_back_args *w = (write_back_args *) argument;
+  CArray   *ca    = w->ca;
+  int8_t    nd    = ca->ndim;
+  size_t    bytes = ca->bytes;
+  ca_size_t inner = w->count[nd - 1];
+  ca_size_t outer = 1;
+  ca_size_t idx[CA_RANK_MAX], start[CA_RANK_MAX], count[CA_RANK_MAX];
+  ca_size_t o, j, e;
+  int8_t    k;
+
+  for ( k = 0; k < nd - 1; k++ ) {
+    outer *= w->count[k];
+    idx[k] = 0;
+    count[k] = 1;
+  }
+  for ( o = 0; o < outer; o++ ) {
+    char *row  = w->data + o * inner * bytes;
+    char *read = w->read + o * inner * bytes;
+    for ( k = 0; k < nd - 1; k++ ) start[k] = w->start[k] + idx[k];
+    j = 0;
+    while ( j < inner ) {
+      if ( ! memcmp(row + j * bytes, read + j * bytes, bytes) ) { j++; continue; }
+      e = j + 1;
+      while ( e < inner && memcmp(row + e * bytes, read + e * bytes, bytes) ) e++;
+      start[nd - 1] = w->start[nd - 1] + j;
+      count[nd - 1] = e - j;
+      ca_xfer_stride(ca, start, count, w->steps, row + j * bytes, CA_XFER_PUT);
+      j = e;
+    }
+    for ( k = nd - 2; k >= 0; k-- ) {
+      if ( ++idx[k] < w->count[k] ) break;
+      idx[k] = 0;
+    }
+  }
+  return Qnil;
 }
 
-/* Closes in reverse order, and runs whether or not the kernel raised. */
+/* Closes in reverse order, and runs whether or not the kernel raised.  A
+   write-back that raises -- the array's own transfer slot failing -- is
+   set aside so that every other region is still written and freed and
+   every root detached; the block's own exception, if it raised, wins. */
 static VALUE
 open_ensure (VALUE argument)
 {
@@ -371,11 +473,23 @@ open_ensure (VALUE argument)
         elements *= state->region_count[i * CA_RANK_MAX + k];
       }
       if ( state->writable[i] && elements > 0 ) {
-        ca_size_t steps[CA_RANK_MAX];
+        ca_size_t       steps[CA_RANK_MAX];
+        write_back_args w;
+        int             tag = 0;
         native_steps(ca, steps);
-        ca_xfer_stride(ca, &state->region_start[i * CA_RANK_MAX],
-                       &state->region_count[i * CA_RANK_MAX],
-                       steps, state->region[i], CA_XFER_PUT);
+        w.ca    = ca;
+        w.start = &state->region_start[i * CA_RANK_MAX];
+        w.count = &state->region_count[i * CA_RANK_MAX];
+        w.steps = steps;
+        w.data  = state->region[i];
+        w.read  = state->region[i] + elements * ca->bytes;
+        rb_protect(write_back, (VALUE) &w, &tag);
+        if ( tag ) {
+          if ( NIL_P(state->put_error) ) {
+            state->put_error = rb_errinfo();
+          }
+          rb_set_errinfo(Qnil);
+        }
       }
       xfree(state->region[i]);
     }
@@ -384,6 +498,10 @@ open_ensure (VALUE argument)
     }
   }
   xfree(state->block);
+  if ( state->body_done && RTEST(rb_obj_is_kind_of(state->put_error,
+                                                   rb_eException)) ) {
+    rb_exc_raise(state->put_error);
+  }
   return Qnil;
 }
 
@@ -451,7 +569,12 @@ packed_body (VALUE argument)
     }
   }
 
-  return rb_yield_values(4, pointers, strides, mask_pointers, mask_strides);
+  {
+    VALUE result = rb_yield_values(4, pointers, strides, mask_pointers,
+                                   mask_strides);
+    state->body_done = 1;
+    return result;
+  }
 }
 
 /*
@@ -489,9 +612,25 @@ address_basis_open (int argc, VALUE *argv, VALUE module)
     rb_raise(rb_eArgError, "one writable flag per array is required");
   }
 
+  /* Every argument is checked before the block below is allocated: a
+     refusal raises, and it must find nothing to free. */
+  for ( i = 0; i < (int) RARRAY_LEN(arrays); i++ ) {
+    VALUE   object = rb_ary_entry(arrays, i);
+    CArray *ca;
+    GetCArray(object, ca);
+    /* A view takes its mask from its parent when first asked for it; one
+       added to the parent after the view was made is not on ca->mask yet. */
+    ca_update_mask(ca);
+    verify_usable(object, ca, RTEST(rb_ary_entry(writable_flags, i)));
+    verify_mask_cells(object, ca);
+    verify_box(box_start, box_count, i, ca);
+  }
+
   state.count         = (int) RARRAY_LEN(arrays);
   state.slots         = state.count * 2;
-  state.arrays        = arrays;
+  /* Our own copy: the caller's Array can be emptied inside the block, and
+     the arrays it held are attached until open_ensure has run. */
+  state.arrays        = rb_ary_dup(arrays);
   state.bases         = rb_ary_new_capa(state.count);
   /* One allocation, carved up, rather than eight.  Every array here is the
      same length in slots and lives exactly as long as the open, so there is
@@ -521,15 +660,15 @@ address_basis_open (int argc, VALUE *argv, VALUE module)
   }
   state.box_starts    = box_start;
   state.box_counts    = box_count;
+  state.body_done     = 0;
+  state.put_error     = Qnil;
 
   for ( i = 0; i < state.count; i++ ) {
-    VALUE   object = rb_ary_entry(arrays, i);
+    VALUE   object = rb_ary_entry(state.arrays, i);
     CArray *ca;
     GetCArray(object, ca);
     state.carrays[i]  = ca;
     state.writable[i] = RTEST(rb_ary_entry(writable_flags, i));
-    verify_usable(object, ca, state.writable[i]);
-    verify_box(box_start, box_count, i, ca);
     state.tier[i] = tier_for(ca);
 
     if ( ca->mask ) {
@@ -540,10 +679,12 @@ address_basis_open (int argc, VALUE *argv, VALUE module)
     }
   }
 
-  if ( RTEST(packed) ) {
-    return rb_ensure(packed_body, (VALUE) &state, open_ensure, (VALUE) &state);
-  } else {
-    return rb_ensure(open_body, (VALUE) &state, open_ensure, (VALUE) &state);
+  {
+    VALUE result = RTEST(packed)
+      ? rb_ensure(packed_body, (VALUE) &state, open_ensure, (VALUE) &state)
+      : rb_ensure(open_body, (VALUE) &state, open_ensure, (VALUE) &state);
+    RB_GC_GUARD(state.arrays);
+    return result;
   }
 }
 

data/ext/carray_attribute.c

@@ -13,6 +13,7 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"   /* CA_OBJ_RECORD + rb_ca_record_get_data_class */
+#include "carray_internal.h"   /* rb_ca_inherit_attr */
 
 /* ------------------------------------------------------------------- */
 
@@ -436,6 +437,8 @@ rb_ca_is_object_type (VALUE self)
 /* ------------------------------------------------------------------- */
 
 static ID id_parent;
+static ID id_attr;
+static ID id_attrs;
 
 VALUE
 rb_ca_parent (VALUE self)
@@ -443,13 +446,41 @@ rb_ca_parent (VALUE self)
   return rb_ivar_get(self, id_parent);
 }
 
+/* Give dst the attributes (lib/carray/attribute.rb) that src shows, as its
+   own Hash.  Used by the methods that produce a new entity holding the
+   same values -- copy, to_type.  The parent walk here only decides
+   whether any array on the chain has an @attr at all; which of them
+   src actually shows (a lazy op view stops the chain) is left to #attrs,
+   so the rule lives in one place. */
+void
+rb_ca_inherit_attr (VALUE dst, VALUE src)
+{
+  VALUE obj = src, attrs;
+  int depth;
+
+  for (depth = 0; depth < 64 && ! NIL_P(obj); depth++) {
+    if ( rb_ivar_defined(obj, id_attr) ) {
+      break;
+    }
+    obj = rb_ivar_get(obj, id_parent);
+  }
+  if ( depth == 64 || NIL_P(obj) ) {
+    return;
+  }
+  attrs = rb_funcall(src, id_attrs, 0);
+  if ( RHASH_SIZE(attrs) > 0 ) {
+    rb_ivar_set(dst, id_attr, rb_hash_dup(attrs));
+  }
+}
+
+/* A view of a frozen array is not frozen itself: building it may still set
+   it up after this (an ivar, a lift that moves it onto another parent), and
+   writes through it are refused by ca_is_readonly, which walks to the
+   frozen root and finds CA_FLAG_READ_ONLY there. */
 VALUE
 rb_ca_set_parent (VALUE self, VALUE obj)
 {
   rb_ivar_set(self, id_parent, obj);
-  if ( OBJ_FROZEN(obj) ) {
-    rb_ca_freeze(self);
-  }
   return obj;
 }
 
@@ -521,6 +552,15 @@ ca_root_array (void *ap)
   }
 }
 
+/* Whether two arrays may share memory: their cells live in the same
+   root.  An operation that writes one while reading the other must read
+   from a copy taken before it writes. */
+int
+ca_shares_root (void *ap, void *aq)
+{
+  return ca_root_array(ap) == ca_root_array(aq);
+}
+
 static VALUE
 rb_ca_root_array (VALUE self)
 {
@@ -584,6 +624,8 @@ void
 Init_carray_attribute (void)
 {
   id_parent     = rb_intern("parent");
+  id_attr       = rb_intern("@attr");
+  id_attrs      = rb_intern("attrs");
 
   rb_define_method(rb_cCArray, "obj_type", rb_ca_obj_type, 0);
   rb_define_method(rb_cCArray, "data_type", rb_ca_data_type, 0);

data/ext/carray_bincount.c

@@ -72,6 +72,34 @@
   } \
 } while (0)
 
+/* Checked before a window opens: the dispatches above raise on a type
+   they do not cover, which would leave the labels (and weights) attached. */
+static void
+bincount_check_types (CArray *cl, CArray *cw)
+{
+  switch ( cl->data_type ) {
+  case CA_INT8:  case CA_INT16:  case CA_INT32:  case CA_INT64:
+  case CA_UINT8: case CA_UINT16: case CA_UINT32: case CA_UINT64:
+    break;
+  default:
+    rb_raise(rb_eCADataTypeError,
+             "bincount: integer label array required (got %d)",
+             cl->data_type);
+  }
+  if ( ! cw ) {
+    return;
+  }
+  switch ( cw->data_type ) {
+  case CA_FLOAT64: case CA_FLOAT32:
+  case CA_INT8:  case CA_INT16:  case CA_INT32:  case CA_INT64:
+  case CA_UINT8: case CA_UINT16: case CA_UINT32: case CA_UINT64:
+    break;
+  default:
+    rb_raise(rb_eCADataTypeError,
+             "bincount: weights must be numeric (got %d)", cw->data_type);
+  }
+}
+
 /* __bincount_count__(length) -- count occurrences of each label in
    self.  Allocates a zero-filled UInt32 (or UInt64 if length >= 2^32)
    output of size `length`, then runs the 8-way label dispatch. */
@@ -104,7 +132,8 @@ rb_ca_bincount_count_kernel (VALUE self, VALUE rlength)
     return vout;
   }
 
-  ca_attach(cl);
+  bincount_check_types(cl, NULL);
+  ca_attach(cl);   /* window: nothing raises inside */
   n      = cl->elements;
   mlabel = cl->mask ? (boolean8_t *) cl->mask->ptr : NULL;
 
@@ -213,7 +242,8 @@ rb_ca_bincount_weighted_kernel (VALUE self, VALUE rweights, VALUE rlength)
     return vout;
   }
 
-  ca_attach_n(2, cl, cw);
+  bincount_check_types(cl, cw);
+  ca_attach_n(2, cl, cw);   /* window: nothing raises inside */
   n       = cl->elements;
   mlabel  = cl->mask ? (boolean8_t *) cl->mask->ptr : NULL;
   mweight = cw->mask ? (boolean8_t *) cw->mask->ptr : NULL;

data/ext/carray_broadcast.c

@@ -30,6 +30,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "ca_obj_face.h"  /* CA_WRAPPER_LIFT */
 
 NORETURN(static void ca_broadcast_refuse_write (VALUE dst, VALUE src));
 
@@ -39,7 +40,7 @@ ca_broadcast_refuse_write (VALUE dst, VALUE src)
 {
   volatile VALUE dst_s = rb_inspect(rb_funcall(dst, rb_intern("shape"), 0));
   volatile VALUE src_s = rb_inspect(rb_funcall(src, rb_intern("shape"), 0));
-  rb_raise(rb_eRuntimeError,
+  rb_raise(rb_eArgError,
            "shape mismatch writing to carray (%s <- %s); shapes must agree "
            "once size-1 axes are dropped, or one side must be 1-D, or the "
            "source must be smaller and broadcastable -- use .flatten to "
@@ -119,7 +120,7 @@ ca_broadcast_view (VALUE src, int8_t ndim, ca_size_t *target_dim)
   TypedData_Get_Struct(src, CArray, &carray_data_type, cs);
 
   if (cs->ndim != ndim) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "broadcast: ndim mismatch (%d vs %d)",
              (int) cs->ndim, (int) ndim);
   }
@@ -143,7 +144,7 @@ ca_broadcast_view (VALUE src, int8_t ndim, ca_size_t *target_dim)
       needs_broadcast = 1;
     }
     else {
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "broadcast: cannot broadcast axis %d (%lld vs %lld)",
                i, (long long) cs->dim[i], (long long) target_dim[i]);
     }
@@ -172,20 +173,48 @@ ca_broadcast_view (VALUE src, int8_t ndim, ca_size_t *target_dim)
    raises). */
 NORETURN(static void ca_broadcast_refuse (VALUE self, VALUE other));
 
-/* Report a pair that cannot be brought to a common shape.  Naming both
-   shapes is the point of the message: the caller wrote two arrays that
-   cannot be combined, and the only remedy is to say which two. */
+/* Report a pair that cannot be brought to a common shape.  The message
+   names both shapes and points to the remedy that fits the pair: when
+   the ndim differs, the missing axes are added with :_; when the
+   element counts are equal, .flatten pairs the values in the order
+   they lie. */
 static void
 ca_broadcast_refuse (VALUE self, VALUE other)
 {
+  CArray *ca, *cb;
   volatile VALUE self_s  = rb_inspect(rb_funcall(self,  rb_intern("shape"), 0));
   volatile VALUE other_s = rb_inspect(rb_funcall(other, rb_intern("shape"), 0));
+  const char *flatten_hint;
+  int i;
+
+  TypedData_Get_Struct(self,  CArray, &carray_data_type, ca);
+  TypedData_Get_Struct(other, CArray, &carray_data_type, cb);
+
+  flatten_hint = (ca->elements == cb->elements)
+    ? "; to pair the values in the order they lie, use .flatten on both sides"
+    : "";
+
+  if (ca->ndim != cb->ndim) {
+    rb_raise(rb_eArgError,
+             "shape mismatch between operands (%s and %s): the operands "
+             "have different numbers of axes, and axes are not added "
+             "implicitly -- add size-1 axes with :_ so both have the same "
+             "number (x[:_, nil] makes a 1-D x a row, x[nil, :_] a column)%s",
+             StringValueCStr(self_s), StringValueCStr(other_s),
+             flatten_hint);
+  }
+
+  for (i = 0; i < ca->ndim; i++) {
+    if (ca->dim[i] != cb->dim[i] && ca->dim[i] != 1 && cb->dim[i] != 1) {
+      break;
+    }
+  }
   rb_raise(rb_eArgError,
-           "shape mismatch between operands (%s and %s); shapes must "
-           "agree, or differ only in size-1 axes with equal ndim -- use "
-           ".flatten on both sides to operate on the values in the order "
-           "they lie",
-           StringValueCStr(self_s), StringValueCStr(other_s));
+           "shape mismatch between operands (%s and %s): axis %d has "
+           "sizes %lld and %lld; each axis must have the same size, or "
+           "size 1 on one side%s",
+           StringValueCStr(self_s), StringValueCStr(other_s), i,
+           (long long) ca->dim[i], (long long) cb->dim[i], flatten_hint);
 }
 
 void
@@ -272,7 +301,7 @@ rb_ca_broadcast_to (int argc, VALUE *argv, VALUE self)
   target_ndim = (int8_t) argc;
 
   if (target_ndim < cs->ndim) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "broadcast_to: target ndim %d smaller than source ndim %d",
              (int) target_ndim, (int) cs->ndim);
   }
@@ -303,6 +332,7 @@ rb_ca_broadcast_to (int argc, VALUE *argv, VALUE self)
     }
     obj = ca_wrap_struct(view);
     rb_ca_set_parent(obj, self);
+    CA_WRAPPER_LIFT(obj, self, cs);
     return obj;
   }
 
@@ -340,7 +370,7 @@ rb_ca_broadcast_to (int argc, VALUE *argv, VALUE self)
     else {
       /* sd == -1 (source exhausted) with dd > 1, or sd > 1 with
          dd > 1 and not equal: cannot broadcast. */
-      rb_raise(rb_eRuntimeError,
+      rb_raise(rb_eArgError,
                "broadcast_to: cannot broadcast axis %d "
                "(source %s, target %lld)",
                t_idx,
@@ -351,7 +381,7 @@ rb_ca_broadcast_to (int argc, VALUE *argv, VALUE self)
   }
 
   if (s_idx >= 0) {
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eArgError,
              "broadcast_to: %d source axes left unmatched", s_idx + 1);
   }
 
@@ -366,6 +396,8 @@ rb_ca_broadcast_to (int argc, VALUE *argv, VALUE self)
   }
   obj = ca_wrap_struct(view);
   rb_ca_set_parent(obj, self);
+  /* The Face stays on top, as for every view. */
+  CA_WRAPPER_LIFT(obj, self, cs);
   return obj;
 }