carray 3.0.2 → 3.0.4

data/ext/carray_factorize.c

@@ -50,7 +50,8 @@
   (Float#eql? treats them equal).  The object lane adds one deviation from Ruby
   Hash, aligning it with the numeric lane: every Float NaN collapses to one
   distinct value (a NaN takes a fixed canonical key and matches any stored Float
-  NaN), where Ruby Hash would keep distinct NaN objects apart.
+  NaN), where Ruby Hash would keep distinct NaN objects apart, and a Complex
+  with a NaN part is one value with any Complex whose parts match it that way.
   __factorize_appearance__ and the discovery members (unique, value_counts,
   mask_duplicates) all cover the numeric / object / fixlen lanes.
 
@@ -77,6 +78,7 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"
+#include "carray_internal.h"   /* ca_object_cells_clear */
 #include <string.h>
 #include <math.h>
 
@@ -102,44 +104,133 @@
    discovery surface rather than this gate (see
    devel/PROPOSAL_DISCOVERY_FAMILY_FACE_GATE.md §4). */
 
+/* The value-hash family decides whether two cells hold the same value: every
+   NaN is one value, and -0.0 is the same value as +0.0.  A float cell's key
+   is the bytes of its canonical form (one NaN, +0.0 for a zero), so equal
+   values have equal keys; fz_canonical_* writes that form back as a value. */
+#define FZ_NAN_KEY_DOUBLE 0x7ff8000000000000ULL
+#define FZ_NAN_KEY_FLOAT  0x7fc00000UL
+
+static inline uint64_t
+fz_key_double (double v)
+{
+  uint64_t b;
+  if ( v != v ) return FZ_NAN_KEY_DOUBLE;
+  if ( v == 0.0 ) v = 0.0;
+  memcpy(&b, &v, sizeof(b));
+  return b;
+}
+
+static inline uint64_t
+fz_key_float (float v)
+{
+  uint32_t b;
+  if ( v != v ) return FZ_NAN_KEY_FLOAT;
+  if ( v == 0.0f ) v = 0.0f;
+  memcpy(&b, &v, sizeof(b));
+  return (uint64_t) b;
+}
+
+static inline double
+fz_canonical_double (double v)
+{
+  uint64_t b = fz_key_double(v);
+  memcpy(&v, &b, sizeof(v));
+  return v;
+}
+
+static inline float
+fz_canonical_float (float v)
+{
+  uint32_t b = (uint32_t) fz_key_float(v);
+  memcpy(&v, &b, sizeof(v));
+  return v;
+}
+
+/* For the kernel macros, which take the cell type T. */
+#define FZ_FLOAT_KEY(T, v) \
+  _Generic((T) 0, float: fz_key_float, double: fz_key_double)(v)
+
+/* A complex array as hash keys: its cells as fixlen blobs of the same
+   width, each component written so that equal values have equal bytes
+   (-0.0 as 0.0, every NaN as one NaN), with the mask kept.  The fixlen lane
+   then answers equality for complex values. */
+static VALUE
+fz_complex_key (VALUE self)
+{
+  volatile VALUE out;
+  CArray *ca, *co;
+  ca_size_t i, n;
+  GetCArray(self, ca);
+  out = rb_carray_new(CA_FIXLEN, ca->ndim, ca->dim, ca->bytes, NULL);
+  GetCArray(out, co);
+  ca_copy_data(ca, co->ptr);
+  n = 2 * ca->elements;
+  if ( ca->data_type == CA_CMPLX128 ) {
+    double *p = (double *) co->ptr;
+    for ( i = 0; i < n; i++ ) p[i] = fz_canonical_double(p[i]);
+  }
+  else {
+    float *p = (float *) co->ptr;
+    for ( i = 0; i < n; i++ ) p[i] = fz_canonical_float(p[i]);
+  }
+  if ( ca_has_mask(ca) ) {
+    ca_copy_mask(co, ca);
+  }
+  RB_GC_GUARD(self);   /* read through ca after rb_carray_new allocates */
+  return out;
+}
+
+/* The members whose output carries no values (a mask, a count) read a
+   complex array through its keys and need nothing back. */
+static VALUE
+fz_complex_as_key (VALUE self)
+{
+  CArray *ca;
+  GetCArray(self, ca);
+  if ( ! ca_is_face(ca) && ca_is_complex_type(ca) ) {
+    return fz_complex_key(self);
+  }
+  return self;
+}
+
 /* Descend `self` when it is an ORDERABLE Face; *pface keeps the pre-strip Face
-   for the re-lift (Qnil when there is nothing to put back). */
+   for the re-lift (Qnil when there is nothing to put back).  A complex array
+   is turned into hash keys (fz_complex_key) and *pface keeps it, so the
+   re-lift reads the values back as complex. */
 static VALUE
 fz_face_descend (VALUE self, volatile VALUE *pface, const char *name)
 {
   CArray *ca;
   GetCArray(self, ca);
+  if ( ! ca_is_face(ca) && ca_is_complex_type(ca) ) {
+    *pface = self;
+    return fz_complex_key(self);
+  }
   if ( ca_is_face(ca) ) {
-    if ( ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-      *pface = self;
-      return rb_ca_strip_face_value(self);
+    /* A record is its bytes: two records are the same value exactly when
+       their bytes are, so the fixlen lane answers for it.  Any other Face
+       is descended only when ORDERABLE.  One that cannot be descended must
+       not flow on undescended: whatever reads it next reads its storage
+       anyway, which is the encoding rather than the values.  A Face in this
+       position normally never arrives -- CAConstString and CACategorical
+       define their own members in Ruby -- but the overrides only fire when
+       the Face is the receiver, and this same helper descends the
+       *reference* for locate_addr, where it is the argument. */
+    if ( ca->obj_type != CA_OBJ_RECORD ) {
+      ca_face_require_orderable(self, name, "compare");
     }
-    /* A Face that cannot be descended must not flow on undescended: whatever
-       reads it next reads its storage anyway, which is the encoding rather
-       than the values.  A Face in this position normally never arrives --
-       CAConstString and CACategorical define their own members in Ruby -- but
-       the overrides only fire when the Face is the receiver, and this same
-       helper descends the *reference* for locate_addr, where it is the
-       argument. */
-    rb_raise(rb_eArgError,
-             "%s: %s is not orderable by storage (a cell encodes the value "
-             "rather than being it); convert it first -- #to_string for a "
-             "string Face -- or pass .parent to work in storage space",
-             name, rb_obj_classname(self));
+    *pface = self;
+    return rb_ca_strip_face_value(self);
   }
   *pface = Qnil;
   return self;
 }
 
 /* Bring `operand` into the space of `reference` (the *pre-strip* Face) and
-   descend it, so both sides hash in one storage space.
-
-   `to_comparable` exists because a Face can carry a *unit* -- an alternative
-   space for the same value -- so a reference that defines it reconciles any
-   operand type through it (and refuses what it cannot convert, which is how a
-   bare storage number stays out).  A reference with one space only (COMPARABLE,
-   or a Face with no unit algebra at all, e.g. CAString) has nothing to
-   reconcile between: descending both sides is the whole job. */
+   descend it, so both sides hash in one storage space
+   (ca_face_reconcile_operand).  A complex reference instead turns the
+   operand into keys of its own complex type. */
 static VALUE
 fz_face_reconcile (VALUE reference, VALUE operand, const char *name)
 {
@@ -148,22 +239,38 @@ fz_face_reconcile (VALUE reference, VALUE operand, const char *name)
     return operand;
   }
   GetCArray(reference, ca);
-  if ( ! ca_test_flag(ca, CA_FLAG_FACE_COMPARABLE_STORAGE)
-       && rb_respond_to(reference, rb_intern("to_comparable")) ) {
-    return rb_ca_strip_face_value(rb_funcall(reference,
-                                             rb_intern("to_comparable"),
-                                             1, operand));
+  if ( ! ca_is_face(ca) ) {
+    /* A complex reference: the operand becomes keys of the same kind, in the
+       reference's complex type. */
+    CArray *op;
+    if ( ! rb_obj_is_carray(operand) ) {
+      return operand;
+    }
+    GetCArray(operand, op);
+    if ( op->data_type != ca->data_type ) {
+      /* coerce: the callers have met both sides at result_type already */
+      operand = rb_ca_to_type(operand, INT2NUM(ca->data_type), Qnil);
+    }
+    return fz_complex_key(operand);
   }
-  return ca_face_operand_descend(operand, name);
+  return ca_face_reconcile_operand(reference, operand, name);
 }
 
-/* Put the Face back on a value-carrying output. */
+/* Put the Face back on a value-carrying output, or read complex keys back
+   as complex values. */
 static VALUE
 fz_face_relift (VALUE out, VALUE face)
 {
+  CArray *cf, *co;
   if ( NIL_P(face) ) {
     return out;
   }
+  GetCArray(face, cf);
+  if ( ! ca_is_face(cf) ) {
+    GetCArray(out, co);
+    return rb_ca_copy(rb_ca_refer_new(out, cf->data_type, co->ndim, co->dim,
+                                      cf->bytes, 0));
+  }
   return ca_face_lift(out, face);
 }
 
@@ -176,16 +283,95 @@ typedef struct {
   VALUE    *val;    /* object lane only: the interned VALUE, kept for an eql? re-check
                        on a hash collision (NULL in the numeric lane, where the widened
                        key is lossless so a key match already proves value equality).
-                       Its VALUEs are always elements of the live receiver, so the GC
-                       reaches them through `self`; this array is not separately marked. */
+                       A receiver that computes its cells (a CAObject, a lazy
+                       expression) hands each fiber over in a scratch that is refilled,
+                       so the owner marks this array (fz_tmp_values). */
   char     *raw;    /* fixlen lane only: cap*esz bytes, the interned element bytes kept
                        for a memcmp re-check on a hash collision (NULL otherwise). */
   int       esz;    /* fixlen lane: element width in bytes (0 otherwise) */
+  int       has_val; /* object lane: val is kept (0 otherwise) */
   ca_size_t cap;    /* power of two */
   ca_size_t n;      /* distinct keys interned so far */
   int       shift;  /* 64 - log2(cap); the home slot is the top log2(cap) bits */
+  VALUE     hbuf;   /* owner of the tables, one block (fz_tmp_alloc) */
 } fz_hash;
 
+/* The tables live in buffers owned by hidden Ruby objects rather than bare
+   xmalloc.  The object lane calls #hash and #eql? for every cell, and a raise
+   there leaves the tables with nothing to free them; the owner is reclaimed
+   by the GC once the frame holding it is gone, and frees its buffer then.
+   An owner whose buffer keeps VALUEs (fz_tmp_values) marks them: the object
+   lane's cells come from a scratch the walk refills, not only from the
+   receiver, so nothing else holds the ones already interned. */
+typedef struct {
+  char      *buf;
+  ca_size_t  voff;    /* byte offset of the VALUE run in buf */
+  ca_size_t  nvals;   /* VALUEs in the run (0: nothing to mark) */
+} fz_buffer;
+
+static void
+fz_buffer_mark (void *ptr)
+{
+  fz_buffer *b = (fz_buffer *) ptr;
+  if ( b->buf && b->nvals > 0 ) {
+    VALUE    *v = (VALUE *) (b->buf + b->voff);
+    ca_size_t i;
+    for ( i = 0; i < b->nvals; i++ ) rb_gc_mark(v[i]);
+  }
+}
+
+static void
+fz_buffer_free (void *ptr)
+{
+  fz_buffer *b = (fz_buffer *) ptr;
+  xfree(b->buf);
+  xfree(b);
+}
+
+static const rb_data_type_t fz_buffer_type = {
+  "carray_factorize_buffer",
+  { fz_buffer_mark, fz_buffer_free, NULL, },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static void *
+fz_tmp_alloc (VALUE *store, size_t bytes)
+{
+  fz_buffer *b;
+  *store = TypedData_Make_Struct(0, fz_buffer, &fz_buffer_type, b);
+  b->buf = (char *) xmalloc(bytes);
+  return b->buf;
+}
+
+static void *
+fz_tmp_realloc (VALUE store, size_t bytes)
+{
+  fz_buffer *b = (fz_buffer *) DATA_PTR(store);
+  b->buf = (char *) xrealloc(b->buf, bytes);
+  return b->buf;
+}
+
+/* Mark the n VALUEs at vals (inside store's buffer); they must be valid. */
+static void
+fz_tmp_values (VALUE store, void *vals, ca_size_t n)
+{
+  fz_buffer *b = (fz_buffer *) DATA_PTR(store);
+  b->voff  = (ca_size_t) ((char *) vals - b->buf);
+  b->nvals = n;
+}
+
+static void
+fz_tmp_free (VALUE *store)
+{
+  if ( *store ) {
+    fz_buffer *b = (fz_buffer *) DATA_PTR(*store);
+    b->nvals = 0;
+    xfree(b->buf);
+    b->buf = NULL;
+    *store = 0;
+  }
+}
+
 /* Multiplicative hashing (Knuth, TAOCP vol. 3 sec. 6.4): multiply by
    2^64 / golden-ratio and take the TOP log2(cap) bits of the product -- the
    high bits are where a multiply mixes best (the low bits carry little
@@ -195,19 +381,48 @@ typedef struct {
 #define FZ_GOLDEN 0x9E3779B97F4A7C15ULL
 #define FZ_HOME(h, key) ((ca_size_t) (((uint64_t)(key) * FZ_GOLDEN) >> (h)->shift))
 
+/* Points the tables of h at one new block for cap slots: key, then the
+   object lane's val, code, used, and the fixlen lane's raw bytes. */
 static void
-fz_hash_init (fz_hash *h)
+fz_hash_alloc (fz_hash *h, ca_size_t cap)
+{
+  int    has_val = h->has_val;
+  size_t nkey    = sizeof(uint64_t) * (size_t) cap;
+  size_t nval    = has_val ? sizeof(VALUE) * (size_t) cap : 0;
+  size_t ncode   = sizeof(int32_t) * (size_t) cap;
+  size_t nused   = sizeof(uint8_t) * (size_t) cap;
+  size_t nraw    = (size_t) cap * (size_t) h->esz;
+  char  *b = fz_tmp_alloc(&h->hbuf, nkey + nval + ncode + nused + nraw);
+  h->key  = (uint64_t *) b;                 b += nkey;
+  h->val  = has_val ? (VALUE *) b : NULL;   b += nval;
+  h->code = (int32_t *) b;                  b += ncode;
+  h->used = (uint8_t *) b;                  b += nused;
+  h->raw  = h->esz ? b : NULL;
+  h->cap  = cap;
+  MEMZERO(h->used, uint8_t, cap);
+  if ( has_val ) {
+    ca_object_cells_clear(h->val, cap);
+    fz_tmp_values(h->hbuf, h->val, cap);
+  }
+}
+
+/* has_val: the object lane (a slot keeps its VALUE); esz > 0: the fixlen
+   lane (a slot keeps esz bytes). */
+static void
+fz_hash_setup (fz_hash *h, int has_val, int esz)
 {
-  h->cap   = 1024;
   h->shift = 64 - 10;   /* log2(1024) = 10 */
   h->n     = 0;
-  h->key   = ALLOC_N(uint64_t, h->cap);
-  h->code  = ALLOC_N(int32_t,  h->cap);
-  h->used  = ALLOC_N(uint8_t,  h->cap);
-  h->val   = NULL;      /* numeric lane: no VALUE re-check needed */
-  h->raw   = NULL;
-  h->esz   = 0;
-  MEMZERO(h->used, uint8_t, h->cap);
+  h->hbuf  = 0;
+  h->has_val = has_val;
+  h->esz   = esz;
+  fz_hash_alloc(h, 1024);
+}
+
+static void
+fz_hash_init (fz_hash *h)
+{
+  fz_hash_setup(h, 0, 0);   /* numeric lane: no re-check needed */
 }
 
 /* Object lane: the widened key is `rb_hash` (lossy), so a slot also stores the
@@ -216,8 +431,7 @@ fz_hash_init (fz_hash *h)
 static void
 fz_hash_init_obj (fz_hash *h)
 {
-  fz_hash_init(h);
-  h->val = ALLOC_N(VALUE, h->cap);
+  fz_hash_setup(h, 1, 0);
 }
 
 /* Fixlen lane: the key is a byte-hash of the esz-wide element (lossy), so a slot
@@ -227,19 +441,18 @@ fz_hash_init_obj (fz_hash *h)
 static void
 fz_hash_init_mem (fz_hash *h, int esz)
 {
-  fz_hash_init(h);
-  h->esz = esz;
-  h->raw = ALLOC_N(char, h->cap * esz);
+  fz_hash_setup(h, 0, esz);
 }
 
 static void
 fz_hash_free (fz_hash *h)
 {
-  if ( h->key )  { xfree(h->key);  h->key  = NULL; }
-  if ( h->code ) { xfree(h->code); h->code = NULL; }
-  if ( h->used ) { xfree(h->used); h->used = NULL; }
-  if ( h->val )  { xfree(h->val);  h->val  = NULL; }
-  if ( h->raw )  { xfree(h->raw);  h->raw  = NULL; }
+  fz_tmp_free(&h->hbuf);
+  h->key  = NULL;
+  h->code = NULL;
+  h->used = NULL;
+  h->val  = NULL;
+  h->raw  = NULL;
 }
 
 /* FNV-1a over esz bytes: a lossy 64-bit key for the fixlen lane. */
@@ -272,14 +485,10 @@ fz_hash_grow (fz_hash *h)
   VALUE    *ov = h->val;
   char     *orw = h->raw;
   int       esz = h->esz;
-  h->cap    = newcap;
-  h->shift -= 1;                 /* log2(cap) grew by one */
-  h->key    = ALLOC_N(uint64_t, newcap);
-  h->code   = ALLOC_N(int32_t,  newcap);
-  h->used   = ALLOC_N(uint8_t,  newcap);
-  if ( ov )  { h->val = ALLOC_N(VALUE, newcap); }
-  if ( orw ) { h->raw = ALLOC_N(char, newcap * esz); }
-  MEMZERO(h->used, uint8_t, newcap);
+  VALUE     hold = h->hbuf;   /* keeps the old block until it is freed below */
+  h->hbuf   = 0;
+  h->shift -= 1;              /* log2(cap) grew by one */
+  fz_hash_alloc(h, newcap);
   ca_size_t mask = newcap - 1;
   for ( ca_size_t s = 0; s < oldcap; s++ ) {
     if ( ! ou[s] ) { continue; }
@@ -291,9 +500,7 @@ fz_hash_grow (fz_hash *h)
     if ( ov )  { h->val[slot] = ov[s]; }
     if ( orw ) { memcpy(h->raw + slot * esz, orw + s * esz, esz); }
   }
-  xfree(ok); xfree(oc); xfree(ou);
-  if ( ov )  { xfree(ov); }
-  if ( orw ) { xfree(orw); }
+  fz_tmp_free(&hold);
 }
 
 /* True when v is a Float holding NaN (any bit pattern). */
@@ -303,25 +510,84 @@ fz_is_float_nan (VALUE v)
   return RB_FLOAT_TYPE_P(v) && isnan(RFLOAT_VALUE(v));
 }
 
