carray 3.0.1 → 3.0.3

data/ext/ca_axis_group.c

@@ -33,6 +33,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* CA_EXTREMUM_REPLACES, ca_obj_extremum_replaces */
 #include "ca_kernel_iterator.h"
 #include <math.h>
 
@@ -64,8 +65,8 @@ group_op_code (VALUE vop)
   else if ( id == rb_intern("max_addr") ) return GR_MAXADDR;
   else if ( id == rb_intern("all") )      return GR_ALL;
   else if ( id == rb_intern("any") )      return GR_ANY;
-  rb_raise(rb_eArgError, "axis_group_reduce: unsupported op :%s",
-           rb_id2name(id));
+  rb_raise(rb_eArgError, "axis_group_reduce: unsupported op :%"PRIsVALUE,
+           rb_id2str(id));
 }
 
 /* ---- per-slab-element composite-code walk, templated on the load type ----
@@ -110,16 +111,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++ ) {                               \
@@ -158,21 +163,95 @@ 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)
 
+/* 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.  The replacement test is the
+   shared CA_EXTREMUM_REPLACES; the first member is taken whatever it is.
+   seen_num[] says whether a number has landed (the positions read it);
+   cnt[] says whether anything has. */
+#define GMINMAX(T, A, CMP)                                                     \
+  do {                                                                         \
+    A *acc = (A *) co->ptr;                                                     \
+    A  av  = (A) rv;                                                            \
+    if ( cnt[o] == 0 || CA_EXTREMUM_REPLACES(av, acc[o], CMP) ) acc[o] = av;    \
+    if ( v == v ) seen_num[o] = 1;                                              \
+    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)                                                  \
@@ -232,7 +311,7 @@ group_op_code (VALUE vop)
    Empty / all-masked groups follow the CArray zero-contribution contract: an
    identity-bearing op returns its identity (sum 0, prod 1, count 0, all true,
    any false), a ratio / extremum returns UNDEF.  Sample variance / stddev:
-   n == 0 UNDEF, n == 1 -> 0.0, n >= 2 the formula.
+   n < 2 UNDEF, n >= 2 the formula.
 */
 static VALUE
 rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
@@ -243,7 +322,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   GetCArray(self, src);
 
   if ( src->ndim <= 0 ) {
-    rb_raise(rb_eRuntimeError, "axis_group_reduce: scalar source");
+    rb_raise(rb_eArgError, "axis_group_reduce: scalar source");
   }
 
   /* --- group (slab) axes --- */
@@ -255,7 +334,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 ) {
@@ -269,7 +347,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) --- */
@@ -303,12 +380,23 @@ 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_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
+      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
+    }
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -363,13 +451,21 @@ 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;
 
@@ -380,10 +476,9 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   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);
+    rb_raise(rb_eCADataTypeError,
+             "axis_group: %"PRIsVALUE" over a group is not supported for data type %s",
+             rb_sym2str(vop), ca_type_name[src->data_type]);
   }
 
   /* output data type per op */
@@ -392,35 +487,52 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   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_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_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_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.
@@ -436,7 +548,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 */
@@ -459,27 +571,13 @@ 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 ) {
@@ -502,8 +600,6 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       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; }
     );
   }
@@ -521,8 +617,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* Empty / all-masked groups follow the same zero-contribution contract as
      CArray reductions (ERI, matching the categorical sibling): an identity-
      bearing op returns its identity (sum 0, prod 1, count 0, all true, any
-     false), a ratio / extremum returns UNDEF. Sample variance/stddev: n==0
-     UNDEF, n==1 -> 0.0 (the n=1 contract), n>=2 the formula. */
+     false), a ratio / extremum returns UNDEF. Sample variance/stddev: n<2
+     UNDEF (n-1 is zero), n>=2 the formula. */
   if ( op == GR_COUNT ) {
     int64_t *out = (int64_t *) co->ptr;
     for ( ca_size_t o = 0; o < nout; o++ ) out[o] = (int64_t) cnt[o];
@@ -531,13 +627,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++ )
@@ -558,16 +661,9 @@ 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); }
-        else if ( cnt[o] == 1 ) { out[o] = 0.0; }         /* n=1 contract */
+        if ( cnt[o] < 2 ) { out[o] = 0.0; MARK_UNDEF(o); }
         else { double var = sumsq[o] / ( (double) cnt[o] - 1.0 );
                out[o] = ( op == GR_STDDEV ) ? sqrt(var) : var; }
         break;
