carray 3.0.0 → 3.0.2

data/ext/ca_axis_group.c

@@ -8,7 +8,7 @@
   reduce dispatch, GroupLabels) is wired in ca_group_iter.c (the `[]` gate and
   the iterator) + `axis_group` (lib/carray/axis_group.rb).  Both kernels are
   written in the general form: several group axes + rank-N categorical (an N-D
-  codes map) via a per-slab-element composite code, native dtype dispatch,
+  codes map) via a per-slab-element composite code, native data type dispatch,
   mask support.  They take pre-built code bundles, so they are independent of
   how the classifier is constructed.
 
@@ -40,7 +40,8 @@
 enum {
   GR_SUM = 0, GR_PROD, GR_MEAN, GR_MIN, GR_MAX,
   GR_VARIANCE, GR_STDDEV, GR_COUNT, GR_ALL, GR_ANY,
-  GR_VARIANCEP, GR_STDDEVP, GR_MINADDR, GR_MAXADDR
+  GR_VARIANCEP, GR_STDDEVP, GR_MINADDR, GR_MAXADDR,
+  GR_ACCUM
 };
 
 static int
@@ -48,6 +49,7 @@ group_op_code (VALUE vop)
 {
   ID id = SYM2ID(vop);
   if      ( id == rb_intern("sum") )      return GR_SUM;
+  else if ( id == rb_intern("accumulate") ) return GR_ACCUM;
   else if ( id == rb_intern("prod") )     return GR_PROD;
   else if ( id == rb_intern("mean") )     return GR_MEAN;
   else if ( id == rb_intern("min") )      return GR_MIN;
@@ -72,14 +74,14 @@ group_op_code (VALUE vop)
    group code, applies the mask, and folds the value into whichever
    accumulator buffers are non-NULL.  Accumulation is always in `double` (or
    counts in ca_size_t), so the op-finalisation below is type-agnostic — only
-   the LOAD is monomorphised per dtype, keeping the inner loop autovectorisable
+   the LOAD is monomorphised per data type, keeping the inner loop autovectorisable
    while avoiding a forced float64 materialise of the (large) source. */
 
 /* GROUP_WALK(T, ACCUM): one CA_FOR_EACH_SLAB pass.  For each slab element it
    computes the composite group code, applies the mask, then runs ACCUM with
    `v` (the element, widened to double) and `o` (the output flat index =
    code * band + band_flat) in scope.  ACCUM is the only per-op-varying part,
-   so the dtype is monomorphised once per type while sum / mean / variance /
+   so the data type is monomorphised once per type while sum / mean / variance /
    ... reuse the same walk. */
 /* Sentinel o-code for a slab element whose composite code is out of range
    (excluded categorical), stored in the precomputed plan below. */
@@ -108,16 +110,20 @@ group_op_code (VALUE vop)
     ca_size_t  *gw_ocode = NULL, *gw_doff = NULL, *gw_moff = NULL,             \
                *gw_gaddr = NULL;                                               \
     int         gw_ready = 0;                                                  \
+    /* freed by the unwind too: the walk can raise between here and the        \
+       releases below (a gather that cannot convert a cell, and in the object  \
+       lane a callback into Ruby). */                                          \
+    volatile VALUE gw_h1 = 0, gw_h2 = 0, gw_h3 = 0, gw_h4 = 0;                 \
     int         gw_need_addr = ( op == GR_MINADDR || op == GR_MAXADDR );       \
     CA_FOR_EACH_SLAB(st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {    \
       int8_t    sndim = st.slab_ndim;                                          \
       ca_size_t SE    = st.slab_elements;                                      \
       if ( SE > 0 ) {                                                          \
         if ( ! gw_ready ) {                                                    \
-          gw_ocode = ALLOC_N(ca_size_t, SE);                                   \
-          gw_doff  = ALLOC_N(ca_size_t, SE);                                   \
-          gw_moff  = ALLOC_N(ca_size_t, SE);                                   \
-          gw_gaddr = ALLOC_N(ca_size_t, SE);                                   \
+          gw_ocode = ALLOCV_N(ca_size_t, gw_h1, SE);                           \
+          gw_doff  = ALLOCV_N(ca_size_t, gw_h2, SE);                           \
+          gw_moff  = ALLOCV_N(ca_size_t, gw_h3, SE);                           \
+          gw_gaddr = ALLOCV_N(ca_size_t, gw_h4, SE);                           \
           ca_size_t sidx[CA_RANK_MAX];                                         \
           for ( int8_t k = 0; k < sndim; k++ ) sidx[k] = 0;                    \
           for ( ca_size_t e = 0; e < SE; e++ ) {                               \
@@ -156,22 +162,96 @@ group_op_code (VALUE vop)
           ca_size_t oc = gw_ocode[e];                                          \
           if ( oc == GW_SKIP ) continue;                                       \
           if ( m && m[ gw_moff[e] ] ) continue;                                \
-          double    v = (double) ( *(T *)(p + gw_doff[e]) );                   \
+          T         rv = *(T *)(p + gw_doff[e]);                              \
+          double    v = (double) rv;                                           \
           ca_size_t o = oc + b;                                                \
           ca_size_t gaddr = gw_gaddr[e];                                       \
           ACCUM;                                                               \
-          (void) v; (void) o; (void) gaddr;                                    \
+          (void) rv; (void) v; (void) o; (void) gaddr;                         \
         }                                                                      \
       }                                                                        \
       b++;                                                                     \
     }                                                                          \
-    if ( gw_ocode ) xfree(gw_ocode);                                          \
-    if ( gw_doff )  xfree(gw_doff);                                           \
-    if ( gw_moff )  xfree(gw_moff);                                           \
-    if ( gw_gaddr ) xfree(gw_gaddr);                                          \
+    ALLOCV_END(gw_h1); ALLOCV_END(gw_h2);                                      \
+    ALLOCV_END(gw_h3); ALLOCV_END(gw_h4);                                      \
   } while (0)
 
-/* Run one walk over every supported native dtype.  Dispatched on the source
+/* GROUP_DISPATCH_T(ACCUM_T): the same walk, for an accumulator that needs to
+   name the source type -- one that keeps its answer in that type instead of
+   widening to double.  ACCUM_T is invoked as ACCUM_T(T). */
+#define GROUP_DISPATCH_T(ACCUM_T)                                              \
+  switch ( ca->data_type ) {                                                   \
+  case CA_BOOLEAN: GROUP_WALK(boolean8_t, ACCUM_T(boolean8_t)); break;         \
+  case CA_INT8:    GROUP_WALK(int8_t,   ACCUM_T(int8_t));   break;             \
+  case CA_UINT8:   GROUP_WALK(uint8_t,  ACCUM_T(uint8_t));  break;             \
+  case CA_INT16:   GROUP_WALK(int16_t,  ACCUM_T(int16_t));  break;             \
+  case CA_UINT16:  GROUP_WALK(uint16_t, ACCUM_T(uint16_t)); break;             \
+  case CA_INT32:   GROUP_WALK(int32_t,  ACCUM_T(int32_t));  break;             \
+  case CA_UINT32:  GROUP_WALK(uint32_t, ACCUM_T(uint32_t)); break;             \
+  case CA_INT64:   GROUP_WALK(int64_t,  ACCUM_T(int64_t));  break;             \
+  case CA_UINT64:  GROUP_WALK(uint64_t, ACCUM_T(uint64_t)); break;             \
+  case CA_FLOAT32: GROUP_WALK(float,    ACCUM_T(float));    break;             \
+  case CA_FLOAT64: GROUP_WALK(double,   ACCUM_T(double));   break;             \
+  default: break;                                                              \
+  }
+
+/* An extremum keeps the source data type: its magnitude never grows, so
+   widening to double buys nothing and costs exactness -- an int64 past 2^53
+   came back rounded, and a genuinely larger value could lose the comparison
+   to a smaller one that rounded to the same double.  The scan siblings
+   (GROUP_SCAN_EXTREMUM_WALK) already held a native accumulator; these are the
+   reduce twins.
+
+   A NaN loses every contest, as it does in CArray's own min / max: it is held
+   only while nothing else has landed, the first number displaces it, and a
+   group of nothing but NaN answers NaN (for a position, UNDEF).  `v` is the
+   widened load, so testing it for NaN is the same question for every source
+   type and costs an integer body nothing.  seen_num[] says whether a number
+   has landed; cnt[] still says whether anything has. */
+#define GMINMAX(T, A, CMP)                                                     \
+  do {                                                                         \
+    A *acc = (A *) co->ptr;                                                     \
+    A  av  = (A) rv;                                                            \
+    if ( v == v ) {                                                             \
+      if ( ! seen_num[o] ) { acc[o] = av; seen_num[o] = 1; }                     \
+      else if ( av CMP acc[o] ) acc[o] = av;                                     \
+    } else if ( cnt[o] == 0 ) acc[o] = av;                                       \
+    cnt[o] += 1;                                                                \
+  } while (0)
+
+/* Boolean answers as its 0/1 numeric storage, which is what CArray#min / #max
+   do with a boolean array -- the boolean-returning twins are all / any. Every
+   other type answers in its own. */
+#define GROUP_DISPATCH_EXTREMUM(CMP)                                           \
+  switch ( ca->data_type ) {                                                   \
+  case CA_BOOLEAN: GROUP_WALK(boolean8_t, GMINMAX(boolean8_t, uint64_t, CMP)); break; \
+  case CA_INT8:    GROUP_WALK(int8_t,   GMINMAX(int8_t,   int8_t,   CMP)); break; \
+  case CA_UINT8:   GROUP_WALK(uint8_t,  GMINMAX(uint8_t,  uint8_t,  CMP)); break; \
+  case CA_INT16:   GROUP_WALK(int16_t,  GMINMAX(int16_t,  int16_t,  CMP)); break; \
+  case CA_UINT16:  GROUP_WALK(uint16_t, GMINMAX(uint16_t, uint16_t, CMP)); break; \
+  case CA_INT32:   GROUP_WALK(int32_t,  GMINMAX(int32_t,  int32_t,  CMP)); break; \
+  case CA_UINT32:  GROUP_WALK(uint32_t, GMINMAX(uint32_t, uint32_t, CMP)); break; \
+  case CA_INT64:   GROUP_WALK(int64_t,  GMINMAX(int64_t,  int64_t,  CMP)); break; \
+  case CA_UINT64:  GROUP_WALK(uint64_t, GMINMAX(uint64_t, uint64_t, CMP)); break; \
+  case CA_FLOAT32: GROUP_WALK(float,    GMINMAX(float,    float,    CMP)); break; \
+  case CA_FLOAT64: GROUP_WALK(double,   GMINMAX(double,   double,   CMP)); break; \
+  default: break;                                                              \
+  }
+
+#define GMINMAXADDR(T, CMP, ADDR)                                              \
+  do {                                                                         \
+    T *acc = (T *) xbuf;                                                        \
+    if ( v == v && ( ! seen_num[o] || rv CMP acc[o] ) ) {                        \
+      acc[o] = rv;                                                              \
+      ADDR[o] = (int64_t) ( band_addr[b] + gaddr );                             \
+      seen_num[o] = 1;                                                          \
+    }                                                                           \
+    cnt[o] += 1;                                                                \
+  } while (0)
+#define GMINADDR(T) GMINMAXADDR(T, <, mnaddr)
+#define GMAXADDR(T) GMINMAXADDR(T, >, mxaddr)
+
+/* Run one walk over every supported native data type.  Dispatched on the source
    data_type so the inner loop stays monomorphic (no forced float64 cast). */
 #define GROUP_DISPATCH(ACCUM)                                                  \
   switch ( ca->data_type ) {                                                   \
@@ -189,6 +269,19 @@ group_op_code (VALUE vop)
   default: break;                                                              \
   }
 
+/* `accumulate` is the one op that folds in the SOURCE's own type instead of in
+   double, so it wraps at that width exactly as CArray#accumulate does.  It
+   folds straight into the (zeroed) output — whose data type is the source's —
+   so an empty group already holds the additive identity 0 and needs no mask.
+   The type cannot travel inside a GROUP_WALK ACCUM argument (an argument's own
+   tokens are not substituted for the macro's parameters), so the walk below
+   names its type twice. */
+#define GACC_ADD(T) ( ((T *) co->ptr)[o] += *(T *)(p + gw_doff[e]) )
+/* A boolean accumulate is XOR parity, matching the core: the result stays
+   boolean, so a second `true` has nowhere to carry into. */
+#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
  * the union of `group_axes` (ascending source-axis indices = the slab) into
  * composite groups described by `bundles`, preserving the band (= non-grouped)
@@ -240,7 +333,6 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   int8_t    axes[CA_RANK_MAX];
   char      is_group[CA_RANK_MAX];
   for ( int8_t i = 0; i < src->ndim; i++ ) is_group[i] = 0;
-  ca_size_t group_prod = 1;
   for ( long i = 0; i < ngroup; i++ ) {
     int a = NUM2INT(RARRAY_AREF(vgaxes, i));
     if ( a < 0 || a >= src->ndim ) {
@@ -254,7 +346,6 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     }
     is_group[a]  = 1;
     axes[i]      = (int8_t) a;
-    group_prod  *= src->dim[a];
   }
 
   /* --- bundles: small per-group code tables (metadata, kept alive) --- */
@@ -288,12 +379,25 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       rb_raise(rb_eArgError, "axis_group_reduce: bundle k must be positive");
     }
 
-    /* int32 view of the codes (metadata-sized, O(consumed-axis dims)) */
+    /* The code table is copied out and the source let go of at once, rather
+       than held attached for the length of the walk. Everything between here
+       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. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    ca_attach(bundle_ca[bi]);
-    bundle_codes[bi] = (int32_t *) bundle_ca[bi]->ptr;
+    {
+      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_attach(bundle_ca[bi]);
+      memcpy(RSTRING_PTR(vbuf), bundle_ca[bi]->ptr, nbytes);
+      ca_detach(bundle_ca[bi]);
+      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
+    }
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -348,63 +452,88 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     }
   }
 
-  /* --- band layout + output shape [K_total, *band_dims] --- */
-  ca_size_t band = (group_prod > 0) ? (src->elements / group_prod) : 0;
+  /* --- band layout + output shape [K_total, *band_dims] ---
+     band is the product of the band dims, taken directly rather than as
+     src->elements / group_prod: a zero-length *group* axis makes group_prod
+     zero, and the division has to answer something. Answering 0 made nout 0
+     while the output really had K_total x band cells, so every finalisation
+     loop below ran zero times and the freshly zeroed buffer went back to the
+     caller unmasked -- a mean, a min and a variance all reported as 0.0.
+     Taken directly, nout == co->elements for every shape, and the group with
+     no cell in it takes the same empty-group path as any other. */
+  ca_size_t band = 1;
   ca_size_t odim[CA_RANK_MAX];
   int8_t    ondim = 1;
   odim[0] = K_total;
   for ( int8_t i = 0; i < src->ndim; i++ ) {
-    if ( ! is_group[i] ) odim[ondim++] = src->dim[i];
+    if ( ! is_group[i] ) { odim[ondim++] = src->dim[i]; band *= src->dim[i]; }
   }
   ca_size_t nout = K_total * band;
 
-  /* --- supported dtype gate (before any allocation) --- */
+  /* --- supported data type gate (before any allocation) --- */
   ca = src;
   switch ( src->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:
   case CA_FLOAT32: case CA_FLOAT64: break;
   default:
-    for ( int bi = 0; bi < n_bundles; bi++ ) ca_detach(bundle_ca[bi]);
     rb_raise(rb_eRuntimeError,
              "axis_group_reduce: unsupported source data_type %d",
              src->data_type);
   }
 
-  /* output dtype per op */
+  /* output data type per op */
   int8_t out_dt = CA_FLOAT64;
   if      ( op == GR_COUNT )              out_dt = CA_INT64;
   else if ( op == GR_MINADDR || op == GR_MAXADDR ) out_dt = CA_INT64;
   else if ( op == GR_ALL || op == GR_ANY ) out_dt = CA_BOOLEAN;
+  else if ( op == GR_ACCUM )              out_dt = src->data_type;
+  else if ( op == GR_MIN || op == GR_MAX )
+    out_dt = ( src->data_type == CA_BOOLEAN ) ? CA_UINT64 : src->data_type;
   VALUE vout = rb_carray_new(out_dt, ondim, odim, 0, NULL);
   GetCArray(vout, co);
 
   /* --- accumulator buffers (only those the op needs; all O(nout)) --- */
-  ca_size_t *cnt   = ALLOC_N(ca_size_t, nout);  MEMZERO(cnt, ca_size_t, nout);
-  double    *sum   = NULL, *sumsq = NULL, *prod = NULL, *mn = NULL, *mx = NULL;
+  /* Scratch that the unwind collects. A raise anywhere in the walk -- an
+     object-lane callback into Ruby, a gather that cannot convert a cell --
+     jumps over every release below, so these ride ALLOCV rather than plain
+     malloc: the temporary buffer behind each holder is freed whether the
+     function returns or unwinds. */
+  volatile VALUE h_cnt = 0, h_sum = 0, h_sumsq = 0, h_prod = 0, h_seen = 0,
+                 h_xbuf = 0, h_nz = 0, h_mnaddr = 0, h_mxaddr = 0, h_band = 0;
+  ca_size_t *cnt   = ALLOCV_N(ca_size_t, h_cnt, nout);
+  MEMZERO(cnt, ca_size_t, nout);
+  double    *sum   = NULL, *sumsq = NULL, *prod = NULL;
+  boolean8_t *seen_num = NULL;       /* has a number (not a NaN) landed here? */
+  char      *xbuf  = NULL;           /* running extremum, in the source type */
   ca_size_t *nz    = NULL;
   int64_t   *mnaddr = NULL, *mxaddr = NULL;   /* flat source addr of min / max */
   ca_size_t *band_addr = NULL;                /* raveled addr of each band cell */
   if ( op == GR_SUM || op == GR_MEAN || op == GR_VARIANCE || op == GR_STDDEV ||
        op == GR_VARIANCEP || op == GR_STDDEVP ) {
-    sum = ALLOC_N(double, nout);  MEMZERO(sum, double, nout);
+    sum = ALLOCV_N(double, h_sum, nout);  MEMZERO(sum, double, nout);
   }
   if ( op == GR_PROD ) {
-    prod = ALLOC_N(double, nout);
+    prod = ALLOCV_N(double, h_prod, nout);
     for ( ca_size_t o = 0; o < nout; o++ ) prod[o] = 1.0;
   }
-  if ( op == GR_MIN || op == GR_MINADDR ) {
-    mn = ALLOC_N(double, nout);
-    for ( ca_size_t o = 0; o < nout; o++ ) mn[o] = HUGE_VAL;
+  if ( op == GR_MIN || op == GR_MAX ||
+       op == GR_MINADDR || op == GR_MAXADDR ) {
+    seen_num = ALLOCV_N(boolean8_t, h_seen, nout);
+    MEMZERO(seen_num, boolean8_t, nout);
+  }
+  if ( op == GR_MIN || op == GR_MAX ) {
+    /* the walk writes the extremum straight into the output, in its own type */
+    MEMZERO(co->ptr, char, (size_t) nout * co->bytes);
   }
-  if ( op == GR_MAX || op == GR_MAXADDR ) {
-    mx = ALLOC_N(double, nout);
-    for ( ca_size_t o = 0; o < nout; o++ ) mx[o] = -HUGE_VAL;
+  if ( op == GR_MINADDR || op == GR_MAXADDR ) {
+    xbuf = ALLOCV_N(char, h_xbuf, (size_t) nout * src->bytes);
+    MEMZERO(xbuf, char, (size_t) nout * src->bytes);
   }
-  if ( op == GR_MINADDR ) { mnaddr = ALLOC_N(int64_t, nout); MEMZERO(mnaddr, int64_t, nout); }
-  if ( op == GR_MAXADDR ) { mxaddr = ALLOC_N(int64_t, nout); MEMZERO(mxaddr, int64_t, nout); }
+  if ( op == GR_MINADDR ) { mnaddr = ALLOCV_N(int64_t, h_mnaddr, nout); MEMZERO(mnaddr, int64_t, nout); }
+  if ( op == GR_MAXADDR ) { mxaddr = ALLOCV_N(int64_t, h_mxaddr, nout); MEMZERO(mxaddr, int64_t, nout); }
   if ( op == GR_ALL || op == GR_ANY ) {
-    nz = ALLOC_N(ca_size_t, nout);  MEMZERO(nz, ca_size_t, nout);
+    nz = ALLOCV_N(ca_size_t, h_nz, nout);  MEMZERO(nz, ca_size_t, nout);
   }
 
   /* min_addr / max_addr need the flat raveled source address of each cell.
@@ -420,7 +549,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     int band_axis[CA_RANK_MAX]; int nband_axes = 0;
     for ( int8_t k = 0; k < src->ndim; k++ )
       if ( ! is_group[k] ) band_axis[nband_axes++] = k;
-    band_addr = ALLOC_N(ca_size_t, band > 0 ? band : 1);
+    band_addr = ALLOCV_N(ca_size_t, h_band, band > 0 ? band : 1);
     for ( ca_size_t bb = 0; bb < band; bb++ ) {
       ca_size_t rem = bb, addr = 0;
       for ( int j = nband_axes - 1; j >= 0; j-- ) {     /* last band axis fastest */
@@ -432,7 +561,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     }
   }
 
-  /* --- compute pass(es), native dtype dispatch, no forced float64 cast ---
+  /* --- compute pass(es), native data type dispatch, no forced float64 cast ---
      variance / stddev use a centred two-pass (= matches CArray's own
      variance, avoids the one-pass sumsq cancellation that breaks ε-close
      for small near-constant groups).  Pass 1 fills sum + cnt; sum is then
@@ -443,34 +572,35 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     GROUP_DISPATCH( cnt[o] += 1; sum[o] += v; );
     for ( ca_size_t o = 0; o < nout; o++ )
       if ( cnt[o] > 0 ) sum[o] /= (double) cnt[o];   /* sum -> mean */
-    sumsq = ALLOC_N(double, nout);  MEMZERO(sumsq, double, nout);
+    sumsq = ALLOCV_N(double, h_sumsq, nout);  MEMZERO(sumsq, double, nout);
     GROUP_DISPATCH( { double _d = v - sum[o]; sumsq[o] += _d * _d; } );
   }
