carray 3.0.3 → 3.0.5

data/ext/ca_axis_dispatch.c

@@ -647,15 +647,15 @@ ca_axis_dispatch_percell_gather (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst + j*2)   = *(uint16_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*2, src + j*inner_step, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst + j*4)   = *(uint32_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*4, src + j*inner_step, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst + j*8)   = *(uint64_t *)(src + j*inner_step);
+              __builtin_memcpy(row_dst + j*8, src + j*inner_step, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -672,18 +672,15 @@ ca_axis_dispatch_percell_gather (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst + j*2) =
-                *(uint16_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*2, row_src_base + inner_indices[j]*inner_pstride, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst + j*4) =
-                *(uint32_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*4, row_src_base + inner_indices[j]*inner_pstride, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst + j*8) =
-                *(uint64_t *)(row_src_base + inner_indices[j]*inner_pstride);
+              __builtin_memcpy(row_dst + j*8, row_src_base + inner_indices[j]*inner_pstride, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -761,8 +758,7 @@ ca_axis_dispatch_gather (CArray          *parent,
        so clang lowers to NEON ldp/stp directly (no libc memcpy call). */
     if ( sbytes == 8 ) {
       for ( i = 0; i < n; i++ ) {
-        *(uint64_t *)(out_buf + i*8) =
-          *(uint64_t *)(base + indices[i] * pstride);
+        __builtin_memcpy(out_buf + i*8, base + indices[i] * pstride, 8);
       }
     } else if ( sbytes == 16 ) {
       for ( i = 0; i < n; i++ ) {
@@ -887,15 +883,15 @@ ca_axis_dispatch_percell_scatter (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(dst + j*inner_step) = *(uint16_t *)(row_src + j*2);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*2, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(dst + j*inner_step) = *(uint32_t *)(row_src + j*4);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*4, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(dst + j*inner_step) = *(uint64_t *)(row_src + j*8);
+              __builtin_memcpy(dst + j*inner_step, row_src + j*8, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -912,18 +908,15 @@ ca_axis_dispatch_percell_scatter (CArray          *parent,
             break;
           case 2:
             for (j = 0; j < inner_count; j++)
-              *(uint16_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint16_t *)(row_src + j*2);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*2, 2);
             break;
           case 4:
             for (j = 0; j < inner_count; j++)
-              *(uint32_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint32_t *)(row_src + j*4);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*4, 4);
             break;
           case 8:
             for (j = 0; j < inner_count; j++)
-              *(uint64_t *)(row_dst_base + inner_indices[j]*inner_pstride) =
-                *(uint64_t *)(row_src + j*8);
+              __builtin_memcpy(row_dst_base + inner_indices[j]*inner_pstride, row_src + j*8, 8);
             break;
           default:
             for (j = 0; j < inner_count; j++)
@@ -1158,15 +1151,10 @@ ca_axis_view_attach_owned (void *ap)
   CArray *ca  = (CArray *) ap;
   char   *buf = xmalloc(ca_length(ca) > 0 ? ca_length(ca) : 1);
   void   *args[2];
-  int     tag = 0;
 
   args[0] = ca;
   args[1] = buf;
-  rb_protect(ca_axis_view_fill_owned, (VALUE) args, &tag);
-  if ( tag ) {
-    xfree(buf);
-    rb_jump_tag(tag);
-  }
+  ca_fill_or_xfree(buf, ca_axis_view_fill_owned, (VALUE) args);
   ca->ptr = buf;
 }
 

data/ext/ca_axis_group.c

@@ -283,7 +283,7 @@ group_op_code (VALUE vop)
 #define GACC_XOR \
   ( ((boolean8_t *) co->ptr)[o] ^= (*(boolean8_t *)(p + gw_doff[e]) ? 1 : 0) )
 
-/* __axis_group_reduce__(group_axes, bundles, op) — group-reduces self along
+/* __reduce_by_axis_groups__(group_axes, bundles, op) — group-reduces self along
  * the union of `group_axes` (ascending source-axis indices = the slab) into
  * composite groups described by `bundles`, preserving the band (= non-grouped)
  * axes.  Internal: the Ruby surface is CAGroupIterator.
@@ -352,7 +352,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (metadata, kept alive) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_reduce: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -362,7 +362,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   int       bundle_slot[CA_RANK_MAX][CA_RANK_MAX];
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
-  volatile VALUE keep = rb_ary_new();   /* GC-pin int32 code views */
+  volatile VALUE keep = rb_ary_new();   /* keeps the int32 code views alive */
+  volatile VALUE h_codes[CA_RANK_MAX];  /* holders of the copied code tables */
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -385,18 +386,16 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -682,6 +681,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ALLOCV_END(h_prod);   ALLOCV_END(h_seen);   ALLOCV_END(h_xbuf);
   ALLOCV_END(h_nz);     ALLOCV_END(h_mnaddr); ALLOCV_END(h_mxaddr);
   ALLOCV_END(h_band);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -983,7 +983,7 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
     omask[o] = 1;                                \
   } while (0)
 
-/* The CA_OBJECT lane of __axis_group_scan__.  Every cell calls into Ruby,
+/* The CA_OBJECT lane of __scan_by_axis_groups__.  Every cell calls into Ruby,
    so the walk can raise part way; its state lives in the caller's frame, in
    c->st, and ca_iter_ensure finishes it however this body leaves.  The
    buffers are ALLOCV-backed, so the unwind collects them. */
@@ -1115,9 +1115,9 @@ group_scan_op_code (VALUE vop)
   rb_raise(rb_eArgError, "axis_group_scan: unsupported op :%"PRIsVALUE, rb_id2str(id));
 }
 
-/* __axis_group_scan__(group_axes, bundles, op) — group-keyed segment scan of
+/* __scan_by_axis_groups__(group_axes, bundles, op) — group-keyed segment scan of
  * self over the union of `group_axes` into composite groups described by
- * `bundles` (same argument shape as __axis_group_reduce__).  Internal.
+ * `bundles` (same argument shape as __reduce_by_axis_groups__).  Internal.
  *
  * Unlike the reduce the grouped axes are not collapsed: the result is a new
  * CArray of the same shape as self, each cell holding the running statistic of
@@ -1187,7 +1187,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (same as reduce) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_scan: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -1198,6 +1198,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
   volatile VALUE keep = rb_ary_new();
+  volatile VALUE h_codes[CA_RANK_MAX];
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -1220,18 +1221,16 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -1413,6 +1412,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ALLOCV_END(h_band2); ALLOCV_END(h_code);  ALLOCV_END(h_doff);
   ALLOCV_END(h_moff);  ALLOCV_END(h_addr);  ALLOCV_END(h_accd);
   ALLOCV_END(h_accn);  ALLOCV_END(h_seen);  ALLOCV_END(h_acco);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -1421,8 +1421,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
 void
 Init_ca_axis_group (void)
 {
-  rb_define_method(rb_cCArray, "__axis_group_reduce__",
+  rb_define_method(rb_cCArray, "__reduce_by_axis_groups__",
                    rb_ca_axis_group_reduce, 3);
-  rb_define_method(rb_cCArray, "__axis_group_scan__",
+  rb_define_method(rb_cCArray, "__scan_by_axis_groups__",
                    rb_ca_axis_group_scan, 3);
 }

data/ext/ca_binop_dispatch.c

@@ -29,7 +29,7 @@
 
 /* The kernel table of each op id.  The eager operators hold the tables
    themselves; ca_binop_op_id_of_table maps one back to its op id, so that
-   both ask ca_binop_is_trapping the same question. */
+   both ask ca_op_raises_on_cell the same question. */
 static ca_binop_func_t * const ca_binop_tables[CA_BINOP_COUNT] = {
   [CA_BINOP_ADD]       = ca_binop_add,
   [CA_BINOP_SUB]       = ca_binop_sub,
@@ -116,31 +116,3 @@ ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
   if ( out_r_in_dt ) *out_r_in_dt = common;
 }
 
-/* ------------------------------------------------------------------- */
-/* trapping-op predicate                                                */
-/* ------------------------------------------------------------------- */
-
-int
-ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
-{
-  /* An object cell calls Ruby, which can raise for any op.  Integer
-     DIV / MOD / QUO / FMOD / RCP_MUL raise on a zero divisor, and POW /
-     IPOWER on zero to a negative power.  Float division returns NaN/Inf
-     and does not trap.                                                 */
-  int is_integer = ( common_dt >= CA_INT8 && common_dt <= CA_UINT64 );
-  if ( common_dt == CA_OBJECT ) return 1;
-  if ( ! is_integer ) return 0;
-
-  switch (op_id) {
-    case CA_BINOP_DIV:
-    case CA_BINOP_MOD:
-    case CA_BINOP_QUO:
-    case CA_BINOP_FMOD:
-    case CA_BINOP_RCP_MUL:
-    case CA_BINOP_POW:
-    case CA_BINOP_IPOWER:
-      return 1;
-    default:
-      return 0;
-  }
-}

data/ext/ca_binop_dispatch.h

@@ -147,7 +147,6 @@ void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
    When trapping AND either operand has a mask, xfer_stride must pass
    a slab mask to the kernel so masked cells are skipped (otherwise
    masked-zero divisors crash with SIGFPE).  See §3.4 rev3.            */
-int ca_binop_is_trapping (uint16_t op_id, int8_t common_dt);
 int ca_binop_op_id_of_table (ca_binop_func_t table[]);
 
 #endif /* CA_BINOP_DISPATCH_H */