@@ -582,17 +678,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;
@@ -763,7 +852,9 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
    emits its own value: a per-group `seen` byte initialises the accumulator
    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
+   running extremum when CA_EXTREMUM_REPLACES (a NaN never does, and a
+   number displaces a leading NaN, as the core cummax / cummin and the
+   reduce twins above do).  A cell masked within its group holds the
    current extremum once a member has been seen (output NOT masked, like sum);
    before any member the extremum is undefined so the cell stays UNDEF (the
    CArray reduction contract: empty max/min has no value — deliberately NOT the
@@ -776,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;                                        \
@@ -803,13 +895,15 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
           }                                                                   \
           T rv = *(T *)(p + sw_doff[e]);                                      \
           if ( ! seen[code] ) { acce[code] = rv; seen[code] = 1; }            \
-          else if ( rv CMP acce[code] ) { acce[code] = rv; }                  \
+          else if ( CA_EXTREMUM_REPLACES(rv, acce[code], CMP) ) {             \
+            acce[code] = rv;                                                  \
+          }                                                                   \
           outp[addr] = acce[code];                                            \
         }                                                                     \
       }                                                                       \
       b++;                                                                    \
     }                                                                         \
-    xfree(acce);                                                              \
+    ALLOCV_END(h_acce);                                                       \
   } while (0)
 
 #define GROUP_SCAN_EXTREMUM_DISPATCH(CMP)                                     \
@@ -841,19 +935,19 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
    both unmasked (matching core object cumsum / cumprod); cummax / cummin hold
    the running VALUE only once a member has been seen and stay UNDEF before that
    (no identity for arbitrary objects).  GW_SKIP (excluded) stays UNDEF.  accn /