-  else if ( op == GR_MINADDR ) {
-    GROUP_DISPATCH(
-      cnt[o] += 1;
-      if ( v < mn[o] ) {
-        ca_size_t faddr = band_addr[b] + gaddr;
-        mn[o] = v; mnaddr[o] = (int64_t) faddr;
-      }
-    );
-  }
-  else if ( op == GR_MAXADDR ) {
-    GROUP_DISPATCH(
-      cnt[o] += 1;
-      if ( v > mx[o] ) {
-        ca_size_t faddr = band_addr[b] + gaddr;
-        mx[o] = v; mxaddr[o] = (int64_t) faddr;
-      }
-    );
+  else if ( op == GR_MINADDR ) { GROUP_DISPATCH_T(GMINADDR); }
+  else if ( op == GR_MAXADDR ) { GROUP_DISPATCH_T(GMAXADDR); }
+  else if ( op == GR_MIN )     { GROUP_DISPATCH_EXTREMUM(<); }
+  else if ( op == GR_MAX )     { GROUP_DISPATCH_EXTREMUM(>); }
+  else if ( op == GR_ACCUM ) {
+    MEMZERO(co->ptr, char, (size_t) nout * co->bytes);
+    switch ( ca->data_type ) {
+    case CA_BOOLEAN: GROUP_WALK(boolean8_t, GACC_XOR);           break;
+    case CA_INT8:    GROUP_WALK(int8_t,   GACC_ADD(int8_t));     break;
+    case CA_UINT8:   GROUP_WALK(uint8_t,  GACC_ADD(uint8_t));    break;
+    case CA_INT16:   GROUP_WALK(int16_t,  GACC_ADD(int16_t));    break;
+    case CA_UINT16:  GROUP_WALK(uint16_t, GACC_ADD(uint16_t));   break;
+    case CA_INT32:   GROUP_WALK(int32_t,  GACC_ADD(int32_t));    break;
+    case CA_UINT32:  GROUP_WALK(uint32_t, GACC_ADD(uint32_t));   break;
+    case CA_INT64:   GROUP_WALK(int64_t,  GACC_ADD(int64_t));    break;
+    case CA_UINT64:  GROUP_WALK(uint64_t, GACC_ADD(uint64_t));   break;
+    case CA_FLOAT32: GROUP_WALK(float,    GACC_ADD(float));      break;
+    case CA_FLOAT64: GROUP_WALK(double,   GACC_ADD(double));     break;
+    default: break;
+    }
   }
   else {
     GROUP_DISPATCH(
       cnt[o] += 1;
       if ( sum )  sum[o]  += v;
       if ( prod ) prod[o] *= v;
-      if ( mn )   { if ( v < mn[o] ) mn[o] = v; }
-      if ( mx )   { if ( v > mx[o] ) mx[o] = v; }
       if ( nz )   { if ( v != 0.0 ) nz[o] += 1; }
     );
   }
@@ -498,10 +628,20 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     int64_t *out  = (int64_t *) co->ptr;
     int64_t *addr = ( op == GR_MINADDR ) ? mnaddr : mxaddr;
     for ( ca_size_t o = 0; o < nout; o++ ) {
-      if ( cnt[o] == 0 ) { out[o] = 0; MARK_UNDEF(o); }   /* empty -> UNDEF */
+      /* Nothing present, or nothing but NaN: either way no cell here won,
+         and the core answers UNDEF for both. */
+      if ( cnt[o] == 0 || ! seen_num[o] ) { out[o] = 0; MARK_UNDEF(o); }
       else out[o] = addr[o];
     }
   }