+/* True when v holds a NaN that eql? would keep apart from an equal value:
+   a Float NaN, or a Complex with a Float NaN part. */
+static int
+fz_obj_has_nan (VALUE v)
+{
+  if ( fz_is_float_nan(v) ) {
+    return 1;
+  }
+  return RB_TYPE_P(v, T_COMPLEX)
+         && ( fz_is_float_nan(rb_complex_real(v))
+              || fz_is_float_nan(rb_complex_imag(v)) );
+}
+
+/* A part of a NaN-bearing value: every NaN is one value, the rest go by
+   eql?, as in Ruby Hash. */
+static uint64_t
+fz_obj_part_key (VALUE v)
+{
+  return fz_is_float_nan(v) ? FZ_NAN_KEY_DOUBLE : (uint64_t) NUM2LL(rb_hash(v));
+}
+
+static int
+fz_obj_part_eql (VALUE a, VALUE b)
+{
+  if ( fz_is_float_nan(a) || fz_is_float_nan(b) ) {
+    return fz_is_float_nan(a) && fz_is_float_nan(b);
+  }
+  return rb_eql(a, b);
+}
+
+/* The hash key of an object cell.  A NaN-bearing value is keyed part by
+   part with every NaN as one value, so it matches the numeric lane: all
+   NaN are one value, and a complex value is one value when its parts are. */
+static uint64_t
+fz_obj_key (VALUE v, int has_nan)
+{
+  if ( ! has_nan ) {
+    return (uint64_t) NUM2LL(rb_hash(v));
+  }
+  if ( RB_TYPE_P(v, T_COMPLEX) ) {
+    return fz_obj_part_key(rb_complex_real(v)) * 31u
+           ^ fz_obj_part_key(rb_complex_imag(v)) ^ 0x9e3779b97f4a7c15ULL;
+  }
+  return FZ_NAN_KEY_DOUBLE;
+}
+
+/* Whether a stored cell is the same value as v (has_nan from fz_obj_has_nan). */
+static int
+fz_obj_same (VALUE stored, VALUE v, int has_nan)
+{
+  if ( ! has_nan ) {
+    return rb_eql(stored, v);
+  }
+  if ( RB_TYPE_P(v, T_COMPLEX) ) {
+    return RB_TYPE_P(stored, T_COMPLEX)
+           && fz_obj_part_eql(rb_complex_real(stored), rb_complex_real(v))
+           && fz_obj_part_eql(rb_complex_imag(stored), rb_complex_imag(v));
+  }
+  return fz_is_float_nan(stored);
+}
+
 /* Object-lane intern: key = rb_hash(v) (lossy), collision re-check via rb_eql.
    Matches Ruby Hash distinctness (`hash` + `eql?`) element for element, with one
    value-based exception aligning with the numeric lane: every Float NaN collapses
    to a single distinct value (Ruby Hash keeps distinct NaN objects apart via
-   eql?, but the discovery family unifies them).  A NaN takes a fixed canonical
-   key and matches any stored Float NaN, so its second and later occurrences fold
-   into the first. */
+   eql?, but the discovery family unifies them), and so does a Complex whose
+   parts are the same with every NaN as one (fz_obj_key / fz_obj_same). */
 static int32_t
 fz_hash_intern_obj (fz_hash *h, VALUE v, int *is_new)
 {
   if ( (h->n + 1) * 10 >= h->cap * 7 ) { fz_hash_grow(h); }   /* load factor 0.7 */
-  int v_nan = fz_is_float_nan(v);
-  uint64_t key = v_nan ? 0x7ff8000000000000ULL
-                       : (uint64_t) NUM2LL(rb_hash(v));
+  int v_nan = fz_obj_has_nan(v);
+  uint64_t key = fz_obj_key(v, v_nan);
   ca_size_t mask = h->cap - 1;
   ca_size_t slot = FZ_HOME(h, key);
   while ( h->used[slot] ) {
     if ( h->key[slot] == key &&
-         ( v_nan ? fz_is_float_nan(h->val[slot]) : rb_eql(h->val[slot], v) ) ) {
+         fz_obj_same(h->val[slot], v, v_nan) ) {
       *is_new = 0; return h->code[slot];
     }
     slot = (slot + 1) & mask;
@@ -412,14 +678,13 @@ fz_hash_lookup (fz_hash *h, uint64_t key, int32_t *code_out)
 static int
 fz_hash_lookup_obj (fz_hash *h, VALUE v, int32_t *code_out)
 {
-  int v_nan = fz_is_float_nan(v);
-  uint64_t key = v_nan ? 0x7ff8000000000000ULL
-                       : (uint64_t) NUM2LL(rb_hash(v));
+  int v_nan = fz_obj_has_nan(v);
+  uint64_t key = fz_obj_key(v, v_nan);
   ca_size_t mask = h->cap - 1;
   ca_size_t slot = FZ_HOME(h, key);
   while ( h->used[slot] ) {
     if ( h->key[slot] == key &&
-         ( v_nan ? fz_is_float_nan(h->val[slot]) : rb_eql(h->val[slot], v) ) ) {
+         fz_obj_same(h->val[slot], v, v_nan) ) {
       if ( code_out ) { *code_out = h->code[slot]; }
       return 1;
     }
@@ -452,23 +717,42 @@ typedef struct {
   ca_size_t cap;    /* capacity in elements */
   ca_size_t n;      /* elements stored */
   int       esz;    /* element bytes */
+  VALUE     hp;     /* owner of p (see fz_tmp_alloc) */
+  int       obj;    /* p holds VALUEs, marked by hp */
 } fz_levels;
 
+/* Fill the VALUE slots from..cap with Qnil and mark all cap of them. */
 static void
-fz_levels_init (fz_levels *l, int esz)
+fz_levels_values (fz_levels *l, ca_size_t from)
+{
+  ca_object_cells_clear((VALUE *) l->p + from, l->cap - from);
+  fz_tmp_values(l->hp, l->p, l->cap);
+}
+
+static void
+fz_levels_init (fz_levels *l, int esz, int obj)
 {
   l->esz = esz;
   l->cap = 16;
   l->n   = 0;
-  l->p   = ALLOC_N(char, l->cap * esz);
+  l->hp  = 0;
+  l->obj = obj;
+  l->p   = fz_tmp_alloc(&l->hp, (size_t) l->cap * esz);
+  if ( obj ) {
+    fz_levels_values(l, 0);
+  }
 }
 
 static void
 fz_levels_push (fz_levels *l, const void *e)
 {
   if ( l->n == l->cap ) {
+    ca_size_t old = l->cap;
     l->cap <<= 1;
-    REALLOC_N(l->p, char, l->cap * l->esz);
+    l->p = fz_tmp_realloc(l->hp, (size_t) l->cap * l->esz);
+    if ( l->obj ) {
+      fz_levels_values(l, old);
+    }
   }
   memcpy(l->p + l->n * l->esz, e, l->esz);
   l->n++;
@@ -477,7 +761,41 @@ fz_levels_push (fz_levels *l, const void *e)
 static void
 fz_levels_free (fz_levels *l)
 {
-  if ( l->p ) { xfree(l->p); l->p = NULL; }
+  fz_tmp_free(&l->hp);
+  l->p = NULL;
+}
+
+/* ---- the frame a discovery method runs in ---------------------------------
+
+   The object lane calls #hash and #eql? for every cell, and either can raise
+   in the middle of a walk.  The walks' states live in this frame, outside the
+   method's body, and ca_iter_ensure finishes them however the body leaves;
+   the tables have owners the unwind collects (fz_tmp_alloc).  Slots 0
+   and 1 hold a method's own walks, slot 2 the walk of fz_intern_all.
+
+   A body that replaces self or an operand with an array it made (complex
+   keys, a Face's storage, an operand brought into self's space) writes the
+   new VALUE back into the frame.  The walks read it only through its
+   CArray *, so a C local alone would leave it to the collector halfway
+   through. */
+
+typedef struct {
+  ca_iter_state st[3];
+  VALUE         self;
+  VALUE         a;
+  VALUE         b;
+  int           i;
+} fz_frame;
+
+static VALUE
+fz_run (VALUE (*body)(VALUE), VALUE self, VALUE a, VALUE b, int i)
+{
+  fz_frame fr;
+  fr.self = self;
+  fr.a    = a;
+  fr.b    = b;
+  fr.i    = i;
+  return ca_iter_ensure(3, fr.st, body, (VALUE) &fr);
 }
 
 /* @overload __factorize_appearance__
@@ -497,11 +815,13 @@ fz_levels_free (fz_levels *l)
               (row-major flatten) order.
 */
 static VALUE
-rb_ca_factorize_appearance (VALUE self)
+fz_factorize_appearance_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "categorize");
+  fr->self = self = fz_face_descend(self, &face, "categorize");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -532,11 +852,11 @@ rb_ca_factorize_appearance (VALUE self)
   if      ( dt == CA_OBJECT ) { fz_hash_init_obj(&h); }
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
-  fz_levels_init(&lv, (int) ca->bytes);
+  fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
 
   int8_t axis = (int8_t) (ca->ndim - 1);   /* innermost fiber = row-major flatten */
 
-  ca_iter_state st_in, st_out;
+  ca_iter_state *st_in = &fr->st[0], *st_out = &fr->st[1];
   char       *p_in, *p_out;
   boolean8_t *m;
   ca_size_t   n;
@@ -558,25 +878,18 @@ rb_ca_factorize_appearance (VALUE self)
     } while (0)
 
   /* Float lane: reproduce `==` with two value-based exceptions matching the
-     discovery family -- all NaN collapse to one canonical key (v != v -> NANKEY),
+     discovery family -- all NaN collapse to one canonical key (FZ_FLOAT_KEY),
      and -0.0 == +0.0 (a zero normalizes to +0.0 before the bitwise key).  The
      level pushed is the raw first-seen element (an appearance-first NaN / -0.0 is
      kept as-is), so masked source cells store the sentinel. */
-  #define FZ_LOOP_FLOAT(T, UINT, NANKEY)                                     \
+  #define FZ_LOOP_FLOAT(T)                                     \
     do {                                                                     \
       const T  *ip = (const T *) p_in;                                       \
       uint32_t *op = (uint32_t *) p_out;                                     \
       for ( ca_size_t i = 0; i < n; i++ ) {                                  \
         if ( m && m[i] ) { op[i] = 0xFFFFFFFFu; continue; }                  \
         T v = ip[i];                                                         \
-        uint64_t key;                                                        \
-        if ( v != v ) { key = (NANKEY); }                                    \
-        else {                                                               \
-          if ( v == (T) 0 ) { v = (T) 0; }                                   \
-          UINT bits;                                                         \
-          memcpy(&bits, &v, sizeof(bits));                                   \
-          key = (uint64_t) bits;                                             \
-        }                                                                    \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                          \
         int32_t code = fz_hash_intern(&h, key, &is_new);                     \
         if ( is_new ) { fz_levels_push(&lv, &ip[i]); }                       \
@@ -615,7 +928,7 @@ rb_ca_factorize_appearance (VALUE self)
       }                                                                      \
     } while (0)
 
-  CA_FOR_EACH_FIBER_INOUT_MASKED(st_in, st_out, ca, cu32, axis,
+  CA_FOR_EACH_FIBER_INOUT_MASKED(*st_in, *st_out, ca, cu32, axis,
                                  CA_KERNEL_READ, p_in, p_out, n, m) {
     switch ( dt ) {
     case CA_INT8:   FZ_LOOP(int8_t,   (int64_t));  break;
@@ -626,8 +939,8 @@ rb_ca_factorize_appearance (VALUE self)
     case CA_UINT16: FZ_LOOP(uint16_t, (uint64_t)); break;
     case CA_UINT32: FZ_LOOP(uint32_t, (uint64_t)); break;
     case CA_UINT64: FZ_LOOP(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: FZ_LOOP_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-    case CA_FLOAT64: FZ_LOOP_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+    case CA_FLOAT32: FZ_LOOP_FLOAT(float);         break;
+    case CA_FLOAT64: FZ_LOOP_FLOAT(double); break;
     case CA_OBJECT: FZ_LOOP_OBJ;                   break;
     case CA_FIXLEN: FZ_LOOP_MEM;                   break;
     }
@@ -686,6 +999,12 @@ rb_ca_factorize_appearance (VALUE self)
   return rb_ary_new3(2, vcodes, fz_face_relift(vlev, face));
 }
 
+static VALUE
+rb_ca_factorize_appearance (VALUE self)
+{
+  return fz_run(fz_factorize_appearance_body, self, Qnil, Qnil, 0);
+}
+
 /* @overload __mask_duplicates__(axis)
 
    INTERNAL (mask_duplicates). Mark each cell whose value duplicates an
@@ -706,8 +1025,11 @@ rb_ca_factorize_appearance (VALUE self)
    value (so the second and later NaN are duplicates, as in the numeric lane).
 */
 static VALUE
-rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
+fz_mask_duplicates_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE vaxis = fr->a;
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
@@ -741,7 +1063,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
 
-  ca_iter_state st_in, st_out;
+  ca_iter_state *st_in = &fr->st[0], *st_out = &fr->st[1];
   char       *p_in, *p_out;
   boolean8_t *m;
   ca_size_t   n;
@@ -764,24 +1086,17 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
 
   /* Float variant: reproduce `==` with two value-based exceptions so the
      distinct-value judgement matches uniq / the discovery family. All NaN
-     collapse to one canonical key (v != v -> NANKEY), so the second and later
+     collapse to one canonical key (FZ_FLOAT_KEY), so the second and later
      NaN in a fiber are duplicates; -0.0 == +0.0, so a zero normalizes to +0.0
      before the bitwise key. */
-  #define MD_LOOP_FLOAT(T, UINT, NANKEY)                                      \
+  #define MD_LOOP_FLOAT(T)                                      \
     do {                                                                      \
       const T    *ip = (const T *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { op[i] = 0; continue; }                            \
         T v = ip[i];                                                          \
-        uint64_t key;                                                         \
-        if ( v != v ) { key = (NANKEY); }                                     \
-        else {                                                                \
-          if ( v == (T) 0 ) { v = (T) 0; }                                   \
-          UINT bits;                                                          \
-          memcpy(&bits, &v, sizeof(bits));                                    \
-          key = (uint64_t) bits;                                              \
-        }                                                                     \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                           \
         fz_hash_intern(&h, key, &is_new);                                     \
         op[i] = is_new ? 0 : 1;                                               \
@@ -814,7 +1129,7 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
       }                                                                       \
     } while (0)
 
-  CA_FOR_EACH_FIBER_INOUT_MASKED(st_in, st_out, ca, cout, (int8_t) axis,
+  CA_FOR_EACH_FIBER_INOUT_MASKED(*st_in, *st_out, ca, cout, (int8_t) axis,
                                  CA_KERNEL_READ, p_in, p_out, n, m) {
     fz_hash_reset(&h);   /* independent seen-set per fiber */
     switch ( dt ) {
@@ -826,8 +1141,8 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
     case CA_UINT16: MD_LOOP(uint16_t, (uint64_t)); break;
     case CA_UINT32: MD_LOOP(uint32_t, (uint64_t)); break;
     case CA_UINT64: MD_LOOP(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: MD_LOOP_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-    case CA_FLOAT64: MD_LOOP_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+    case CA_FLOAT32: MD_LOOP_FLOAT(float);         break;
+    case CA_FLOAT64: MD_LOOP_FLOAT(double); break;
     case CA_OBJECT:  MD_LOOP_OBJ;                                            break;
     case CA_FIXLEN:  MD_LOOP_MEM;                                            break;
     }
@@ -841,6 +1156,12 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
   return vout;
 }
 
+static VALUE
+rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
+{
+  return fz_run(fz_mask_duplicates_body, fz_complex_as_key(self), vaxis, Qnil, 0);
+}
+
 /* @overload __unique_flat__
 
    INTERNAL (CArray#unique). Collect the distinct values of self in
@@ -865,11 +1186,13 @@ rb_ca_mask_duplicates (VALUE self, VALUE vaxis)
    uniform-width binary cells the fixlen seen-set used.
 */
 static VALUE
-rb_ca_unique_flat (VALUE self)
+fz_unique_flat_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "unique");
+  fr->self = self = fz_face_descend(self, &face, "unique");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -893,11 +1216,9 @@ rb_ca_unique_flat (VALUE self)
   if      ( dt == CA_OBJECT ) { fz_hash_init_obj(&h); }
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
-  fz_levels_init(&lv, (int) ca->bytes);
+  fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
 
-  int8_t axis = (int8_t) (ca->ndim - 1);   /* innermost fiber; hash not reset =
-                                              one seen-set over the whole array */
-  ca_iter_state st_in;
+  ca_iter_state *st_in = &fr->st[0];
   char       *p_in;
   boolean8_t *m;
   ca_size_t   n;
@@ -916,20 +1237,13 @@ rb_ca_unique_flat (VALUE self)
 
   /* Float: NaN collapses to one canonical key; -0.0 / +0.0 share a key. The
      pushed level is the raw first-seen element. */
-  #define UQ_LOOP_FLOAT(T, UINT, NANKEY)                                      \
+  #define UQ_LOOP_FLOAT(T)                                      \
     do {                                                                      \
       const T *ip = (const T *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         T v = ip[i];                                                          \
-        uint64_t key;                                                         \
-        if ( v != v ) { key = (NANKEY); }                                     \
-        else {                                                                \
-          if ( v == (T) 0 ) { v = (T) 0; }                                    \
-          UINT bits;                                                          \
-          memcpy(&bits, &v, sizeof(bits));                                    \
-          key = (uint64_t) bits;                                              \
-        }                                                                     \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                           \
         fz_hash_intern(&h, key, &is_new);                                     \
         if ( is_new ) { fz_levels_push(&lv, &ip[i]); }                        \
@@ -964,7 +1278,7 @@ rb_ca_unique_flat (VALUE self)
       }                                                                        \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
+  CA_FOR_EACH_WHOLE_MASKED(*st_in, ca, CA_KERNEL_READ, p_in, n, m) {
     switch ( dt ) {
     case CA_INT8:   UQ_LOOP(int8_t,   (int64_t));  break;
     case CA_INT16:  UQ_LOOP(int16_t,  (int64_t));  break;
@@ -974,8 +1288,8 @@ rb_ca_unique_flat (VALUE self)
     case CA_UINT16: UQ_LOOP(uint16_t, (uint64_t)); break;
     case CA_UINT32: UQ_LOOP(uint32_t, (uint64_t)); break;
     case CA_UINT64: UQ_LOOP(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: UQ_LOOP_FLOAT(float,  uint32_t, 0x7fc00000ULL);          break;
-    case CA_FLOAT64: UQ_LOOP_FLOAT(double, uint64_t, 0x7ff8000000000000ULL);  break;
+    case CA_FLOAT32: UQ_LOOP_FLOAT(float);          break;
+    case CA_FLOAT64: UQ_LOOP_FLOAT(double);  break;
     case CA_OBJECT:  UQ_LOOP_OBJ;                                             break;
     case CA_FIXLEN:  UQ_LOOP_MEM;                                             break;
     }
@@ -1002,8 +1316,14 @@ rb_ca_unique_flat (VALUE self)
   return fz_face_relift(vlev, face);   /* distinct *values*: give the Face back */
 }
 
+static VALUE
+rb_ca_unique_flat (VALUE self)
+{
+  return fz_run(fz_unique_flat_body, self, Qnil, Qnil, 0);
+}
+
 /* Intern every non-masked cell of cv into h, one seen-set over the whole array
-   (the hash is not reset between fibers).  When lv is non-NULL, the first-seen
+   walked in row-major order.  When lv is non-NULL, the first-seen
    raw element of each distinct value is pushed to it (appearance order), so the
    same pass builds both a probe set and the distinct-value list.  Dispatches the
    three key lanes exactly as the discovery family: numeric widen with all NaN
@@ -1011,11 +1331,9 @@ rb_ca_unique_flat (VALUE self)
    fixlen byte-hash + memcmp.  Used to build the probe set (is_in, set relations)
    and to accumulate distinct values (union). */
 static void
-fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
+fz_intern_all (ca_iter_state *st_v, fz_hash *h, CArray *cv, fz_levels *lv)
 {
   int8_t dt = cv->data_type;
-  int8_t vaxis = (int8_t) (cv->ndim - 1);
-  ca_iter_state st_v;
   char       *p_v;
   boolean8_t *mv;
   ca_size_t   nv;
@@ -1032,20 +1350,13 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
       }                                                                        \
     } while (0)
 
-  #define FZ_IA_FLOAT(T, UINT, NANKEY)                                         \
+  #define FZ_IA_FLOAT(T)                                         \
     do {                                                                       \
       const T *ip = (const T *) p_v;                                           \
       for ( ca_size_t i = 0; i < nv; i++ ) {                                   \
         if ( mv && mv[i] ) { continue; }                                       \
         T v = ip[i];                                                           \
-        uint64_t key;                                                          \
-        if ( v != v ) { key = (NANKEY); }                                      \
-        else {                                                                 \
-          if ( v == (T) 0 ) { v = (T) 0; }                                    \
-          UINT bits;                                                           \
-          memcpy(&bits, &v, sizeof(bits));                                     \
-          key = (uint64_t) bits;                                               \
-        }                                                                      \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                            \
         fz_hash_intern(h, key, &is_new);                                       \
         if ( is_new && lv ) { fz_levels_push(lv, &ip[i]); }                    \
@@ -1075,7 +1386,7 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
       }                                                                        \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(st_v, cv, vaxis, CA_KERNEL_READ, p_v, nv, mv) {
+  CA_FOR_EACH_WHOLE_MASKED(*st_v, cv, CA_KERNEL_READ, p_v, nv, mv) {
     switch ( dt ) {
     case CA_INT8:   FZ_IA(int8_t,   (int64_t));  break;
     case CA_INT16:  FZ_IA(int16_t,  (int64_t));  break;
@@ -1085,8 +1396,8 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
     case CA_UINT16: FZ_IA(uint16_t, (uint64_t)); break;
     case CA_UINT32: FZ_IA(uint32_t, (uint64_t)); break;
     case CA_UINT64: FZ_IA(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: FZ_IA_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-    case CA_FLOAT64: FZ_IA_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+    case CA_FLOAT32: FZ_IA_FLOAT(float);         break;
+    case CA_FLOAT64: FZ_IA_FLOAT(double); break;
     case CA_OBJECT:  FZ_IA_OBJ;                                            break;
     case CA_FIXLEN:  FZ_IA_MEM;                                            break;
     }
@@ -1115,12 +1426,15 @@ fz_intern_all (fz_hash *h, CArray *cv, fz_levels *lv)
    fixlen byte equality (byte-hash + memcmp).
 */
 static VALUE
-rb_ca_is_in (VALUE self, VALUE rvalues)
+fz_is_in_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE rvalues = fr->a;
   CArray *ca, *cv;
   volatile VALUE face;
-  self     = fz_face_descend(self, &face, "is_in");
-  rvalues  = fz_face_reconcile(face, rvalues, "is_in");
+  fr->self = self    = fz_face_descend(self, &face, "is_in");
+  fr->a    = rvalues = fz_face_reconcile(face, rvalues, "is_in");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -1145,12 +1459,12 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
   GetCArray(rvalues, cv);
   if ( cv->data_type != dt ) {
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: values data type (%s) must match self (%s)",
+             "is_in: values data type (%s) must match self (%s)",
              ca_type_name[cv->data_type], ca_type_name[dt]);
   }
   if ( dt == CA_FIXLEN && cv->bytes != ca->bytes ) {
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: a fixlen value is a cell-width blob, so the values "
+             "is_in: a fixlen value is a cell-width blob, so the values "
              "must be %ld bytes wide like self, not %ld",
              (long) ca->bytes, (long) cv->bytes);
   }
@@ -1164,14 +1478,14 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
   else                        { fz_hash_init(&h); }
 
   /* ---- Phase 1: build the seen-set from every non-masked cell of `values`. */
-  fz_intern_all(&h, cv, NULL);
+  fz_intern_all(&fr->st[2], &h, cv, NULL);
 
   /* ---- Phase 2: probe every cell of self, writing the boolean membership. */
   VALUE vout = rb_carray_new(CA_BOOLEAN, ca->ndim, ca->dim, 0, NULL);
   CArray *cout;
   GetCArray(vout, cout);
   {
-    ca_iter_state st_in, st_out;
+    ca_iter_state *st_in = &fr->st[0], *st_out = &fr->st[1];
     char       *p_in, *p_out;
     boolean8_t *m;
     ca_size_t   n;
@@ -1188,21 +1502,14 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
         }                                                                       \
       } while (0)
 
-    #define IN_PROBE_FLOAT(T, UINT, NANKEY)                                     \
+    #define IN_PROBE_FLOAT(T)                                     \
       do {                                                                      \
         const T    *ip = (const T *) p_in;                                      \
         boolean8_t *op = (boolean8_t *) p_out;                                  \
         for ( ca_size_t i = 0; i < n; i++ ) {                                   \
           if ( m && m[i] ) { op[i] = 0; continue; }                            \
           T v = ip[i];                                                          \
-          uint64_t key;                                                         \
-          if ( v != v ) { key = (NANKEY); }                                     \
-          else {                                                                \
-            if ( v == (T) 0 ) { v = (T) 0; }                                   \
-            UINT bits;                                                          \
-            memcpy(&bits, &v, sizeof(bits));                                    \
-            key = (uint64_t) bits;                                              \
-          }                                                                     \
+          uint64_t key = FZ_FLOAT_KEY(T, v);           \
           op[i] = (boolean8_t) fz_hash_lookup(&h, key, NULL);                        \
         }                                                                       \
       } while (0)
@@ -1227,7 +1534,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
         }                                                                       \
       } while (0)
 
-    CA_FOR_EACH_FIBER_INOUT_MASKED(st_in, st_out, ca, cout, axis,
+    CA_FOR_EACH_FIBER_INOUT_MASKED(*st_in, *st_out, ca, cout, axis,
                                    CA_KERNEL_READ, p_in, p_out, n, m) {
       switch ( dt ) {
       case CA_INT8:   IN_PROBE(int8_t,   (int64_t));  break;
@@ -1238,8 +1545,8 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
       case CA_UINT16: IN_PROBE(uint16_t, (uint64_t)); break;
       case CA_UINT32: IN_PROBE(uint32_t, (uint64_t)); break;
       case CA_UINT64: IN_PROBE(uint64_t, (uint64_t)); break;
-      case CA_FLOAT32: IN_PROBE_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-      case CA_FLOAT64: IN_PROBE_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+      case CA_FLOAT32: IN_PROBE_FLOAT(float);         break;
+      case CA_FLOAT64: IN_PROBE_FLOAT(double); break;
       case CA_OBJECT:  IN_PROBE_OBJ;                                            break;
       case CA_FIXLEN:  IN_PROBE_MEM;                                            break;
       }
@@ -1259,6 +1566,12 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
   return vout;
 }
 
+static VALUE
+rb_ca_is_in (VALUE self, VALUE rvalues)
+{
+  return fz_run(fz_is_in_body, self, rvalues, Qnil, 0);
+}
+
 /* @overload __locate_addr__(ref)
 
    INTERNAL (CArray#locate_addr, exact hash lane). For each cell of self, the
@@ -1276,16 +1589,19 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
    appearance order (matching the discovery family); on a `ref` with duplicate
    values this is the earliest address, which can differ from the bsearch lane. */
 static VALUE
-rb_ca_locate_addr (VALUE self, VALUE rref)
+fz_locate_addr_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE rref = fr->a;
   CArray *ca, *cr;
   /* Here the *reference* is the argument (self is the query being placed on
      rref), so the gate runs the other way round: rref reconciles self.  The
      output is an address, so nothing is lifted back. */
   {
     volatile VALUE ref_face;
-    rref = fz_face_descend(rref, &ref_face, "locate_addr");
-    self = fz_face_reconcile(ref_face, self, "locate_addr");
+    fr->a    = rref = fz_face_descend(rref, &ref_face, "locate_addr");
+    fr->self = self = fz_face_reconcile(ref_face, self, "locate_addr");
   }
   GetCArray(self, ca);
 
@@ -1308,9 +1624,16 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
     rb_raise(rb_eArgError, "__locate_addr__: ref must be a CArray");
   }
   GetCArray(rref, cr);
-  if ( cr->data_type != dt || (dt == CA_FIXLEN && cr->bytes != ca->bytes) ) {
+  if ( cr->data_type != dt ) {
     rb_raise(rb_eCADataTypeError,
-             "__locate_addr__: ref data type must match self (%d)", dt);
+             "locate_addr: ref data type (%s) must match self (%s)",
+             ca_type_name[cr->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && cr->bytes != ca->bytes ) {
+    rb_raise(rb_eCADataTypeError,
+             "locate_addr: a fixlen value is a cell-width blob, so ref "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) cr->bytes);
   }
   if ( cr->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__locate_addr__: ref need ndim >= 1");
@@ -1325,11 +1648,11 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
      the ref value carrying dense code `code`.  Codes are assigned 0,1,2,... in
      insertion order, so pushing on is_new fills addr.p in code order. */
   fz_levels addr;
-  fz_levels_init(&addr, (int) sizeof(int64_t));
+  fz_levels_init(&addr, (int) sizeof(int64_t), 0);
 
   /* ---- Phase 1: build value -> first-address map from ref (row-major). ----- */
   {
-    ca_iter_state st_r;
+    ca_iter_state *st_r = &fr->st[0];
     char       *p_r;
     boolean8_t *mr;
     ca_size_t   nr;
@@ -1349,20 +1672,13 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
         }                                                                       \
       } while (0)
 
-    #define LOC_BUILD_FLOAT(T, UINT, NANKEY)                                    \
+    #define LOC_BUILD_FLOAT(T)                                    \
       do {                                                                      \
         const T *ip = (const T *) p_r;                                          \
         for ( ca_size_t i = 0; i < nr; i++ ) {                                  \
           if ( mr && mr[i] ) { continue; }                                     \
           T v = ip[i];                                                          \
-          uint64_t key;                                                         \
-          if ( v != v ) { key = (NANKEY); }                                     \
-          else {                                                                \
-            if ( v == (T) 0 ) { v = (T) 0; }                                   \
-            UINT bits;                                                          \
-            memcpy(&bits, &v, sizeof(bits));                                    \
-            key = (uint64_t) bits;                                              \
-          }                                                                     \
+          uint64_t key = FZ_FLOAT_KEY(T, v);           \
           int is_new;                                                           \
           fz_hash_intern(&h, key, &is_new);                                     \
           if ( is_new ) { int64_t a = (int64_t) (base + i);                     \
@@ -1394,7 +1710,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
         }                                                                       \
       } while (0)
 
-    CA_FOR_EACH_FIBER_MASKED(st_r, cr, raxis, CA_KERNEL_READ, p_r, nr, mr) {
+    CA_FOR_EACH_FIBER_MASKED(*st_r, cr, raxis, CA_KERNEL_READ, p_r, nr, mr) {
       switch ( dt ) {
       case CA_INT8:   LOC_BUILD(int8_t,   (int64_t));  break;
       case CA_INT16:  LOC_BUILD(int16_t,  (int64_t));  break;
@@ -1404,8 +1720,8 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
       case CA_UINT16: LOC_BUILD(uint16_t, (uint64_t)); break;
       case CA_UINT32: LOC_BUILD(uint32_t, (uint64_t)); break;
       case CA_UINT64: LOC_BUILD(uint64_t, (uint64_t)); break;
-      case CA_FLOAT32: LOC_BUILD_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-      case CA_FLOAT64: LOC_BUILD_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+      case CA_FLOAT32: LOC_BUILD_FLOAT(float);         break;
+      case CA_FLOAT64: LOC_BUILD_FLOAT(double); break;
       case CA_OBJECT:  LOC_BUILD_OBJ;                                            break;
       case CA_FIXLEN:  LOC_BUILD_MEM;                                            break;
       }
@@ -1422,10 +1738,11 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
   CArray *cout;
   GetCArray(vout, cout);
   int64_t    *out = (int64_t *) cout->ptr;
-  boolean8_t *um  = ALLOC_N(boolean8_t, ca->elements);   /* undef flags scratch */
+  volatile VALUE hum = 0;
+  boolean8_t *um  = ALLOCV_N(boolean8_t, hum, ca->elements);   /* undef flags scratch */
   ca_size_t   n_undef = 0;
   {
-    ca_iter_state st_in;
+    ca_iter_state *st_in = &fr->st[1];
     char       *p_in;
     boolean8_t *m;
     ca_size_t   n;
@@ -1446,7 +1763,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
         }                                                                       \
       } while (0)
 
-    #define LOC_PROBE_FLOAT(T, UINT, NANKEY)                                    \
+    #define LOC_PROBE_FLOAT(T)                                    \
       do {                                                                      \
         const T *ip = (const T *) p_in;                                         \
         const int64_t *ab = (const int64_t *) addr.p;                           \
@@ -1454,14 +1771,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
           ca_size_t o = base + i;                                               \
           if ( m && m[i] ) { out[o] = 0; um[o] = 1; n_undef++; continue; }     \
           T v = ip[i];                                                          \
-          uint64_t key;                                                         \
-          if ( v != v ) { key = (NANKEY); }                                     \
-          else {                                                                \
-            if ( v == (T) 0 ) { v = (T) 0; }                                   \
-            UINT bits;                                                          \
-            memcpy(&bits, &v, sizeof(bits));                                    \
-            key = (uint64_t) bits;                                              \
-          }                                                                     \
+          uint64_t key = FZ_FLOAT_KEY(T, v);           \
           int32_t code;                                                         \
           if ( fz_hash_lookup(&h, key, &code) ) { out[o] = ab[code]; um[o] = 0; } \
           else { out[o] = 0; um[o] = 1; n_undef++; }                            \
@@ -1494,7 +1804,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
         }                                                                       \
       } while (0)
 
-    CA_FOR_EACH_FIBER_MASKED(st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
+    CA_FOR_EACH_FIBER_MASKED(*st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
       switch ( dt ) {
       case CA_INT8:   LOC_PROBE(int8_t,   (int64_t));  break;
       case CA_INT16:  LOC_PROBE(int16_t,  (int64_t));  break;
@@ -1504,8 +1814,8 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
       case CA_UINT16: LOC_PROBE(uint16_t, (uint64_t)); break;
       case CA_UINT32: LOC_PROBE(uint32_t, (uint64_t)); break;
       case CA_UINT64: LOC_PROBE(uint64_t, (uint64_t)); break;
-      case CA_FLOAT32: LOC_PROBE_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-      case CA_FLOAT64: LOC_PROBE_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+      case CA_FLOAT32: LOC_PROBE_FLOAT(float);         break;
+      case CA_FLOAT64: LOC_PROBE_FLOAT(double); break;
       case CA_OBJECT:  LOC_PROBE_OBJ;                                            break;
       case CA_FIXLEN:  LOC_PROBE_MEM;                                            break;
       }
@@ -1526,11 +1836,17 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
     ca_create_mask(cout);
     memcpy(cout->mask->ptr, um, (size_t) ca->elements);
   }
-  xfree(um);
+  ALLOCV_END(hum);
 
   return vout;
 }
 
+static VALUE
+rb_ca_locate_addr (VALUE self, VALUE rref)
+{
+  return fz_run(fz_locate_addr_body, self, rref, Qnil, 0);
+}
+
 /* Shared body of __intersection__ (keep_when_hit = 1) and __difference__
    (keep_when_hit = 0): the distinct values of self that are (resp. are not)
    present in `other`, in self's first-appearance order, as a 1-D CArray of
@@ -1540,12 +1856,16 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
    lane (numeric `==` + NaN collapse + -0.0 == +0.0, object hash/eql? + NaN
    collapse, fixlen byte equality). */
 static VALUE
-fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
+fz_set_relation_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE rother = fr->a;
+  int keep_when_hit = fr->i;
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face, "set relation");
-  rother = fz_face_reconcile(face, rother, "set relation");
+  fr->self = self   = fz_face_descend(self, &face, "set relation");
+  fr->a    = rother = fz_face_reconcile(face, rother, "set relation");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -1594,15 +1914,15 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
   }
 
   fz_levels lv;
-  fz_levels_init(&lv, (int) ca->bytes);
+  fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
 
   /* Build the probe set from every non-masked cell of other. */
-  fz_intern_all(&hoth, co, NULL);
+  fz_intern_all(&fr->st[2], &hoth, co, NULL);
 
   /* Walk self: hself dedups, so each distinct self value is decided once; keep
      it when its membership in other equals keep_when_hit. */
   int8_t axis = (int8_t) (ca->ndim - 1);
-  ca_iter_state st;
+  ca_iter_state *st = &fr->st[0];
   char       *p;
   boolean8_t *m;
   ca_size_t   n;
@@ -1621,20 +1941,13 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
       }                                                                        \
     } while (0)
 
-  #define SR_FLOAT(T, UINT, NANKEY)                                            \
+  #define SR_FLOAT(T)                                            \
     do {                                                                       \
       const T *ip = (const T *) p;                                             \
       for ( ca_size_t i = 0; i < n; i++ ) {                                    \
         if ( m && m[i] ) { continue; }                                         \
         T v = ip[i];                                                           \
-        uint64_t key;                                                          \
-        if ( v != v ) { key = (NANKEY); }                                      \
-        else {                                                                 \
-          if ( v == (T) 0 ) { v = (T) 0; }                                    \
-          UINT bits;                                                           \
-          memcpy(&bits, &v, sizeof(bits));                                     \
-          key = (uint64_t) bits;                                               \
-        }                                                                      \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                            \
         fz_hash_intern(&hself, key, &is_new);                                  \
         if ( is_new && fz_hash_lookup(&hoth, key, NULL) == keep_when_hit ) {   \
@@ -1670,7 +1983,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
       }                                                                        \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(st, ca, axis, CA_KERNEL_READ, p, n, m) {
+  CA_FOR_EACH_FIBER_MASKED(*st, ca, axis, CA_KERNEL_READ, p, n, m) {
     switch ( dt ) {
     case CA_INT8:   SR(int8_t,   (int64_t));  break;
     case CA_INT16:  SR(int16_t,  (int64_t));  break;
@@ -1680,8 +1993,8 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
     case CA_UINT16: SR(uint16_t, (uint64_t)); break;
     case CA_UINT32: SR(uint32_t, (uint64_t)); break;
     case CA_UINT64: SR(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: SR_FLOAT(float,  uint32_t, 0x7fc00000ULL);         break;
-    case CA_FLOAT64: SR_FLOAT(double, uint64_t, 0x7ff8000000000000ULL); break;
+    case CA_FLOAT32: SR_FLOAT(float);         break;
+    case CA_FLOAT64: SR_FLOAT(double); break;
     case CA_OBJECT:  SR_OBJ;                                            break;
     case CA_FIXLEN:  SR_MEM;                                            break;
     }
@@ -1708,6 +2021,12 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
   return fz_face_relift(vlev, face);   /* set *values*: give the Face back */
 }
 
+static VALUE
+fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
+{
+  return fz_run(fz_set_relation_body, self, rother, Qnil, keep_when_hit);
+}
+
 /* @overload __intersection__(other)
    INTERNAL (CArray#intersection). 1-D CArray of the distinct values present in
    both self and other, in self's first-appearance order. */
@@ -1733,12 +2052,15 @@ rb_ca_difference (VALUE self, VALUE rother)
    distinct values first, then other's not-yet-seen ones).  Masked cells of
    either array do not participate. */
 static VALUE
-rb_ca_set_union (VALUE self, VALUE rother)
+fz_set_union_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE rother = fr->a;
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face, "union");
-  rother = fz_face_reconcile(face, rother, "union");
+  fr->self = self   = fz_face_descend(self, &face, "union");
+  fr->a    = rother = fz_face_reconcile(face, rother, "union");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -1760,8 +2082,16 @@ rb_ca_set_union (VALUE self, VALUE rother)
     rb_raise(rb_eArgError, "__union__: other must be a CArray");
   }
   GetCArray(rother, co);
-  if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "__union__: other data type must match self (%d)", dt);
+  if ( co->data_type != dt ) {
+    rb_raise(rb_eCADataTypeError,
+             "union: other data type (%s) must match self (%s)",
+             ca_type_name[co->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && co->bytes != ca->bytes ) {
+    rb_raise(rb_eCADataTypeError,
+             "union: a fixlen value is a cell-width blob, so other "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) co->bytes);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__union__: other need ndim >= 1");
@@ -1773,10 +2103,10 @@ rb_ca_set_union (VALUE self, VALUE rother)
   else                        { fz_hash_init(&h); }
 
   fz_levels lv;
-  fz_levels_init(&lv, (int) ca->bytes);
+  fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
 
-  fz_intern_all(&h, ca, &lv);   /* self's distinct values, appearance order */
-  fz_intern_all(&h, co, &lv);   /* + other's not-yet-seen distinct values   */
+  fz_intern_all(&fr->st[2], &h, ca, &lv);   /* self's distinct values, appearance order */
+  fz_intern_all(&fr->st[2], &h, co, &lv);   /* + other's not-yet-seen distinct values   */
 
   ca_size_t k = lv.n;
   fz_hash_free(&h);
@@ -1794,6 +2124,12 @@ rb_ca_set_union (VALUE self, VALUE rother)
   return fz_face_relift(vlev, face);   /* set *values*: give the Face back */
 }
 
+static VALUE
+rb_ca_set_union (VALUE self, VALUE rother)
+{
+  return fz_run(fz_set_union_body, self, rother, Qnil, 0);
+}
+
 /* @overload __value_counts_flat__
 
    INTERNAL (CArray#value_counts). Collect the distinct values of self in
@@ -1810,11 +2146,13 @@ rb_ca_set_union (VALUE self, VALUE rother)
    collapses every Float NaN to one value (their counts add up, as numeric does).
 */
 static VALUE
-rb_ca_value_counts_flat (VALUE self)
+fz_value_counts_flat_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "value_counts");
+  fr->self = self = fz_face_descend(self, &face, "value_counts");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -1839,11 +2177,11 @@ rb_ca_value_counts_flat (VALUE self)
   if      ( dt == CA_OBJECT ) { fz_hash_init_obj(&h); }
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
-  fz_levels_init(&lv, (int) ca->bytes);
-  fz_levels_init(&ct, (int) sizeof(int64_t));
+  fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
+  fz_levels_init(&ct, (int) sizeof(int64_t), 0);
 
   int8_t axis = (int8_t) (ca->ndim - 1);   /* one seen-set over the whole array */
-  ca_iter_state st_in;
+  ca_iter_state *st_in = &fr->st[0];
   char       *p_in;
   boolean8_t *m;
   ca_size_t   n;
@@ -1866,20 +2204,13 @@ rb_ca_value_counts_flat (VALUE self)
       }                                                                       \
     } while (0)
 
-  #define VC_LOOP_FLOAT(T, UINT, NANKEY)                                      \
+  #define VC_LOOP_FLOAT(T)                                      \
     do {                                                                      \
       const T *ip = (const T *) p_in;                                         \
       for ( ca_size_t i = 0; i < n; i++ ) {                                   \
         if ( m && m[i] ) { continue; }                                        \
         T v = ip[i];                                                          \
-        uint64_t key;                                                         \
-        if ( v != v ) { key = (NANKEY); }                                     \
-        else {                                                                \
-          if ( v == (T) 0 ) { v = (T) 0; }                                    \
-          UINT bits;                                                          \
-          memcpy(&bits, &v, sizeof(bits));                                    \
-          key = (uint64_t) bits;                                              \
-        }                                                                     \
+        uint64_t key = FZ_FLOAT_KEY(T, v);             \
         int is_new;                                                           \
         int32_t code = fz_hash_intern(&h, key, &is_new);                      \
         if ( is_new ) {                                                       \
@@ -1929,7 +2260,7 @@ rb_ca_value_counts_flat (VALUE self)
       }                                                                       \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
+  CA_FOR_EACH_FIBER_MASKED(*st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
     switch ( dt ) {
     case CA_INT8:   VC_LOOP(int8_t,   (int64_t));  break;
     case CA_INT16:  VC_LOOP(int16_t,  (int64_t));  break;
@@ -1939,8 +2270,8 @@ rb_ca_value_counts_flat (VALUE self)
     case CA_UINT16: VC_LOOP(uint16_t, (uint64_t)); break;
     case CA_UINT32: VC_LOOP(uint32_t, (uint64_t)); break;
     case CA_UINT64: VC_LOOP(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: VC_LOOP_FLOAT(float,  uint32_t, 0x7fc00000ULL);          break;
-    case CA_FLOAT64: VC_LOOP_FLOAT(double, uint64_t, 0x7ff8000000000000ULL);  break;
+    case CA_FLOAT32: VC_LOOP_FLOAT(float);          break;
+    case CA_FLOAT64: VC_LOOP_FLOAT(double);  break;
     case CA_OBJECT:  VC_LOOP_OBJ;                                             break;
     case CA_FIXLEN:  VC_LOOP_MEM;                                             break;
     }
@@ -1973,20 +2304,30 @@ rb_ca_value_counts_flat (VALUE self)
   return rb_ary_new3(2, fz_face_relift(vlev, face), vcnt);
 }
 
+static VALUE
+rb_ca_value_counts_flat (VALUE self)
+{
+  return fz_run(fz_value_counts_flat_body, self, Qnil, Qnil, 0);
+}
+
 /* @overload __nunique__(axis, keep_axis)
 
-   INTERNAL (CArray#nunique). Count the distinct values along axis, one linear
-   pass per fiber with an independent seen-set. Returns a reduced
-   CA_INT64 CArray of self.shape with axis removed (or kept as length-1 when
-   keep_axis). Masked cells do not participate; an all-masked fiber counts 0
+   INTERNAL (CArray#nunique). Count the distinct values along axis (an Integer
+   or an Array of them), one linear pass per fiber with an independent
+   seen-set. Returns a reduced CA_INT64 CArray of self.shape with the axes
+   removed (or kept as length-1 when keep_axis). Masked cells do not participate; an all-masked fiber counts 0
    (an empty set has zero distinct values, not UNDEF -- nunique has identity 0).
    Numeric distinctness collapses all NaN to one value and treats -0.0 == +0.0;
    object keys on rb_hash + rb_eql and fixlen on a byte-hash + memcmp, reproducing
    Ruby Hash distinctness; the object lane also collapses every Float NaN to one.
 */
 static VALUE
-rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
+fz_nunique_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE vaxis = fr->a;
+  VALUE vkeep = fr->b;
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
@@ -2006,14 +2347,11 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
     rb_raise(rb_eRuntimeError, "__nunique__: need ndim >= 1");
   }
 
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 || axis >= ca->ndim ) {
-    rb_raise(rb_eArgError, "__nunique__: axis %d out of range", axis);
-  }
+  int8_t axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw_ctx(vaxis, ca, axes, "nunique");
   int keep_axis = RTEST(vkeep);
 
-  int8_t ax = (int8_t) axis;
-  VALUE vout = rb_ca_new_reduced(self, &ax, 1, CA_INT64, keep_axis);
+  VALUE vout = rb_ca_new_reduced(self, axes, naxes, CA_INT64, keep_axis);
   CArray *cout;
   TypedData_Get_Struct(vout, CArray, &carray_data_type, cout);
   int64_t *op = (int64_t *) cout->ptr;
@@ -2023,8 +2361,8 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
 
-  ca_iter_state st;
-  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES, &ax, 1, 0);
+  ca_iter_state *st = &fr->st[0];
+  int rc = ca_iter_state_init_l2(st, ca, CA_SLAB_AXES, axes, naxes, 0);
   if ( rc != CA_ITER_OK ) {
     fz_hash_free(&h);
     rb_raise(rb_eRuntimeError, "__nunique__: kernel_iterator init failed rc=%d", rc);
@@ -2040,17 +2378,10 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
      -0.0 before the bitwise key. */
   #define NU_INT(WIDEN)                                                       \
     do { int _n; fz_hash_intern(&h, (uint64_t) ((WIDEN) v), &_n); } while (0)
-  #define NU_FLOAT(T, UINT, NANKEY)                                           \
+  #define NU_FLOAT(T)                                           \
     do {                                                                      \
       T _v = v;                                                               \
-      uint64_t _key;                                                          \
-      if ( _v != _v ) { _key = (NANKEY); }                                    \
-      else {                                                                  \
-        if ( _v == (T) 0 ) { _v = (T) 0; }                                    \
-        UINT _b;                                                              \
-        memcpy(&_b, &_v, sizeof(_b));                                         \
-        _key = (uint64_t) _b;                                                 \
-      }                                                                       \
+      uint64_t _key = FZ_FLOAT_KEY(T, _v);           \
       int _n; fz_hash_intern(&h, _key, &_n);                                  \
     } while (0)
   /* Object: intern the VALUE via the object lane (v is bound by the macro). */
@@ -2062,43 +2393,43 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
      each esz-wide element via the fixlen lane. */
   #define NU_MEM_WALK                                                         \
     do {                                                                      \
-      int8_t K = st.slab_ndim;                                               \
+      int8_t K = st->slab_ndim;                                              \
       ca_size_t idx[CA_RANK_MAX] = { 0 };                                    \
-      ca_size_t total = st.slab_elements;                                    \
+      ca_size_t total = st->slab_elements;                                   \
       for ( ca_size_t e = 0; e < total; e++ ) {                             \
         ca_size_t doff = 0, moff = 0;                                        \
         for ( int8_t kk = 0; kk < K; kk++ ) {                               \
-          doff += idx[kk] * st.slab_strides[kk];                            \
-          moff += idx[kk] * st.slab_mask_strides[kk];                       \
+          doff += idx[kk] * st->slab_strides[kk];                           \
+          moff += idx[kk] * st->slab_mask_strides[kk];                      \
         }                                                                    \
         if ( ! (m && m[moff]) ) {                                           \
           int _n; fz_hash_intern_mem(&h, p + doff, &_n);                    \
         }                                                                    \
         for ( int8_t kk = (int8_t)(K - 1); kk >= 0; kk-- ) {               \
-          if ( ++idx[kk] < st.slab_dims[kk] ) break;                        \
+          if ( ++idx[kk] < st->slab_dims[kk] ) break;                       \
           idx[kk] = 0;                                                      \
         }                                                                    \
       }                                                                      \
     } while (0)
 
-  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+  while ( ca_iter_state_next_slab_axes(st, &p, &m) ) {
     fz_hash_reset(&h);   /* independent seen-set per fiber */
     switch ( dt ) {
-    case CA_INT8:   CA_SLAB_REDUCE_T(int8_t,   st, p, m, dummy, 0, NU_INT(int64_t));  break;
-    case CA_INT16:  CA_SLAB_REDUCE_T(int16_t,  st, p, m, dummy, 0, NU_INT(int64_t));  break;
-    case CA_INT32:  CA_SLAB_REDUCE_T(int32_t,  st, p, m, dummy, 0, NU_INT(int64_t));  break;
-    case CA_INT64:  CA_SLAB_REDUCE_T(int64_t,  st, p, m, dummy, 0, NU_INT(int64_t));  break;
-    case CA_BOOLEAN: case CA_UINT8:  CA_SLAB_REDUCE_T(uint8_t,  st, p, m, dummy, 0, NU_INT(uint64_t)); break;
-    case CA_UINT16: CA_SLAB_REDUCE_T(uint16_t, st, p, m, dummy, 0, NU_INT(uint64_t)); break;
-    case CA_UINT32: CA_SLAB_REDUCE_T(uint32_t, st, p, m, dummy, 0, NU_INT(uint64_t)); break;
-    case CA_UINT64: CA_SLAB_REDUCE_T(uint64_t, st, p, m, dummy, 0, NU_INT(uint64_t)); break;
+    case CA_INT8:   CA_SLAB_REDUCE_T(int8_t,   *st, p, m, dummy, 0, NU_INT(int64_t));  break;
+    case CA_INT16:  CA_SLAB_REDUCE_T(int16_t,  *st, p, m, dummy, 0, NU_INT(int64_t));  break;
+    case CA_INT32:  CA_SLAB_REDUCE_T(int32_t,  *st, p, m, dummy, 0, NU_INT(int64_t));  break;
+    case CA_INT64:  CA_SLAB_REDUCE_T(int64_t,  *st, p, m, dummy, 0, NU_INT(int64_t));  break;
+    case CA_BOOLEAN: case CA_UINT8:  CA_SLAB_REDUCE_T(uint8_t,  *st, p, m, dummy, 0, NU_INT(uint64_t)); break;
+    case CA_UINT16: CA_SLAB_REDUCE_T(uint16_t, *st, p, m, dummy, 0, NU_INT(uint64_t)); break;
+    case CA_UINT32: CA_SLAB_REDUCE_T(uint32_t, *st, p, m, dummy, 0, NU_INT(uint64_t)); break;
+    case CA_UINT64: CA_SLAB_REDUCE_T(uint64_t, *st, p, m, dummy, 0, NU_INT(uint64_t)); break;
     case CA_FLOAT32:
-      CA_SLAB_REDUCE_T(float,  st, p, m, dummy, 0, NU_FLOAT(float,  uint32_t, 0x7fc00000ULL));
+      CA_SLAB_REDUCE_T(float,  *st, p, m, dummy, 0, NU_FLOAT(float));
       break;
     case CA_FLOAT64:
-      CA_SLAB_REDUCE_T(double, st, p, m, dummy, 0, NU_FLOAT(double, uint64_t, 0x7ff8000000000000ULL));
+      CA_SLAB_REDUCE_T(double, *st, p, m, dummy, 0, NU_FLOAT(double));
       break;
-    case CA_OBJECT: CA_SLAB_REDUCE_T(VALUE, st, p, m, dummy, 0, NU_OBJ); break;
+    case CA_OBJECT: CA_SLAB_REDUCE_T(VALUE, *st, p, m, dummy, 0, NU_OBJ); break;
     case CA_FIXLEN: NU_MEM_WALK;                                          break;
     }
     op[out_i++] = (int64_t) h.n;
@@ -2109,11 +2440,17 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
   #undef NU_MEM_WALK
   (void) dummy;
 
-  ca_iter_state_finish(&st);
+  ca_iter_state_finish(st);
   fz_hash_free(&h);
   return vout;
 }
 
+static VALUE
+rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
+{
+  return fz_run(fz_nunique_body, fz_complex_as_key(self), vaxis, vkeep, 0);
+}
+
 /* @overload __is_mode__(axis)
 
    INTERNAL (CArray#is_mode). Mark each cell that holds a modal value along axis
@@ -2132,8 +2469,11 @@ rb_ca_nunique (VALUE self, VALUE vaxis, VALUE vkeep)
    Callers pass flat input by flattening first (a single fiber over axis 0).
 */
 static VALUE
-rb_ca_is_mode (VALUE self, VALUE vaxis)
+fz_is_mode_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE vaxis = fr->a;
   CArray *ca;
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
@@ -2166,9 +2506,9 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
   if      ( dt == CA_OBJECT ) { fz_hash_init_obj(&h); }
   else if ( dt == CA_FIXLEN ) { fz_hash_init_mem(&h, (int) ca->bytes); }
   else                        { fz_hash_init(&h); }
-  fz_levels_init(&ct, (int) sizeof(int64_t));
+  fz_levels_init(&ct, (int) sizeof(int64_t), 0);
 
-  ca_iter_state st_in, st_out;
+  ca_iter_state *st_in = &fr->st[0], *st_out = &fr->st[1];
   char       *p_in, *p_out;
   boolean8_t *m;
   ca_size_t   n;
@@ -2201,7 +2541,7 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
     } while (0)
 
   /* Float: NaN collapses to one canonical key; -0.0 / +0.0 share a key. */
-  #define IM_BODY_FLOAT(T, UINT, NANKEY)                                      \
+  #define IM_BODY_FLOAT(T)                                      \
     do {                                                                      \
       const T    *ip = (const T *) p_in;                                      \
       boolean8_t *op = (boolean8_t *) p_out;                                  \
@@ -2216,14 +2556,7 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
         for ( ca_size_t i = 0; i < n; i++ ) {                                 \
           if ( m && m[i] ) { if ( pass == 1 ) { op[i] = 0; } continue; }      \
           T v = ip[i];                                                        \
-          uint64_t key;                                                       \
-          if ( v != v ) { key = (NANKEY); }                                   \
-          else {                                                              \
-            if ( v == (T) 0 ) { v = (T) 0; }                                  \
-            UINT bits;                                                        \
-            memcpy(&bits, &v, sizeof(bits));                                  \
-            key = (uint64_t) bits;                                            \
-          }                                                                   \
+          uint64_t key = FZ_FLOAT_KEY(T, v);           \
           int is_new;                                                         \
           int32_t code = fz_hash_intern(&h, key, &is_new);                    \
           if ( pass == 0 ) {                                                  \
@@ -2287,7 +2620,7 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
       }                                                                       \
     } while (0)
 
-  CA_FOR_EACH_FIBER_INOUT_MASKED(st_in, st_out, ca, cout, (int8_t) axis,
+  CA_FOR_EACH_FIBER_INOUT_MASKED(*st_in, *st_out, ca, cout, (int8_t) axis,
                                  CA_KERNEL_READ, p_in, p_out, n, m) {
     fz_hash_reset(&h);   /* independent frequency table per fiber */
     ct.n = 0;
@@ -2300,8 +2633,8 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
     case CA_UINT16: IM_BODY(uint16_t, (uint64_t)); break;
     case CA_UINT32: IM_BODY(uint32_t, (uint64_t)); break;
     case CA_UINT64: IM_BODY(uint64_t, (uint64_t)); break;
-    case CA_FLOAT32: IM_BODY_FLOAT(float,  uint32_t, 0x7fc00000ULL);          break;
-    case CA_FLOAT64: IM_BODY_FLOAT(double, uint64_t, 0x7ff8000000000000ULL);  break;
+    case CA_FLOAT32: IM_BODY_FLOAT(float);          break;
+    case CA_FLOAT64: IM_BODY_FLOAT(double);  break;
     case CA_OBJECT:  IM_BODY_OBJ;                                            break;
     case CA_FIXLEN:  IM_BODY_MEM;                                            break;
     }
@@ -2316,6 +2649,12 @@ rb_ca_is_mode (VALUE self, VALUE vaxis)
   return vout;
 }
 
+static VALUE
+rb_ca_is_mode (VALUE self, VALUE vaxis)
+{
+  return fz_run(fz_is_mode_body, fz_complex_as_key(self), vaxis, Qnil, 0);
+}
+
 /* Ascending comparison for the modal-value sort, NaN ordered last so a
    collapsed NaN key (at most one per fiber) trails the real values, matching
    CArray#sort. */
@@ -2349,11 +2688,14 @@ static int mode_gt_f64 (double a, double b) { if ( a != a ) return b == b; if (
    its sign), matching the discovery family.
 */
 static VALUE
-rb_ca_mode_axis (VALUE self, VALUE vaxis)
+fz_mode_axis_body (VALUE arg)
 {
+  fz_frame *fr = (fz_frame *) arg;
+  VALUE self = fr->self;
+  VALUE vaxis = fr->a;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "mode");
+  fr->self = self = fz_face_descend(self, &face, "mode");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -2387,20 +2729,21 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
   fz_levels mod;    /* per-fiber modal values, collected then sorted (reset) */
   fz_levels flat;   /* all fibers' modal values concatenated, fiber order */
   fz_hash_init(&h);
-  fz_levels_init(&lv,   esz);
-  fz_levels_init(&ct,   (int) sizeof(int64_t));
-  fz_levels_init(&mod,  esz);
-  fz_levels_init(&flat, esz);
+  fz_levels_init(&lv,   esz, 0);
+  fz_levels_init(&ct,   (int) sizeof(int64_t), 0);
+  fz_levels_init(&mod,  esz, 0);
+  fz_levels_init(&flat, esz, 0);
 
-  ca_size_t *foff = ALLOC_N(ca_size_t, M + 1);   /* prefix offsets into flat */
+  volatile VALUE hfoff = 0;
+  ca_size_t *foff = ALLOCV_N(ca_size_t, hfoff, M + 1);   /* prefix offsets into flat */
   foff[0] = 0;
 
   int8_t ax = (int8_t) axis;
-  ca_iter_state st;
-  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES, &ax, 1, 0);
+  ca_iter_state *st = &fr->st[0];
+  int rc = ca_iter_state_init_l2(st, ca, CA_SLAB_AXES, &ax, 1, 0);
   if ( rc != CA_ITER_OK ) {
     fz_hash_free(&h); fz_levels_free(&lv); fz_levels_free(&ct);
-    fz_levels_free(&mod); fz_levels_free(&flat); xfree(foff);
+    fz_levels_free(&mod); fz_levels_free(&flat); ALLOCV_END(hfoff);
     rb_raise(rb_eRuntimeError, "__mode_axis__: kernel_iterator init failed rc=%d", rc);
   }
 
@@ -2421,12 +2764,9 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
                       fz_levels_push(&ct, &one); }                           \
       else { ((int64_t *) ct.p)[code]++; }                                    \
     } while (0)
-  #define MB_FLOAT(T, UINT, NANKEY)                                           \
+  #define MB_FLOAT(T)                                           \
     do {                                                                      \
-      T vn = v; uint64_t key;                                                 \
-      if ( vn != vn ) { key = (NANKEY); }                                     \
-      else { if ( vn == (T) 0 ) { vn = (T) 0; }                              \
-             UINT bits; memcpy(&bits, &vn, sizeof(bits)); key = (uint64_t) bits; } \
+      uint64_t key = FZ_FLOAT_KEY(T, v);                                      \
       int is_new; int32_t code = fz_hash_intern(&h, key, &is_new);            \
       if ( is_new ) { int64_t one = 1; fz_levels_push(&lv, &v);              \
                       fz_levels_push(&ct, &one); }                           \
@@ -2450,24 +2790,24 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
       for ( ca_size_t x = 0; x < cm; x++ ) { fz_levels_push(&flat, &dp[x]); } \
     } while (0)
 
-  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+  while ( ca_iter_state_next_slab_axes(st, &p, &m) ) {
     fz_hash_reset(&h);
     lv.n = 0; ct.n = 0; mod.n = 0;
 
     switch ( dt ) {
-    case CA_INT8:   CA_SLAB_REDUCE_T(int8_t,   st, p, m, dummy, 0, MB_INT(int64_t));  break;
-    case CA_INT16:  CA_SLAB_REDUCE_T(int16_t,  st, p, m, dummy, 0, MB_INT(int64_t));  break;
-    case CA_INT32:  CA_SLAB_REDUCE_T(int32_t,  st, p, m, dummy, 0, MB_INT(int64_t));  break;
-    case CA_INT64:  CA_SLAB_REDUCE_T(int64_t,  st, p, m, dummy, 0, MB_INT(int64_t));  break;
-    case CA_BOOLEAN: case CA_UINT8:  CA_SLAB_REDUCE_T(uint8_t,  st, p, m, dummy, 0, MB_INT(uint64_t)); break;
-    case CA_UINT16: CA_SLAB_REDUCE_T(uint16_t, st, p, m, dummy, 0, MB_INT(uint64_t)); break;
-    case CA_UINT32: CA_SLAB_REDUCE_T(uint32_t, st, p, m, dummy, 0, MB_INT(uint64_t)); break;
-    case CA_UINT64: CA_SLAB_REDUCE_T(uint64_t, st, p, m, dummy, 0, MB_INT(uint64_t)); break;
+    case CA_INT8:   CA_SLAB_REDUCE_T(int8_t,   *st, p, m, dummy, 0, MB_INT(int64_t));  break;
+    case CA_INT16:  CA_SLAB_REDUCE_T(int16_t,  *st, p, m, dummy, 0, MB_INT(int64_t));  break;
+    case CA_INT32:  CA_SLAB_REDUCE_T(int32_t,  *st, p, m, dummy, 0, MB_INT(int64_t));  break;
+    case CA_INT64:  CA_SLAB_REDUCE_T(int64_t,  *st, p, m, dummy, 0, MB_INT(int64_t));  break;
+    case CA_BOOLEAN: case CA_UINT8:  CA_SLAB_REDUCE_T(uint8_t,  *st, p, m, dummy, 0, MB_INT(uint64_t)); break;
+    case CA_UINT16: CA_SLAB_REDUCE_T(uint16_t, *st, p, m, dummy, 0, MB_INT(uint64_t)); break;
+    case CA_UINT32: CA_SLAB_REDUCE_T(uint32_t, *st, p, m, dummy, 0, MB_INT(uint64_t)); break;
+    case CA_UINT64: CA_SLAB_REDUCE_T(uint64_t, *st, p, m, dummy, 0, MB_INT(uint64_t)); break;
     case CA_FLOAT32:
-      CA_SLAB_REDUCE_T(float,  st, p, m, dummy, 0, MB_FLOAT(float,  uint32_t, 0x7fc00000ULL));
+      CA_SLAB_REDUCE_T(float,  *st, p, m, dummy, 0, MB_FLOAT(float));
       break;
     case CA_FLOAT64:
-      CA_SLAB_REDUCE_T(double, st, p, m, dummy, 0, MB_FLOAT(double, uint64_t, 0x7ff8000000000000ULL));
+      CA_SLAB_REDUCE_T(double, *st, p, m, dummy, 0, MB_FLOAT(double));
       break;
     }
 
@@ -2499,7 +2839,7 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
   #undef MODE_EMIT
   (void) dummy;
 
-  ca_iter_state_finish(&st);
+  ca_iter_state_finish(st);
   fz_hash_free(&h);
   fz_levels_free(&lv);
   fz_levels_free(&ct);
@@ -2529,10 +2869,16 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
   }
 
   fz_levels_free(&flat);
-  xfree(foff);
+  ALLOCV_END(hfoff);
   return result;
 }
 
+static VALUE
+rb_ca_mode_axis (VALUE self, VALUE vaxis)
+{
+  return fz_run(fz_mode_axis_body, self, vaxis, Qnil, 0);
+}
+
 void
 Init_carray_factorize (void)
 {