-   seen are reset at each band; acco carries the running VALUE. */
+   seen are reset at each band; acco carries the running VALUE.
+   Expanded only in group_scan_object_body, whose walk state is c->st. */
 #define GROUP_SCAN_OBJECT_WALK(EMIT, HOLD)                                    \
   do {                                                                        \
-    ca_iter_state st;                                                         \
     char       *p;                                                            \
     boolean8_t *m;                                                            \
     ca_size_t   b = 0;                                                        \
     int         ready = 0;                                                    \
-    CA_FOR_EACH_SLAB(st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {   \
-      ca_size_t SE = st.slab_elements;                                        \
+    CA_FOR_EACH_SLAB(c->st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {\
+      ca_size_t SE = c->st.slab_elements;                                     \
       if ( SE > 0 ) {                                                         \
         if ( ! ready ) {                                                      \
-          group_scan_build_plan(&st, m, n_bundles, bundle_codes, bundle_k,   \
+          group_scan_build_plan(&c->st, m, n_bundles, bundle_codes, bundle_k,\
                                 bundle_placeval, bundle_nconsumed,            \
                                 bundle_slot, bundle_cstride, ngroup,          \
                                 grstride, sw_code, sw_doff, sw_moff, sw_addr);\
@@ -878,6 +972,137 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
     }                                                                         \
   } while (0)
 
+/* Marks output cell o UNDEF, creating the output mask on first use.  Used
+   by the scan walks, in functions that hold the output as `co` and the mask
+   pointer as `omask`. */
+#define MARK_OUT_UNDEF(o) do {                   \
+    if ( ! omask ) {                             \
+      ca_create_mask(co);                        \
+      omask = (boolean8_t *) co->mask->ptr;      \
+    }                                            \
+    omask[o] = 1;                                \
+  } while (0)
+
+/* The CA_OBJECT lane of __axis_group_scan__.  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. */
+typedef struct {
+  ca_iter_state st;
+  CArray     *ca;
+  CArray     *co;
+  int         op;
+  int8_t     *axes;
+  long        ngroup;
+  int         n_bundles;
+  int32_t   **bundle_codes;
+  ca_size_t  *bundle_k;
+  ca_size_t  *bundle_placeval;
+  int        *bundle_nconsumed;
+  int       (*bundle_slot)[CA_RANK_MAX];
+  ca_size_t (*bundle_cstride)[CA_RANK_MAX];
+  ca_size_t  *grstride;
+  ca_size_t  *band_addr;
+  ca_size_t   K_total;
+  ca_size_t  *sw_code;
+  ca_size_t  *sw_doff;
+  ca_size_t  *sw_moff;
+  ca_size_t  *sw_addr;
+  ca_size_t  *accn;
+  char       *seen;
+  VALUE      *acco;
+} group_scan_object_t;
+
+static VALUE
+group_scan_object_body (VALUE arg)
+{
+  group_scan_object_t *c = (group_scan_object_t *) arg;
+  CArray     *ca               = c->ca;
+  CArray     *co               = c->co;
+  int         op               = c->op;
+  int8_t     *axes             = c->axes;
+  long        ngroup           = c->ngroup;
+  int         n_bundles        = c->n_bundles;
+  int32_t   **bundle_codes     = c->bundle_codes;
+  ca_size_t  *bundle_k         = c->bundle_k;
+  ca_size_t  *bundle_placeval  = c->bundle_placeval;
+  int        *bundle_nconsumed = c->bundle_nconsumed;
+  int       (*bundle_slot)[CA_RANK_MAX]    = c->bundle_slot;
+  ca_size_t (*bundle_cstride)[CA_RANK_MAX] = c->bundle_cstride;
+  ca_size_t  *grstride         = c->grstride;
+  ca_size_t  *band_addr        = c->band_addr;
+  ca_size_t   K_total          = c->K_total;
+  ca_size_t  *sw_code          = c->sw_code;
+  ca_size_t  *sw_doff          = c->sw_doff;
+  ca_size_t  *sw_moff          = c->sw_moff;
+  ca_size_t  *sw_addr          = c->sw_addr;
+  ca_size_t  *accn             = c->accn;
+  char       *seen             = c->seen;
+  VALUE      *acco             = c->acco;
+  boolean8_t *omask            = NULL;
+
+  if ( op == GS_CUMCOUNT ) {                    /* int64 1-based running count */
+    int64_t *outi = (int64_t *) co->ptr;
+    GROUP_SCAN_OBJECT_WALK(
+      accn[code] += 1; outi[addr] = (int64_t) accn[code];,
+      outi[addr] = (int64_t) accn[code];
+    );
+  }
+  else {                                        /* object running VALUE */
+    VALUE *outo = (VALUE *) co->ptr;
+    switch ( op ) {
+    case GS_CUMSUM:
+      /* Identity 0 (matching the core object cumsum): a group's acc is lazily
+         seeded to 0 (Fixnum, so 0 + ev promotes to ev's class), so a cell
+         masked before any present member holds 0 unmasked and an all-masked
+         group yields 0 everywhere.  seen doubles as the per-band init flag. */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
+        acco[code] = rb_funcall(acco[code], rb_intern("+"), 1, ev);
+        outo[addr] = acco[code];,
+        if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
+        outo[addr] = acco[code];
+      );
+      break;
+    case GS_CUMPROD:
+      /* Identity 1, same lazy-init as cumsum. */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
+        acco[code] = rb_funcall(acco[code], rb_intern("*"), 1, ev);
+        outo[addr] = acco[code];,
+        if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
+        outo[addr] = acco[code];
+      );
+      break;
+    case GS_CUMMAX:
+      /* No identity: seed from the first member, hold only once seen; a cell
+         masked before any member stays UNDEF (empty-max contract). */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
+        else if ( ca_obj_extremum_replaces(ev, acco[code], rb_intern(">")) ) {
+          acco[code] = ev;
+        }
+        outo[addr] = acco[code];,
+        if ( seen[code] ) { outo[addr] = acco[code]; }
+        else { MARK_OUT_UNDEF(addr); }
+      );
+      break;
+    case GS_CUMMIN:
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
+        else if ( ca_obj_extremum_replaces(ev, acco[code], rb_intern("<")) ) {
+          acco[code] = ev;
+        }
+        outo[addr] = acco[code];,
+        if ( seen[code] ) { outo[addr] = acco[code]; }
+        else { MARK_OUT_UNDEF(addr); }
+      );
+      break;
+    }
+  }
+  return Qnil;
+}
+
 static int
 group_scan_op_code (VALUE vop)
 {
@@ -887,7 +1112,7 @@ group_scan_op_code (VALUE vop)
   else if ( id == rb_intern("cummax") )   return GS_CUMMAX;
   else if ( id == rb_intern("cummin") )   return GS_CUMMIN;
   else if ( id == rb_intern("cumprod") )  return GS_CUMPROD;
-  rb_raise(rb_eArgError, "axis_group_scan: unsupported op :%s", rb_id2name(id));
+  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
@@ -930,7 +1155,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   GetCArray(self, src);
 
   if ( src->ndim <= 0 ) {
-    rb_raise(rb_eRuntimeError, "axis_group_scan: scalar source");
+    rb_raise(rb_eArgError, "axis_group_scan: scalar source");
   }
 
   /* --- group (slab) axes (same validation as reduce) --- */
@@ -990,11 +1215,23 @@ 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_copy_data(bundle_ca[bi], RSTRING_PTR(vbuf));
+      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
+    }
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -1054,8 +1291,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   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,
+    rb_raise(rb_eCADataTypeError,
              "axis_group_scan: unsupported source data_type %d",
              src->data_type);
   }