+  else if ( op == GR_ACCUM ) {
+    /* already folded in place, in the source's own type; empty groups hold 0 */
+  }
+  else if ( op == GR_MIN || op == GR_MAX ) {
+    /* the walk wrote the extremum in place, in the source's own type; a group
+       with no cell in it has nothing to report */
+    for ( ca_size_t o = 0; o < nout; o++ ) if ( cnt[o] == 0 ) MARK_UNDEF(o);
+  }
   else if ( op == GR_ALL ) {
     boolean8_t *out = (boolean8_t *) co->ptr;    /* empty -> true (vacuous) */
     for ( ca_size_t o = 0; o < nout; o++ )
@@ -522,12 +662,6 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
         if ( cnt[o] == 0 ) { out[o] = 0.0; MARK_UNDEF(o); }
         else out[o] = sum[o] / (double) cnt[o];
         break;
-      case GR_MIN:
-        if ( cnt[o] == 0 ) { out[o] = 0.0; MARK_UNDEF(o); } else out[o] = mn[o];
-        break;
-      case GR_MAX:
-        if ( cnt[o] == 0 ) { out[o] = 0.0; MARK_UNDEF(o); } else out[o] = mx[o];
-        break;
       case GR_VARIANCE:
       case GR_STDDEV:
         if ( cnt[o] == 0 ) { out[o] = 0.0; MARK_UNDEF(o); }
@@ -546,17 +680,10 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   }
   #undef MARK_UNDEF
 
