carray 3.0.3 → 3.0.5

data/ext/ca_obj_monop.c

@@ -222,6 +222,7 @@ ca_monop_setup (CAMonOp *ca, CArray *parent, uint16_t op_id)
 CAMonOp *
 ca_monop_new (CArray *parent, uint16_t op_id)
 {
+  /* check: the setup checks nothing */
   CAMonOp *ca = (CAMonOp *) ca_array_alloc(CA_OBJ_MONOP, parent->ndim);
   ca_monop_setup(ca, parent, op_id);
   return ca;
@@ -282,7 +283,7 @@ ca_monop_func_xfer_index (void *ap, ca_size_t *idx, void *data, int dir)
     /* PUT: only writable-view op_ids accept writes (cast, or byte_swap
        involution). */
     if ( ! ca_monop_is_writable_view(ca->op_id) ) {
-      rb_raise(rb_eRuntimeError, "CAMonOp is read-only (xfer_index PUT)");
+      ca_refuse_read_only();
     }
     {
       volatile VALUE holder;
@@ -337,16 +338,14 @@ ca_size_t ca_monop_materialise_call_count = 0;
 #define CA_MAX_LAZY_DEPTH 256
 #endif
 
-/* Whether an op can raise on a cell, so that a masked cell must be
-   skipped rather than computed: any op on an object cell (it calls Ruby),
-   and an integer reciprocal (zero raises). */
+/* Whether a cast from `from` to `to` raises on a NaN cell: a float or
+   complex value has no integer for NaN. */
 static int
-ca_monop_is_trapping (uint16_t op_id, int8_t dt)
+ca_monop_cast_refuses_nan (int8_t from, int8_t to)
 {
-  if ( dt == CA_OBJECT ) {
-    return 1;
-  }
-  return ( op_id == CA_MONOP_RCP && dt >= CA_INT8 && dt <= CA_UINT64 );
+  int from_float = ( from == CA_FLOAT32 || from == CA_FLOAT64 ||
+                     from == CA_CMPLX64 || from == CA_CMPLX128 );
+  return from_float && to >= CA_INT8 && to <= CA_UINT64;
 }
 
 /* Apply a single op in-place on `data` (src == dst, unit element stride).
@@ -371,12 +370,19 @@ apply_monop_in_place (uint16_t op_id, int8_t cur_dt,
   fn(slab_n, mask, (char *) data, 1, (char *) data, 1);
 }
 
-/* Minimal CArray-shaped stub used as ca_cast_block's data_type-only carrier.
-   ca_cast_block only reads data_type to index into ca_cast_func_table.  */
-typedef struct {
-  int16_t obj_type;
-  int8_t  data_type;
-} ca_data_type_stub_t;
+/* A zeroed CArray carrying only data_type and bytes, handed to
+   ca_cast_block in place of a real array.  It is a whole CArray, not a
+   shorter struct cast to one: ca_cast_block reads data_type through a
+   CArray pointer, and a fixlen cast reads bytes as well.  */
+static CArray
+ca_data_type_stub (int8_t data_type)
+{
+  CArray stub;
+  memset(&stub, 0, sizeof(stub));
+  stub.data_type = data_type;
+  stub.bytes     = ca_sizeof[data_type];
+  return stub;
+}
 
 /* Pull leaf into the output buffer.  Three paths:
 
@@ -429,8 +435,8 @@ pull_leaf_with_optional_cast (CArray *leaf, uint16_t innermost_op,
   if ( has_cast_at_leaf ) {
     /* Path 2: cast scratch → data with output layout in target data_type.  */
     int8_t target_dt = (int8_t)(innermost_op - CA_MONOP_CAST_BASE);
-    ca_data_type_stub_t src_stub = { 0, leaf->data_type };
-    ca_data_type_stub_t dst_stub = { 0, target_dt };
+    CArray src_stub = ca_data_type_stub(leaf->data_type);
+    CArray dst_stub = ca_data_type_stub(target_dt);
     ca_cast_block(slab_n, &src_stub, scratch, &dst_stub, data);
     result_dt = target_dt;
   } else {
@@ -476,7 +482,27 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
     v = ALLOCV_N(char, holder, n * parent_bytes);
     if ( dir == CA_XFER_GET ) {
       ca_lazy_req_pull(mo->parent, req, v, CA_XFER_GET);
-      if ( is_cast ) {
+      if ( is_cast && ca_monop_cast_refuses_nan(mo->parent->data_type,
+                                                mo->data_type) ) {
+        /* The cast raises on a NaN cell it is asked to convert; a masked
+           cell (mask_invalid keeps the NaN under the mask) is skipped.
+           The mask is copied off the arena first so a raise leaves no
+           arena slot held. */
+        CArray *parent = mo->parent;
+        boolean8_t *arena_mask = ca_lazy_req_mask(req, 1, &parent);
+        boolean8_t *m = NULL;
+        volatile VALUE mholder = 0;
+        if ( arena_mask ) {
+          m = ALLOCV_N(boolean8_t, mholder, n);
+          memcpy(m, arena_mask, n);
+          ca_lazy_arena_release(arena_mask);
+        }
+        ca_cast_block_with_mask(n, mo->parent, v, (CArray *) mo, data, m);
+        if ( m ) {
+          ALLOCV_END(mholder);
+        }
+      }
+      else if ( is_cast ) {
         ca_cast_block(n, mo->parent, v, (CArray *) mo, data);
       }
       else {
@@ -503,7 +529,7 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
   /* Writable-view op_id PUT/GET is handled above.  Below: non-writable
      monop/monfunc.  PUT is read-only.  */
   if ( dir != CA_XFER_GET ) {
-    rb_raise(rb_eRuntimeError, "CAMonOp is read-only (xfer_stride PUT)");
+    ca_refuse_read_only();
   }
   ca_monop_materialise_call_count++;
 
@@ -536,6 +562,30 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
     chain_apply_count = chain_len - 1;
   }
 
+  /* The chain runs in place, so the buffer must hold slab_n cells of the
+     widest type along it: the leaf, or a step that widens before a later
+     one narrows (cmplx128.lazy.abs pulls 16-byte cells and answers 8-byte
+     ones).  When that is wider than the output, run in a scratch and copy
+     the answer into `data` at the end. */
+  void   *out  = data;
+  void   *work = NULL;
+  {
+    ca_size_t max_bytes = leaf->bytes;
+    int8_t    dt        = leaf->data_type;
+    for ( i = chain_len - 1; i >= 0; i-- ) {
+      dt = ca_monop_is_cast(op_chain[i])
+             ? (int8_t)(op_chain[i] - CA_MONOP_CAST_BASE)
+             : ca_lazy_promote_monop(op_chain[i], dt);
+      if ( ca_sizeof[dt] > max_bytes ) max_bytes = ca_sizeof[dt];
+    }
+    if ( max_bytes > mo->bytes ) {
+      work = ( leaf->data_type == CA_OBJECT )
+               ? ca_lazy_arena_acquire_object((slab_n * max_bytes + sizeof(VALUE) - 1) / sizeof(VALUE))
+               : ca_lazy_arena_acquire(slab_n * max_bytes);
+      data = work;
+    }
+  }
+
   /* === 2. pull leaf into output buffer (with optional cast) === */
   cur_dt = pull_leaf_with_optional_cast(
     leaf,
@@ -557,8 +607,8 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
       ca_size_t src_bytes = ca_sizeof[cur_dt];
       ca_size_t total_bytes = slab_n * src_bytes;
       void *scratch;
-      ca_data_type_stub_t src_stub = { 0, cur_dt };
-      ca_data_type_stub_t dst_stub = { 0, target_dt };
+      CArray src_stub = ca_data_type_stub(cur_dt);
+      CArray dst_stub = ca_data_type_stub(target_dt);
 
       /* Copy current data → scratch (in src data_type), then cast scratch
          → data (in target data_type).  Required because in-place cast
@@ -573,18 +623,22 @@ ca_monop_eval (CAMonOp *mo, const ca_lazy_req_t *req, void *data, int dir)
       ca_lazy_arena_release(scratch);
       cur_dt = target_dt;
     } else {
-      if ( ! mask_taken && ca_monop_is_trapping(op_id, cur_dt) ) {
+      if ( ! mask_taken && ca_op_raises_on_cell(CA_OP_KIND_MONOP, op_id, cur_dt) ) {
         slab_mask  = ca_lazy_req_mask(req, 1, &leaf);
         mask_taken = 1;
       }
       apply_monop_in_place(op_id, cur_dt, slab_n, data,
-                           ca_monop_is_trapping(op_id, cur_dt) ? slab_mask : NULL);
+                           ca_op_raises_on_cell(CA_OP_KIND_MONOP, op_id, cur_dt) ? slab_mask : NULL);
       cur_dt = ca_lazy_promote_monop(op_id, cur_dt);
     }
   }
   if ( slab_mask ) {
     ca_lazy_arena_release(slab_mask);
   }
+  if ( work ) {
+    memcpy(out, work, slab_n * mo->bytes);
+    ca_lazy_arena_release(work);
+  }
 }
 
 static void
@@ -638,16 +692,7 @@ ca_monop_func_allocate (void *ap)
   if ( ca_monop_is_writable_view(ca->op_id) ) {
     ca_attach(ca->parent);
   }
-  ca->ptr = xmalloc(ca_length(ca));
-  /* CA_OBJECT initialisation for GC safety.  */
-  if ( ca->data_type == CA_OBJECT ) {
-    VALUE *p = (VALUE *) ca->ptr;
-    VALUE zero = SIZE2NUM(0);
-    ca_size_t i;
-    for ( i = 0; i < ca->elements; i++ ) {
-      *p++ = zero;
-    }
-  }
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -676,22 +721,19 @@ ca_monop_func_attach (void *ap)
      Mirrors CAFake.attach.  */
   if ( ca_monop_is_writable_view(ca->op_id) ) {
     ca_attach(ca->parent);
-    ca->ptr = xmalloc(ca_length(ca));
-    /* CA_OBJECT initialisation for GC safety (mirrors CAFake.allocate):
-       zero-init the VALUE cells before any potential GC can observe
-       them.  */
-    if ( ca->data_type == CA_OBJECT ) {
-      VALUE *p = (VALUE *) ca->ptr;
-      VALUE zero = SIZE2NUM(0);
-      ca_size_t i;
-      for ( i = 0; i < ca->elements; i++ ) {
-        *p++ = zero;
-      }
-    }
+    ca->ptr = ca_alloc_cells((CArray *) ca);
     if ( ca_monop_is_cast(ca->op_id) ) {
-      /* Cast parent.ptr (parent data_type) → ca.ptr (cast target data_type).  */
-      ca_cast_block(ca->elements, ca->parent, ca->parent->ptr,
-                    (CArray *) ca, ca->ptr);
+      /* Cast parent.ptr (parent data_type) → ca.ptr (cast target data_type).
+         A cast that raises on NaN skips the masked cells; the parent's
+         mask is attached with the parent.  A raise here is undone by
+         ca_attach, which calls the detach slot once ca->ptr is set. */
+      boolean8_t *m = NULL;
+      if ( ca_monop_cast_refuses_nan(ca->parent->data_type, ca->data_type)
+           && ca_has_mask(ca->parent) ) {
+        m = (boolean8_t *) ca->parent->mask->ptr;
+      }
+      ca_cast_block_with_mask(ca->elements, ca->parent, ca->parent->ptr,
+                              (CArray *) ca, ca->ptr, m);
     }
     else {
       /* byte_swap: memcpy parent.ptr → ca.ptr (same data_type same bytes),
@@ -702,19 +744,11 @@ ca_monop_func_attach (void *ap)
     return;
   }
 
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
   for ( k = 0; k < ca->ndim; k++ ) starts[k] = 0;
-  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
-     soon as the view is, so it must not be handed to the GC as raw
-     xmalloc garbage. */
-  if ( ca->data_type == CA_OBJECT ) {
-    VALUE *p = (VALUE *) ca->ptr;
-    ca_size_t i;
-    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
-  }
   ca_monop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 
@@ -782,7 +816,7 @@ ca_monop_func_fill_data (void *ap, void *ptr)
      data_type (= same bytes for byte_swap, reverse-cast for cast).
      Non-writable monop/monfunc remains read-only.  */
   if ( ! ca_monop_is_writable_view(ca->op_id) ) {
-    rb_raise(rb_eRuntimeError, "CAMonOp is read-only (fill_data)");
+    ca_refuse_read_only();
   }
   {
     int is_cast = ca_monop_is_cast(ca->op_id);
@@ -915,8 +949,9 @@ rb_ca_monop_build (VALUE cary, uint16_t op_id)
      with no boolean kernel reads the 0/1 storage in int64. */
   if ( parent_dt == CA_BOOLEAN && ! ca_monop_is_writable_view(op_id) ) {
     if ( ca_monop_is_widening(op_id) ) {
-      rb_raise(rb_eCADataTypeError,
-               "invalid data type for monop (not implemented)");
+      /* the eager monop reads a boolean with no kernel as int64 (0/1), and
+         names that type in its refusal */
+      ca_op_refuse_unimplemented(cary, CA_INT64, rb_eCADataTypeError);
     }
     if ( ca_monop_kernel_lookup(op_id, CA_BOOLEAN) == ca_monop_not_implement ) {
       target = rb_ca_monop_new(target, CA_MONOP_CAST_BASE + CA_INT64);
@@ -934,8 +969,13 @@ rb_ca_monop_build (VALUE cary, uint16_t op_id)
        ( ca_monop_kernel_lookup(op_id, kernel_in_dt) == ca_monop_not_implement ||
          ( parent_dt == CA_FIXLEN &&
            ca_monop_kernel_lookup(op_id, CA_FIXLEN) == ca_monop_not_implement ) ) ) {
-    rb_raise(rb_eCADataTypeError,
-             "invalid data type for monop (not implemented)");
+    /* the eager monop takes an integer to float64 before it looks for the
+       kernel, and names the type it looked in */
+    ca_op_refuse_unimplemented(cary,
+                               parent_dt == CA_FIXLEN ? CA_FIXLEN
+                               : RTEST(rb_ca_is_integer_type(cary)) ? CA_FLOAT64
+                               : kernel_in_dt,
+                               rb_eCADataTypeError);
   }
 
   /* Insert cast node if the kernel wants a different input data_type.  */
@@ -952,6 +992,7 @@ rb_ca_monop_build (VALUE cary, uint16_t op_id)
 static VALUE
 rb_ca_monop_s_build (VALUE klass, VALUE cary, VALUE op_id_val)
 {
+  /* fits: an operation number from the library's own table */
   uint16_t op_id = (uint16_t) NUM2UINT(op_id_val);
   (void) klass;
   return rb_ca_monop_build(cary, op_id);
@@ -976,7 +1017,7 @@ rb_ca_monop_trapping (VALUE self)
   CAMonOp *mo;
   TypedData_Get_Struct(self, CAMonOp, &camonop_data_type, mo);
   return ( ! ca_monop_is_cast(mo->op_id)
-           && ca_monop_is_trapping(mo->op_id, mo->parent->data_type) )
+           && ca_op_raises_on_cell(CA_OP_KIND_MONOP, mo->op_id, mo->parent->data_type) )
          ? Qtrue : Qfalse;
 }
 
@@ -996,6 +1037,7 @@ rb_ca_monop_op_id (VALUE self)
    because in-place chain eval allocates no scratch; only attach (xfer_all
    → output) and the parent's own xfer_stride alloc, neither of which we
    count here.  */
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_monop_s_reset_scratch_counter (VALUE klass)
 {
@@ -1021,6 +1063,7 @@ rb_ca_monop_s_materialise_count (VALUE klass)
 {
   return SIZE2NUM(ca_monop_materialise_call_count);
 }
+#endif /* CARRAY_DEV_BUILD */
 
 static VALUE
 rb_ca_monop_s_allocate (VALUE klass)
@@ -1108,6 +1151,7 @@ Init_ca_obj_monop (void)
   rb_define_const(rb_cCAMonOp, "OP_RAD_PI",  INT2NUM(CA_MONOP_RAD_PI));
   rb_define_const(rb_cCAMonOp, "OP_SIGN",    INT2NUM(CA_MONOP_SIGN));
   rb_define_const(rb_cCAMonOp, "OP_ARG_I",   INT2NUM(CA_MONOP_ARG_I));
+  rb_define_const(rb_cCAMonOp, "OP_BYTE_SWAP", INT2NUM(CA_MONOP_BYTE_SWAP));
   rb_define_const(rb_cCAMonOp, "CAST_BASE",  INT2NUM(CA_MONOP_CAST_BASE));
 
   rb_define_alloc_func(rb_cCAMonOp, rb_ca_monop_s_allocate);
@@ -1119,10 +1163,10 @@ Init_ca_obj_monop (void)
   rb_define_singleton_method(rb_cCAMonOp, "__build__",
                              rb_ca_monop_s_build, 2);
 
-  /* Lazy-view predicate exposed on CArray (covers CAMonOp and
-     CALazyMarker).  */
-  rb_define_method(rb_cCArray, "__lazy_view__?",
-                   rb_ca_is_lazy_view_p, 0);
+  /* Lazy-view predicate on CArray (covers CAMonOp and CALazyMarker).
+     Protected: the lazy dispatch asks it of the other operands. */
+  rb_define_protected_method(rb_cCArray, "lazy_view?",
+                             rb_ca_is_lazy_view_p, 0);
 
   /* op_id accessor for inspect / dump_tree consumers in Ruby.  */
   rb_define_method(rb_cCAMonOp, "__op_id__",
@@ -1130,6 +1174,7 @@ Init_ca_obj_monop (void)
   rb_define_method(rb_cCAMonOp, "__trapping__", rb_ca_monop_trapping, 0);
 
   /* Test instrumentation (not user-facing API).  */
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCAMonOp, "__reset_scratch_counter__",
                              rb_ca_monop_s_reset_scratch_counter, 0);
   rb_define_singleton_method(rb_cCAMonOp, "__scratch_count__",
@@ -1138,4 +1183,5 @@ Init_ca_obj_monop (void)
                              rb_ca_monop_s_reset_materialise_counter, 0);
   rb_define_singleton_method(rb_cCAMonOp, "__materialise_count__",
                              rb_ca_monop_s_materialise_count, 0);
+#endif
 }