@@ -1091,7 +1327,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-- ) {
@@ -1108,86 +1345,41 @@ 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;
 
   boolean8_t *omask = NULL;
-  #define MARK_OUT_UNDEF(o) do {                   \
-      if ( ! omask ) {                             \
-        ca_create_mask(co);                        \
-        omask = (boolean8_t *) co->mask->ptr;      \
-      }                                            \
-      omask[o] = 1;                                \
-    } while (0)
 
   if ( src->data_type == CA_OBJECT ) {
-    if ( op == GS_CUMCOUNT ) {                    /* int64 1-based running count */
-      int64_t *outi = (int64_t *) co->ptr;
-      GROUP_SCAN_OBJECT_WALK(
-        accn[code] += 1; outi[addr] = (int64_t) accn[code];,
-        outi[addr] = (int64_t) accn[code];
-      );
-    }
-    else {                                        /* object running VALUE */
-      VALUE *outo = (VALUE *) co->ptr;
-      acco = ALLOC_N(VALUE, K_total);
-      switch ( op ) {
-      case GS_CUMSUM:
-        /* Identity 0 (matching the core object cumsum): a group's acc is lazily
-           seeded to 0 (Fixnum, so 0 + ev promotes to ev's class), so a cell
-           masked before any present member holds 0 unmasked and an all-masked
-           group yields 0 everywhere.  seen doubles as the per-band init flag. */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
-          acco[code] = rb_funcall(acco[code], rb_intern("+"), 1, ev);
-          outo[addr] = acco[code];,
-          if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
-          outo[addr] = acco[code];
-        );
-        break;
-      case GS_CUMPROD:
-        /* Identity 1, same lazy-init as cumsum. */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
-          acco[code] = rb_funcall(acco[code], rb_intern("*"), 1, ev);
-          outo[addr] = acco[code];,
-          if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
-          outo[addr] = acco[code];
-        );
-        break;
-      case GS_CUMMAX:
-        /* No identity: seed from the first member, hold only once seen; a cell
-           masked before any member stays UNDEF (empty-max contract). */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
-          else if ( NUM2INT(rb_funcall(ev, rb_intern("<=>"), 1, acco[code])) > 0 ) {
-            acco[code] = ev;
-          }
-          outo[addr] = acco[code];,
-          if ( seen[code] ) { outo[addr] = acco[code]; }
-          else { MARK_OUT_UNDEF(addr); }
-        );
-        break;
-      case GS_CUMMIN:
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
-          else if ( NUM2INT(rb_funcall(ev, rb_intern("<=>"), 1, acco[code])) < 0 ) {
-            acco[code] = ev;
-          }
-          outo[addr] = acco[code];,
-          if ( seen[code] ) { outo[addr] = acco[code]; }
-          else { MARK_OUT_UNDEF(addr); }
-        );
-        break;
-      }
+    group_scan_object_t c;
+    if ( op != GS_CUMCOUNT ) {
+      acco = ALLOCV_N(VALUE, h_acco, K_total);
     }
+    c.ca = ca;  c.co = co;  c.op = op;
+    c.axes = axes;  c.ngroup = ngroup;
+    c.n_bundles = n_bundles;  c.bundle_codes = bundle_codes;
+    c.bundle_k = bundle_k;  c.bundle_placeval = bundle_placeval;
+    c.bundle_nconsumed = bundle_nconsumed;
+    c.bundle_slot = bundle_slot;  c.bundle_cstride = bundle_cstride;
+    c.grstride = grstride;  c.band_addr = band_addr;  c.K_total = K_total;
+    c.sw_code = sw_code;  c.sw_doff = sw_doff;
+    c.sw_moff = sw_moff;  c.sw_addr = sw_addr;
+    c.accn = accn;  c.seen = seen;  c.acco = acco;
+    ca_iter_ensure(1, &c.st, group_scan_object_body, (VALUE) &c);
   }
   else {                                          /* native data type dispatch */
     switch ( op ) {
@@ -1217,18 +1409,10 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       break;
     }
   }
-  #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;