-  for ( int bi = 0; bi < n_bundles; bi++ ) ca_detach(bundle_ca[bi]);
-  xfree(cnt);
-  if ( sum ) xfree(sum);
-  if ( sumsq ) xfree(sumsq);
-  if ( prod ) xfree(prod);
-  if ( mn ) xfree(mn);
-  if ( mx ) xfree(mx);
-  if ( nz ) xfree(nz);
-  if ( mnaddr ) xfree(mnaddr);
-  if ( mxaddr ) xfree(mxaddr);
-  if ( band_addr ) xfree(band_addr);
+  ALLOCV_END(h_cnt);    ALLOCV_END(h_sum);    ALLOCV_END(h_sumsq);
+  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);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -722,10 +849,10 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
   }
 
 /* GROUP_SCAN_EXTREMUM_WALK(T, CMP): running extremum (cummax / cummin).  The
-   extremum keeps the source dtype (its magnitude never grows), so it holds a
+   extremum keeps the source data type (its magnitude never grows), so it holds a
    native T accumulator, not a widened double.  The first member of a group
    emits its own value: a per-group `seen` byte initialises the accumulator
-   lazily on first hit — no sentinel like HUGE_VAL, which an integer dtype could
+   lazily on first hit — no sentinel like HUGE_VAL, which an integer data type could
    not represent.  CMP is > for max, < for min: a later member replaces the
    running extremum when `rv CMP acc`.  A cell masked within its group holds the
    current extremum once a member has been seen (output NOT masked, like sum);
@@ -740,7 +867,8 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
     boolean8_t *m;                                                            \
     ca_size_t   b = 0;                                                        \
     int         ready = 0;                                                    \
-    T          *acce = ALLOC_N(T, K_total);                                   \
+    volatile VALUE h_acce = 0;   /* freed by the unwind if the walk raises */ \
+    T          *acce = ALLOCV_N(T, h_acce, K_total);                          \
     T          *outp = (T *) co->ptr;                                         \
     CA_FOR_EACH_SLAB(st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {   \
       ca_size_t SE = st.slab_elements;                                        \
@@ -773,7 +901,7 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
       }                                                                       \
       b++;                                                                    \
     }                                                                         \
-    xfree(acce);                                                              \
+    ALLOCV_END(h_acce);                                                       \
   } while (0)
 
 #define GROUP_SCAN_EXTREMUM_DISPATCH(CMP)                                     \
@@ -863,18 +991,18 @@ group_scan_op_code (VALUE vop)
  * its group up to and including that cell, in row-major position order along
  * the grouped axes (per band).
 
-   op / output dtype:
+   op / output data type:
      :cumsum   -> float64, inclusive within-group running sum.
      :cumprod  -> float64, inclusive within-group running product (init 1.0;
                   float64 like cumsum since the product grows).
-     :cummax   -> source dtype, running within-group maximum (extrema do not
-                  grow magnitude, so the dtype is preserved; int stays int).
-     :cummin   -> source dtype, running within-group minimum.
+     :cummax   -> source data type, running within-group maximum (extrema do not
+                  grow magnitude, so the data type is preserved; int stays int).
+     :cummin   -> source data type, running within-group minimum.
      :cumcount -> int64, 1-based within-group running count of present cells
                   (matching the core CArray#cumcount): the first present member
                   of a group emits 1, the next 2, ...
    cumsum / cumprod keep float64 (matching the reduce siblings sum / prod);
-   integer-preserving sum / prod is a deliberate non-goal (overflow / dtype
+   integer-preserving sum / prod is a deliberate non-goal (overflow / data type
    consistency), as on the reduce side.  A CA_OBJECT source emits a CA_OBJECT
    result for cumsum / cumprod / cummax / cummin (cumcount stays int64).
 
@@ -954,11 +1082,25 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       rb_raise(rb_eArgError, "axis_group_scan: bundle k must be positive");
     }
 
+    /* The code table is copied out and the source let go of at once, rather
+       than held attached for the length of the walk. Everything between here
+       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. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    ca_attach(bundle_ca[bi]);
-    bundle_codes[bi] = (int32_t *) bundle_ca[bi]->ptr;
+    {
+      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_attach(bundle_ca[bi]);
+      memcpy(RSTRING_PTR(vbuf), bundle_ca[bi]->ptr, nbytes);
+      ca_detach(bundle_ca[bi]);
+      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
+    }
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -1011,21 +1153,20 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
 
   ca_size_t band = (group_prod > 0) ? (src->elements / group_prod) : 0;
 
-  /* --- supported dtype gate (CA_OBJECT handled by its own lane below) --- */
+  /* --- supported data type gate (CA_OBJECT handled by its own lane below) --- */
   ca = src;
   switch ( src->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:
   case CA_FLOAT32: case CA_FLOAT64: case CA_OBJECT: break;
   default:
-    for ( int bi = 0; bi < n_bundles; bi++ ) ca_detach(bundle_ca[bi]);
     rb_raise(rb_eRuntimeError,
              "axis_group_scan: unsupported source data_type %d",
              src->data_type);
   }
 
-  /* --- output dtype per op: cumcount int64; cumsum / cumprod float64 (object
-     source -> object); cummax / cummin preserve the source dtype (object ->
+  /* --- output data type per op: cumcount int64; cumsum / cumprod float64 (object
+     source -> object); cummax / cummin preserve the source data type (object ->
      object). --- */
   int8_t out_dt;
   if      ( op == GS_CUMCOUNT )                        { out_dt = CA_INT64; }
@@ -1055,7 +1196,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   int band_axis[CA_RANK_MAX]; int nband_axes = 0;
   for ( int8_t k = 0; k < src->ndim; k++ )
     if ( ! is_group[k] ) band_axis[nband_axes++] = k;
-  ca_size_t *band_addr = ALLOC_N(ca_size_t, band > 0 ? band : 1);
+  volatile VALUE h_band2 = 0;
+  ca_size_t *band_addr = ALLOCV_N(ca_size_t, h_band2, band > 0 ? band : 1);
   for ( ca_size_t bb = 0; bb < band; bb++ ) {
     ca_size_t rem = bb, addr = 0;
     for ( int j = nband_axes - 1; j >= 0; j-- ) {
@@ -1072,13 +1214,20 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
      member / object identity init) are all tiny; acco (object running VALUE) is
      allocated only for the object arithmetic / extremum ops. */
   ca_size_t  plan_n  = (group_prod > 0) ? group_prod : 1;
-  ca_size_t *sw_code = ALLOC_N(ca_size_t, plan_n);
-  ca_size_t *sw_doff = ALLOC_N(ca_size_t, plan_n);
-  ca_size_t *sw_moff = ALLOC_N(ca_size_t, plan_n);
-  ca_size_t *sw_addr = ALLOC_N(ca_size_t, plan_n);
-  double    *accd    = ALLOC_N(double,    K_total);
-  ca_size_t *accn    = ALLOC_N(ca_size_t, K_total);
-  char      *seen    = ALLOC_N(char,      K_total);
+  /* Scratch that the unwind collects. The object lane calls back into Ruby
+     for every cell, so a raise in the middle of the walk is ordinary here --
+     an operand that will not coerce, a <=> that answers nil -- and it jumps
+     over every release below. ALLOCV frees the buffer behind each holder
+     whether the function returns or unwinds. */
+  volatile VALUE h_code = 0, h_doff = 0, h_moff = 0, h_addr = 0,
+                 h_accd = 0, h_accn = 0, h_seen = 0, h_acco = 0;
+  ca_size_t *sw_code = ALLOCV_N(ca_size_t, h_code, plan_n);
+  ca_size_t *sw_doff = ALLOCV_N(ca_size_t, h_doff, plan_n);
+  ca_size_t *sw_moff = ALLOCV_N(ca_size_t, h_moff, plan_n);
+  ca_size_t *sw_addr = ALLOCV_N(ca_size_t, h_addr, plan_n);
+  double    *accd    = ALLOCV_N(double,    h_accd, K_total);
+  ca_size_t *accn    = ALLOCV_N(ca_size_t, h_accn, K_total);
+  char      *seen    = ALLOCV_N(char,      h_seen, K_total);
   VALUE     *acco    = NULL;
   double     acc_init = ( op == GS_CUMPROD ) ? 1.0 : 0.0;
 
@@ -1101,7 +1250,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     }
     else {                                        /* object running VALUE */
       VALUE *outo = (VALUE *) co->ptr;
-      acco = ALLOC_N(VALUE, K_total);
+      acco = ALLOCV_N(VALUE, h_acco, K_total);
       switch ( op ) {
       case GS_CUMSUM:
         /* Identity 0 (matching the core object cumsum): a group's acc is lazily
@@ -1153,7 +1302,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       }
     }
   }
-  else {                                          /* native dtype dispatch */
+  else {                                          /* native data type dispatch */
     switch ( op ) {
     case GS_CUMSUM: {
       double *outd = (double *) co->ptr;
@@ -1183,16 +1332,9 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   }
   #undef MARK_OUT_UNDEF
 
-  for ( int bi = 0; bi < n_bundles; bi++ ) ca_detach(bundle_ca[bi]);
-  xfree(band_addr);
-  xfree(sw_code);
-  xfree(sw_doff);
-  xfree(sw_moff);
-  xfree(sw_addr);
-  xfree(accd);
-  xfree(accn);
-  xfree(seen);
-  if ( acco ) xfree(acco);
+  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);
 
   RB_GC_GUARD(keep);
   return vout;