carray 3.0.2 → 3.0.4

data/ext/carray_kernels_sort.c

@@ -24,6 +24,13 @@
    probed by operation-table function pointer (obj_type is runtime-
    assigned, so no CA_OBJ_STACK compile-time constant exists). */
 extern ca_operation_function_t ca_stack_func;
+/* The square root of a variance: an ε-negative from rounding becomes 0,
+   a NaN stays NaN (fmax(NaN, 0.0) is 0.0). */
+#ifndef CARRAY_SQRT_CLAMP_DEFINED
+#define CARRAY_SQRT_CLAMP_DEFINED
+static inline double ca_sqrt_clamp (double v) { return sqrt(v < 0.0 ? 0.0 : v); }
+#endif
+
 /* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
    for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
    return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
@@ -61,21 +68,21 @@ sort_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_i8 *buf =
-    xmalloc(sizeof(sort_index_pair_i8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_i8 *buf = ALLOCV_N(sort_index_pair_i8, hbuf, fiber_n);
   sort_index_pair_i8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_i8) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_i8, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -146,8 +153,8 @@ sort_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int ma
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -176,21 +183,21 @@ sort_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_u8 *buf =
-    xmalloc(sizeof(sort_index_pair_u8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_u8 *buf = ALLOCV_N(sort_index_pair_u8, hbuf, fiber_n);
   sort_index_pair_u8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_u8) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_u8, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -261,8 +268,8 @@ sort_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int ma
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -291,21 +298,21 @@ sort_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_i16 *buf =
-    xmalloc(sizeof(sort_index_pair_i16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_i16 *buf = ALLOCV_N(sort_index_pair_i16, hbuf, fiber_n);
   sort_index_pair_i16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_i16) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_i16, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -376,8 +383,8 @@ sort_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -406,21 +413,21 @@ sort_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_u16 *buf =
-    xmalloc(sizeof(sort_index_pair_u16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_u16 *buf = ALLOCV_N(sort_index_pair_u16, hbuf, fiber_n);
   sort_index_pair_u16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_u16) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_u16, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -491,8 +498,8 @@ sort_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -521,21 +528,21 @@ sort_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_i32 *buf =
-    xmalloc(sizeof(sort_index_pair_i32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_i32 *buf = ALLOCV_N(sort_index_pair_i32, hbuf, fiber_n);
   sort_index_pair_i32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_i32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_i32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -606,8 +613,8 @@ sort_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -636,21 +643,21 @@ sort_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_u32 *buf =
-    xmalloc(sizeof(sort_index_pair_u32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_u32 *buf = ALLOCV_N(sort_index_pair_u32, hbuf, fiber_n);
   sort_index_pair_u32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_u32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_u32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -721,8 +728,8 @@ sort_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -751,21 +758,21 @@ sort_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_i64 *buf =
-    xmalloc(sizeof(sort_index_pair_i64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_i64 *buf = ALLOCV_N(sort_index_pair_i64, hbuf, fiber_n);
   sort_index_pair_i64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_i64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_i64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -836,8 +843,8 @@ sort_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -866,21 +873,21 @@ sort_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_u64 *buf =
-    xmalloc(sizeof(sort_index_pair_u64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_u64 *buf = ALLOCV_N(sort_index_pair_u64, hbuf, fiber_n);
   sort_index_pair_u64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_u64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_u64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -951,8 +958,8 @@ sort_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -981,21 +988,21 @@ sort_index_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_f32 *buf =
-    xmalloc(sizeof(sort_index_pair_f32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_f32 *buf = ALLOCV_N(sort_index_pair_f32, hbuf, fiber_n);
   sort_index_pair_f32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_f32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_f32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -1070,8 +1077,8 @@ sort_index_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1100,21 +1107,21 @@ sort_index_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_f64 *buf =
-    xmalloc(sizeof(sort_index_pair_f64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_f64 *buf = ALLOCV_N(sort_index_pair_f64, hbuf, fiber_n);
   sort_index_pair_f64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_f64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_f64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -1189,8 +1196,8 @@ sort_index_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int m
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1219,21 +1226,21 @@ sort_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_bool *buf =
-    xmalloc(sizeof(sort_index_pair_bool) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_bool *buf = ALLOCV_N(sort_index_pair_bool, hbuf, fiber_n);
   sort_index_pair_bool *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_bool) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_bool, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -1304,8 +1311,8 @@ sort_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1321,23 +1328,42 @@ sort_index_cmp_object (const void *a, const void *b)
 {
   const sort_index_pair_object *pa = (const sort_index_pair_object *) a;
   const sort_index_pair_object *pb = (const sort_index_pair_object *) b;
-  VALUE r = rb_funcall(pa->v, rb_intern("<=>"), 1, pb->v);
-  if ( NIL_P(r) ) {
-    rb_raise(rb_eArgError, "sort_index_ki: comparison of %s with %s failed",
-             rb_obj_classname(pa->v), rb_obj_classname(pb->v));
-  }
-  int c = NUM2INT(r);
-  if ( c > 0 ) return 1;
-  if ( c < 0 ) return -1;
+  int c = ca_obj_order_cmp(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
   return 0;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+  int do_stable;
+  int masked_last;
+} sort_index_ki_native_object_frame;
+
 static VALUE
-sort_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int masked_last)
-{
+sort_index_ki_native_object_body (VALUE arg)
+{
+  sort_index_ki_native_object_frame *fr = (sort_index_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+  int do_stable = fr->do_stable;
+  (void) do_stable;
+  int masked_last = fr->masked_last;
+  (void) masked_last;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_SIZE),
                                           INT2NUM(0));
   CArray *co;
@@ -1348,27 +1374,23 @@ sort_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
      positions align between iterators. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_object *buf =
-    xmalloc(sizeof(sort_index_pair_object) * (size_t) fiber_n);
-  sort_index_pair_object *aux = NULL;
-  if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_object) * (size_t) fiber_n);
-  }
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_object *buf = ALLOCV_N(sort_index_pair_object, hbuf, fiber_n);
+  sort_index_pair_object *aux = ALLOCV_N(sort_index_pair_object, haux, fiber_n);
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -1427,21 +1449,36 @@ sort_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
        selects introsort with mergesort escape (= AC1 1.88x payoff).
        Only the unmasked sub-range [sort_lo, sort_lo+sort_n) is
        sorted -- see emit_sort_mask_split_load in mkkernel.rb. */
-    (void) do_stable;   /* CA_OBJECT: qsort handles both stable / quick */
-    qsort((buf + sort_lo), (size_t) sort_n, sizeof(sort_index_pair_object), sort_index_cmp_object);
+    (void) do_stable;   /* CA_OBJECT: one stable sort serves both kinds */
+    ca_sort_merge_pair_object((ca_pair_object *) (buf + sort_lo), (ca_pair_object *) aux, (ca_size_t) sort_n, sort_index_cmp_object);
     /* Write sorted fiber-local indices to output fiber. */
     for ( ca_size_t k = 0; k < fiber_n; k++ ) {
       *(ca_size_t *) (po + k * ostride) = (ca_size_t) buf[k].i;
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+sort_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int masked_last)
+{
+  sort_index_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  fr.do_stable = do_stable;
+  fr.masked_last = masked_last;
+  return ca_iter_ensure(2, fr.states, sort_index_ki_native_object_body, (VALUE) &fr);
+}
+
+
 typedef struct {
   char     *vp;   /* pointer to the fiber cell (nb bytes wide) */
   ca_size_t nb;   /* element byte width (= ca->bytes) */
@@ -1479,21 +1516,21 @@ sort_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_index_pair_fixlen *buf =
-    xmalloc(sizeof(sort_index_pair_fixlen) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_index_pair_fixlen *buf = ALLOCV_N(sort_index_pair_fixlen, hbuf, fiber_n);
   sort_index_pair_fixlen *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_index_pair_fixlen) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_index_pair_fixlen, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -1565,8 +1602,8 @@ sort_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1577,46 +1614,39 @@ sort_index_ki_dispatch (VALUE self, VALUE vaxis, int do_stable, int masked_last)
 {
   CArray *src;
   GetCArray(self, src);
-  /* Face gate: descend to storage (fixlen -> memcmp default,
-     numeric -> ORDERABLE required).  The strip also makes the
-     switch below and every index/addr template output build on
-     the plain storage, not a face-lifted (NULL-ptr) view. */
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  /* Face gate: run on the array the Face's order is read from.
+     It is never a Face, so the switch below and every index/addr
+     template output build on a plain array, not a face-lifted
+     (NULL-ptr) view. */
   if ( ca_is_face(src) ) {
-    VALUE _face = self;
-    int _orderable = ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE);
-    VALUE _st = rb_ca_strip_face_value(self);
-    CArray *_sc;
-    GetCArray(_st, _sc);
-    if ( _sc->data_type != CA_FIXLEN && ! _orderable ) {
-      rb_raise(rb_eArgError,
-               "sort_index_ki: Face-typed input (%s) is not orderable "
-               "by storage; use ca.parent to descend to storage",
-               rb_obj_classname(_face));
-    }
-    self = _st;
-    src = _sc;
-  }
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "sort_index_ki: axis %d out of range for ndim %d", NUM2INT(vaxis), src->ndim);
+    self = ca_order_key(self, ca_calling_method_name());
+    GetCArray(self, src);
   }
+  int axis = ca_normalize_axis_arg(vaxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return sort_index_ki_native_i8(self, src, axis, do_stable, masked_last);
-    case CA_UINT8: return sort_index_ki_native_u8(self, src, axis, do_stable, masked_last);
-    case CA_INT16: return sort_index_ki_native_i16(self, src, axis, do_stable, masked_last);
-    case CA_UINT16: return sort_index_ki_native_u16(self, src, axis, do_stable, masked_last);
-    case CA_INT32: return sort_index_ki_native_i32(self, src, axis, do_stable, masked_last);
-    case CA_UINT32: return sort_index_ki_native_u32(self, src, axis, do_stable, masked_last);
-    case CA_INT64: return sort_index_ki_native_i64(self, src, axis, do_stable, masked_last);
-    case CA_UINT64: return sort_index_ki_native_u64(self, src, axis, do_stable, masked_last);
-    case CA_FLOAT32: return sort_index_ki_native_f32(self, src, axis, do_stable, masked_last);
-    case CA_FLOAT64: return sort_index_ki_native_f64(self, src, axis, do_stable, masked_last);
-    case CA_BOOLEAN: return sort_index_ki_native_bool(self, src, axis, do_stable, masked_last);
-    case CA_OBJECT: return sort_index_ki_native_object(self, src, axis, do_stable, masked_last);
-    case CA_FIXLEN: return sort_index_ki_native_fixlen(self, src, axis, do_stable, masked_last);
+    case CA_INT8: CA_RETURN_KEEPING(self, sort_index_ki_native_i8(self, src, axis, do_stable, masked_last));
+    case CA_UINT8: CA_RETURN_KEEPING(self, sort_index_ki_native_u8(self, src, axis, do_stable, masked_last));
+    case CA_INT16: CA_RETURN_KEEPING(self, sort_index_ki_native_i16(self, src, axis, do_stable, masked_last));
+    case CA_UINT16: CA_RETURN_KEEPING(self, sort_index_ki_native_u16(self, src, axis, do_stable, masked_last));
+    case CA_INT32: CA_RETURN_KEEPING(self, sort_index_ki_native_i32(self, src, axis, do_stable, masked_last));
+    case CA_UINT32: CA_RETURN_KEEPING(self, sort_index_ki_native_u32(self, src, axis, do_stable, masked_last));
+    case CA_INT64: CA_RETURN_KEEPING(self, sort_index_ki_native_i64(self, src, axis, do_stable, masked_last));
+    case CA_UINT64: CA_RETURN_KEEPING(self, sort_index_ki_native_u64(self, src, axis, do_stable, masked_last));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, sort_index_ki_native_f32(self, src, axis, do_stable, masked_last));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, sort_index_ki_native_f64(self, src, axis, do_stable, masked_last));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, sort_index_ki_native_bool(self, src, axis, do_stable, masked_last));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, sort_index_ki_native_object(self, src, axis, do_stable, masked_last));
+    case CA_FIXLEN: CA_RETURN_KEEPING(self, sort_index_ki_native_fixlen(self, src, axis, do_stable, masked_last));
     default:
-      rb_raise(rb_eCADataTypeError, "sort_index_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object, fixlen)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object, fixlen)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -1647,34 +1677,19 @@ rb_ca_sort_index_kw (int argc, VALUE *argv, VALUE self)
   volatile VALUE rkind = Qnil;
   volatile VALUE rmasked_position = Qnil;
   rb_scan_options(ropt, "axis,kind,masked_position", &raxis, &rkind, &rmasked_position);
-  if ( NIL_P(raxis) ) raxis = INT2NUM(0);   /* default axis */
-  int masked_last = 1;   /* default masked_position: :last */
-  if ( ! NIL_P(rmasked_position) ) {
-    static ID sym_first = 0, sym_last = 0;
-    if ( ! sym_first ) sym_first = rb_intern("first");
-    if ( ! sym_last )  sym_last  = rb_intern("last");
-    ID mp_id = SYM2ID(rmasked_position);
-    if      ( mp_id == sym_last )  masked_last = 1;
-    else if ( mp_id == sym_first ) masked_last = 0;
-    else {
-      rb_raise(rb_eArgError, "sort_index: unknown masked_position %s (expected :first or :last)", rb_id2name(mp_id));
+  if ( NIL_P(raxis) ) {   /* no axis: the whole array */
+    {
+      volatile VALUE evaluated = ca_lazy_evaluated(self);
+      if ( ! NIL_P(evaluated) ) self = evaluated;
     }
+    self  = rb_ca_flatten(self);
+    raxis = INT2NUM(0);
   }
+  int masked_last = NIL_P(rmasked_position) ? 1 : ca_symbol_choice(rmasked_position, "masked_position", "first", "last", NULL);
   if ( argc != 0 ) {
     rb_raise(rb_eArgError, "sort_index: positional args no longer accepted (given %d args); use axis:/kind: kwargs", argc);
   }
-  int do_stable = 0;
-  if ( ! NIL_P(rkind) ) {
-    static ID sym_quick = 0, sym_stable = 0;
-    if ( ! sym_quick )  sym_quick  = rb_intern("quick");
-    if ( ! sym_stable ) sym_stable = rb_intern("stable");
-    ID kind_id = SYM2ID(rkind);
-    if      ( kind_id == sym_quick )  do_stable = 0;
-    else if ( kind_id == sym_stable ) do_stable = 1;
-    else {
-      rb_raise(rb_eArgError, "sort_index: unknown kind %s (expected :quick or :stable)", rb_id2name(kind_id));
-    }
-  }
+  int do_stable = NIL_P(rkind) ? 0 : ca_symbol_choice(rkind, "kind", "quick", "stable", NULL);
   return sort_index_ki_dispatch(self, raxis, do_stable, masked_last);
 }
 
@@ -1703,21 +1718,21 @@ sort_addr_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int mas
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_i8 *buf =
-    xmalloc(sizeof(sort_addr_pair_i8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_i8 *buf = ALLOCV_N(sort_addr_pair_i8, hbuf, fiber_n);
   sort_addr_pair_i8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_i8) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_i8, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -1820,8 +1835,8 @@ sort_addr_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int mas
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1850,21 +1865,21 @@ sort_addr_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int mas
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_u8 *buf =
-    xmalloc(sizeof(sort_addr_pair_u8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_u8 *buf = ALLOCV_N(sort_addr_pair_u8, hbuf, fiber_n);
   sort_addr_pair_u8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_u8) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_u8, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -1967,8 +1982,8 @@ sort_addr_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int mas
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -1997,21 +2012,21 @@ sort_addr_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_i16 *buf =
-    xmalloc(sizeof(sort_addr_pair_i16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_i16 *buf = ALLOCV_N(sort_addr_pair_i16, hbuf, fiber_n);
   sort_addr_pair_i16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_i16) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_i16, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2114,8 +2129,8 @@ sort_addr_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2144,21 +2159,21 @@ sort_addr_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_u16 *buf =
-    xmalloc(sizeof(sort_addr_pair_u16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_u16 *buf = ALLOCV_N(sort_addr_pair_u16, hbuf, fiber_n);
   sort_addr_pair_u16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_u16) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_u16, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2261,8 +2276,8 @@ sort_addr_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2291,21 +2306,21 @@ sort_addr_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_i32 *buf =
-    xmalloc(sizeof(sort_addr_pair_i32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_i32 *buf = ALLOCV_N(sort_addr_pair_i32, hbuf, fiber_n);
   sort_addr_pair_i32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_i32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_i32, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2408,8 +2423,8 @@ sort_addr_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2438,21 +2453,21 @@ sort_addr_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_u32 *buf =
-    xmalloc(sizeof(sort_addr_pair_u32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_u32 *buf = ALLOCV_N(sort_addr_pair_u32, hbuf, fiber_n);
   sort_addr_pair_u32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_u32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_u32, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2555,8 +2570,8 @@ sort_addr_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2585,21 +2600,21 @@ sort_addr_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_i64 *buf =
-    xmalloc(sizeof(sort_addr_pair_i64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_i64 *buf = ALLOCV_N(sort_addr_pair_i64, hbuf, fiber_n);
   sort_addr_pair_i64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_i64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_i64, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2702,8 +2717,8 @@ sort_addr_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2732,21 +2747,21 @@ sort_addr_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_u64 *buf =
-    xmalloc(sizeof(sort_addr_pair_u64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_u64 *buf = ALLOCV_N(sort_addr_pair_u64, hbuf, fiber_n);
   sort_addr_pair_u64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_u64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_u64, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -2849,8 +2864,8 @@ sort_addr_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -2879,21 +2894,21 @@ sort_addr_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_f32 *buf =
-    xmalloc(sizeof(sort_addr_pair_f32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_f32 *buf = ALLOCV_N(sort_addr_pair_f32, hbuf, fiber_n);
   sort_addr_pair_f32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_f32) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_f32, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -3000,8 +3015,8 @@ sort_addr_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -3030,21 +3045,21 @@ sort_addr_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_f64 *buf =
-    xmalloc(sizeof(sort_addr_pair_f64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_f64 *buf = ALLOCV_N(sort_addr_pair_f64, hbuf, fiber_n);
   sort_addr_pair_f64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_f64) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_f64, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -3151,8 +3166,8 @@ sort_addr_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int ma
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -3181,21 +3196,21 @@ sort_addr_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int m
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_bool *buf =
-    xmalloc(sizeof(sort_addr_pair_bool) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_bool *buf = ALLOCV_N(sort_addr_pair_bool, hbuf, fiber_n);
   sort_addr_pair_bool *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_bool) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_bool, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -3298,8 +3313,8 @@ sort_addr_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int m
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -3315,23 +3330,42 @@ sort_addr_cmp_object (const void *a, const void *b)
 {
   const sort_addr_pair_object *pa = (const sort_addr_pair_object *) a;
   const sort_addr_pair_object *pb = (const sort_addr_pair_object *) b;
-  VALUE r = rb_funcall(pa->v, rb_intern("<=>"), 1, pb->v);
-  if ( NIL_P(r) ) {
-    rb_raise(rb_eArgError, "sort_addr_ki: comparison of %s with %s failed",
-             rb_obj_classname(pa->v), rb_obj_classname(pb->v));
-  }
-  int c = NUM2INT(r);
-  if ( c > 0 ) return 1;
-  if ( c < 0 ) return -1;
+  int c = ca_obj_order_cmp(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
   return 0;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+  int do_stable;
+  int masked_last;
+} sort_addr_ki_native_object_frame;
+
 static VALUE
-sort_addr_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int masked_last)
-{
+sort_addr_ki_native_object_body (VALUE arg)
+{
+  sort_addr_ki_native_object_frame *fr = (sort_addr_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+  int do_stable = fr->do_stable;
+  (void) do_stable;
+  int masked_last = fr->masked_last;
+  (void) masked_last;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_SIZE),
                                           INT2NUM(0));
   CArray *co;
@@ -3342,27 +3376,23 @@ sort_addr_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int
      positions align between iterators. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_object *buf =
-    xmalloc(sizeof(sort_addr_pair_object) * (size_t) fiber_n);
-  sort_addr_pair_object *aux = NULL;
-  if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_object) * (size_t) fiber_n);
-  }
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_object *buf = ALLOCV_N(sort_addr_pair_object, hbuf, fiber_n);
+  sort_addr_pair_object *aux = ALLOCV_N(sort_addr_pair_object, haux, fiber_n);
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -3448,8 +3478,8 @@ sort_addr_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int
        selects introsort with mergesort escape (= AC1 1.88x payoff).
        Only the unmasked sub-range [sort_lo, sort_lo+sort_n) is
        sorted -- see emit_sort_mask_split_load in mkkernel.rb. */
-    (void) do_stable;   /* CA_OBJECT: qsort handles both stable / quick */
-    qsort((buf + sort_lo), (size_t) sort_n, sizeof(sort_addr_pair_object), sort_addr_cmp_object);
+    (void) do_stable;   /* CA_OBJECT: one stable sort serves both kinds */
+    ca_sort_merge_pair_object((ca_pair_object *) (buf + sort_lo), (ca_pair_object *) aux, (ca_size_t) sort_n, sort_addr_cmp_object);
     /* Write sorted view-flat addresses to output fiber. */
     for ( ca_size_t k = 0; k < fiber_n; k++ ) {
       *(ca_size_t *) (po + k * ostride) = (ca_size_t) buf[k].i;
@@ -3461,13 +3491,28 @@ sort_addr_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+sort_addr_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int masked_last)
+{
+  sort_addr_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  fr.do_stable = do_stable;
+  fr.masked_last = masked_last;
+  return ca_iter_ensure(2, fr.states, sort_addr_ki_native_object_body, (VALUE) &fr);
+}
+
+
 typedef struct {
   char     *vp;   /* pointer to the fiber cell (nb bytes wide) */
   ca_size_t nb;   /* element byte width (= ca->bytes) */
@@ -3505,21 +3550,21 @@ sort_addr_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, int
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "sort_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  sort_addr_pair_fixlen *buf =
-    xmalloc(sizeof(sort_addr_pair_fixlen) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  sort_addr_pair_fixlen *buf = ALLOCV_N(sort_addr_pair_fixlen, hbuf, fiber_n);
   sort_addr_pair_fixlen *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(sort_addr_pair_fixlen) * (size_t) fiber_n);
+    aux = ALLOCV_N(sort_addr_pair_fixlen, haux, fiber_n);
   }
 
   /* :view_flat semantics: kernel computes view-flat address
@@ -3623,8 +3668,8 @@ sort_addr_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, int
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -3635,68 +3680,43 @@ sort_addr_ki_dispatch (VALUE self, VALUE vaxis, int do_stable, int masked_last)
 {
   CArray *src;
   GetCArray(self, src);
-  /* Face gate: descend to storage (fixlen -> memcmp default,
-     numeric -> ORDERABLE required).  The strip also makes the
-     switch below and every index/addr template output build on
-     the plain storage, not a face-lifted (NULL-ptr) view. */
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  /* Face gate: run on the array the Face's order is read from.
+     It is never a Face, so the switch below and every index/addr
+     template output build on a plain array, not a face-lifted
+     (NULL-ptr) view. */
   if ( ca_is_face(src) ) {
-    VALUE _face = self;
-    int _orderable = ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE);
-    VALUE _st = rb_ca_strip_face_value(self);
-    CArray *_sc;
-    GetCArray(_st, _sc);
-    if ( _sc->data_type != CA_FIXLEN && ! _orderable ) {
-      rb_raise(rb_eArgError,
-               "sort_addr_ki: Face-typed input (%s) is not orderable "
-               "by storage; use ca.parent to descend to storage",
-               rb_obj_classname(_face));
-    }
-    self = _st;
-    src = _sc;
-  }
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "sort_addr_ki: axis %d out of range for ndim %d", NUM2INT(vaxis), src->ndim);
+    self = ca_order_key(self, ca_calling_method_name());
+    GetCArray(self, src);
   }
+  int axis = ca_normalize_axis_arg(vaxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return sort_addr_ki_native_i8(self, src, axis, do_stable, masked_last);
-    case CA_UINT8: return sort_addr_ki_native_u8(self, src, axis, do_stable, masked_last);
-    case CA_INT16: return sort_addr_ki_native_i16(self, src, axis, do_stable, masked_last);
-    case CA_UINT16: return sort_addr_ki_native_u16(self, src, axis, do_stable, masked_last);
-    case CA_INT32: return sort_addr_ki_native_i32(self, src, axis, do_stable, masked_last);
-    case CA_UINT32: return sort_addr_ki_native_u32(self, src, axis, do_stable, masked_last);
-    case CA_INT64: return sort_addr_ki_native_i64(self, src, axis, do_stable, masked_last);
-    case CA_UINT64: return sort_addr_ki_native_u64(self, src, axis, do_stable, masked_last);
-    case CA_FLOAT32: return sort_addr_ki_native_f32(self, src, axis, do_stable, masked_last);
-    case CA_FLOAT64: return sort_addr_ki_native_f64(self, src, axis, do_stable, masked_last);
-    case CA_BOOLEAN: return sort_addr_ki_native_bool(self, src, axis, do_stable, masked_last);
-    case CA_OBJECT: return sort_addr_ki_native_object(self, src, axis, do_stable, masked_last);
-    case CA_FIXLEN: return sort_addr_ki_native_fixlen(self, src, axis, do_stable, masked_last);
+    case CA_INT8: CA_RETURN_KEEPING(self, sort_addr_ki_native_i8(self, src, axis, do_stable, masked_last));
+    case CA_UINT8: CA_RETURN_KEEPING(self, sort_addr_ki_native_u8(self, src, axis, do_stable, masked_last));
+    case CA_INT16: CA_RETURN_KEEPING(self, sort_addr_ki_native_i16(self, src, axis, do_stable, masked_last));
+    case CA_UINT16: CA_RETURN_KEEPING(self, sort_addr_ki_native_u16(self, src, axis, do_stable, masked_last));
+    case CA_INT32: CA_RETURN_KEEPING(self, sort_addr_ki_native_i32(self, src, axis, do_stable, masked_last));
+    case CA_UINT32: CA_RETURN_KEEPING(self, sort_addr_ki_native_u32(self, src, axis, do_stable, masked_last));
+    case CA_INT64: CA_RETURN_KEEPING(self, sort_addr_ki_native_i64(self, src, axis, do_stable, masked_last));
+    case CA_UINT64: CA_RETURN_KEEPING(self, sort_addr_ki_native_u64(self, src, axis, do_stable, masked_last));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, sort_addr_ki_native_f32(self, src, axis, do_stable, masked_last));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, sort_addr_ki_native_f64(self, src, axis, do_stable, masked_last));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, sort_addr_ki_native_bool(self, src, axis, do_stable, masked_last));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, sort_addr_ki_native_object(self, src, axis, do_stable, masked_last));
+    case CA_FIXLEN: CA_RETURN_KEEPING(self, sort_addr_ki_native_fixlen(self, src, axis, do_stable, masked_last));
     default:
-      rb_raise(rb_eCADataTypeError, "sort_addr_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object, fixlen)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object, fixlen)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
 
-VALUE
-rb_ca_sort_addr_ki_quick (VALUE self, VALUE vaxis)
-{
-  return sort_addr_ki_dispatch(self, vaxis, 0, 1);
-}
-
-VALUE
-rb_ca_sort_addr_ki_stable (VALUE self, VALUE vaxis)
-{
-  return sort_addr_ki_dispatch(self, vaxis, 1, 1);
-}
-
-VALUE
-rb_ca_sort_addr_ki (VALUE self, VALUE vaxis)
-{
-  return rb_ca_sort_addr_ki_quick(self, vaxis);
-}
-
 VALUE
 rb_ca_sort_addr_ki_quick_mp (VALUE self, VALUE vaxis, int masked_last)
 {
@@ -3802,18 +3822,19 @@ partition_index_ki_native_i8 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_i8 *buf =
-    xmalloc(sizeof(partition_index_pair_i8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_i8 *buf = ALLOCV_N(partition_index_pair_i8, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -3882,7 +3903,8 @@ partition_index_ki_native_i8 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -3979,18 +4001,19 @@ partition_index_ki_native_u8 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_u8 *buf =
-    xmalloc(sizeof(partition_index_pair_u8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_u8 *buf = ALLOCV_N(partition_index_pair_u8, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4059,7 +4082,8 @@ partition_index_ki_native_u8 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -4156,18 +4180,19 @@ partition_index_ki_native_i16 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_i16 *buf =
-    xmalloc(sizeof(partition_index_pair_i16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_i16 *buf = ALLOCV_N(partition_index_pair_i16, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4236,7 +4261,8 @@ partition_index_ki_native_i16 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -4333,18 +4359,19 @@ partition_index_ki_native_u16 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_u16 *buf =
-    xmalloc(sizeof(partition_index_pair_u16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_u16 *buf = ALLOCV_N(partition_index_pair_u16, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4413,7 +4440,8 @@ partition_index_ki_native_u16 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -4510,18 +4538,19 @@ partition_index_ki_native_i32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_i32 *buf =
-    xmalloc(sizeof(partition_index_pair_i32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_i32 *buf = ALLOCV_N(partition_index_pair_i32, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4590,7 +4619,8 @@ partition_index_ki_native_i32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -4687,18 +4717,19 @@ partition_index_ki_native_u32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_u32 *buf =
-    xmalloc(sizeof(partition_index_pair_u32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_u32 *buf = ALLOCV_N(partition_index_pair_u32, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4767,7 +4798,8 @@ partition_index_ki_native_u32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -4864,18 +4896,19 @@ partition_index_ki_native_i64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_i64 *buf =
-    xmalloc(sizeof(partition_index_pair_i64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_i64 *buf = ALLOCV_N(partition_index_pair_i64, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -4944,7 +4977,8 @@ partition_index_ki_native_i64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -5041,18 +5075,19 @@ partition_index_ki_native_u64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_u64 *buf =
-    xmalloc(sizeof(partition_index_pair_u64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_u64 *buf = ALLOCV_N(partition_index_pair_u64, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -5121,7 +5156,8 @@ partition_index_ki_native_u64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -5137,12 +5173,8 @@ partition_index_cmp_f32 (const void *a, const void *b)
 {
   const partition_index_pair_f32 *pa = (const partition_index_pair_f32 *) a;
   const partition_index_pair_f32 *pb = (const partition_index_pair_f32 *) b;
-  int nan_a = isnan(pa->v);
-  int nan_b = isnan(pb->v);
-  if ( nan_a && !nan_b ) return 1;
-  if ( nan_b && !nan_a ) return -1;
-  if ( pa->v > pb->v ) return 1;
-  if ( pa->v < pb->v ) return -1;
+  int c = CA_FLOAT_ORDER_CMP(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -5222,18 +5254,19 @@ partition_index_ki_native_f32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_f32 *buf =
-    xmalloc(sizeof(partition_index_pair_f32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_f32 *buf = ALLOCV_N(partition_index_pair_f32, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -5302,7 +5335,8 @@ partition_index_ki_native_f32 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -5318,12 +5352,8 @@ partition_index_cmp_f64 (const void *a, const void *b)
 {
   const partition_index_pair_f64 *pa = (const partition_index_pair_f64 *) a;
   const partition_index_pair_f64 *pb = (const partition_index_pair_f64 *) b;
-  int nan_a = isnan(pa->v);
-  int nan_b = isnan(pb->v);
-  if ( nan_a && !nan_b ) return 1;
-  if ( nan_b && !nan_a ) return -1;
-  if ( pa->v > pb->v ) return 1;
-  if ( pa->v < pb->v ) return -1;
+  int c = CA_FLOAT_ORDER_CMP(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -5403,18 +5433,19 @@ partition_index_ki_native_f64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_f64 *buf =
-    xmalloc(sizeof(partition_index_pair_f64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_f64 *buf = ALLOCV_N(partition_index_pair_f64, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -5483,7 +5514,8 @@ partition_index_ki_native_f64 (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -5580,18 +5612,19 @@ partition_index_ki_native_bool (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_bool *buf =
-    xmalloc(sizeof(partition_index_pair_bool) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_bool *buf = ALLOCV_N(partition_index_pair_bool, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -5660,7 +5693,8 @@ partition_index_ki_native_bool (VALUE self, CArray *ca, int axis, ca_size_t kth,
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -5676,14 +5710,8 @@ partition_index_cmp_object (const void *a, const void *b)
 {
   const partition_index_pair_object *pa = (const partition_index_pair_object *) a;
   const partition_index_pair_object *pb = (const partition_index_pair_object *) b;
-  VALUE r = rb_funcall(pa->v, rb_intern("<=>"), 1, pb->v);
-  if ( NIL_P(r) ) {
-    rb_raise(rb_eArgError, "partition_index_ki: comparison of %s with %s failed",
-             rb_obj_classname(pa->v), rb_obj_classname(pb->v));
-  }
-  int c = NUM2INT(r);
-  if ( c > 0 ) return 1;
-  if ( c < 0 ) return -1;
+  int c = ca_obj_order_cmp(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -5745,9 +5773,34 @@ partition_index_quickselect_object (partition_index_pair_object *arr,
   }
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+  ca_size_t kth;
+  int masked_last;
+} partition_index_ki_native_object_frame;
+
 static VALUE
-partition_index_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth, int masked_last)
-{
+partition_index_ki_native_object_body (VALUE arg)
+{
+  partition_index_ki_native_object_frame *fr = (partition_index_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+  ca_size_t kth = fr->kth;
+  (void) kth;
+  int masked_last = fr->masked_last;
+  (void) masked_last;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_SIZE),
                                           INT2NUM(0));
   CArray *co;
@@ -5758,23 +5811,23 @@ partition_index_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kt
      positions align between iterators. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_object *buf =
-    xmalloc(sizeof(partition_index_pair_object) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_object *buf = ALLOCV_N(partition_index_pair_object, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -5843,12 +5896,28 @@ partition_index_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kt
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+partition_index_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth, int masked_last)
+{
+  partition_index_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  fr.kth = kth;
+  fr.masked_last = masked_last;
+  return ca_iter_ensure(2, fr.states, partition_index_ki_native_object_body, (VALUE) &fr);
+}
+
+
 typedef struct {
   char     *vp;   /* pointer to the fiber cell (nb bytes wide) */
   ca_size_t nb;   /* element byte width (= ca->bytes) */
@@ -5941,18 +6010,19 @@ partition_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, ca_size_t kt
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_index_pair_fixlen *buf =
-    xmalloc(sizeof(partition_index_pair_fixlen) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_index_pair_fixlen *buf = ALLOCV_N(partition_index_pair_fixlen, hbuf, fiber_n);
+  (void) haux;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -6021,7 +6091,8 @@ partition_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, ca_size_t kt
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -6032,50 +6103,43 @@ partition_index_ki_dispatch (VALUE self, VALUE vaxis, VALUE vkth, int masked_las
 {
   CArray *src;
   GetCArray(self, src);
-  /* Face gate (partition): same as the sort dispatcher --
-     fixlen -> memcmp default, numeric -> ORDERABLE required. */
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  /* Face gate (partition): same as the sort dispatcher. */
   if ( ca_is_face(src) ) {
-    VALUE _face = self;
-    int _orderable = ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE);
-    VALUE _st = rb_ca_strip_face_value(self);
-    CArray *_sc;
-    GetCArray(_st, _sc);
-    if ( _sc->data_type != CA_FIXLEN && ! _orderable ) {
-      rb_raise(rb_eArgError,
-               "partition_index_ki: Face-typed input (%s) is not orderable "
-               "by storage; use ca.parent to descend to storage",
-               rb_obj_classname(_face));
-    }
-    self = _st;
-    src = _sc;
-  }
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "partition_index_ki: axis %d out of range for ndim %d", NUM2INT(vaxis), src->ndim);
-  }
-  ca_size_t kth = NUM2SIZE(vkth);
+    self = ca_order_key(self, ca_calling_method_name());
+    GetCArray(self, src);
+  }
+  int axis = ca_normalize_axis_arg(vaxis, src->ndim, NULL);
+  ca_size_t kth_raw = (ca_size_t) ca_integer_arg(vkth, "kth", NULL);
+  ca_size_t kth = kth_raw;
   ca_size_t axis_n = src->dim[axis];
   if ( kth < 0 ) kth += axis_n;
   if ( kth < 0 || kth >= axis_n ) {
-    rb_raise(rb_eArgError, "partition_index_ki: kth %lld out of range for axis size %lld", (long long) NUM2SIZE(vkth), (long long) axis_n);
+    rb_raise(rb_eArgError, "%s: kth %lld out of range for length %lld", ca_calling_method_name(), (long long) kth_raw, (long long) axis_n);
   }
   switch ( src->data_type ) {
-    case CA_INT8: return partition_index_ki_native_i8(self, src, axis, kth, masked_last);
-    case CA_UINT8: return partition_index_ki_native_u8(self, src, axis, kth, masked_last);
-    case CA_INT16: return partition_index_ki_native_i16(self, src, axis, kth, masked_last);
-    case CA_UINT16: return partition_index_ki_native_u16(self, src, axis, kth, masked_last);
-    case CA_INT32: return partition_index_ki_native_i32(self, src, axis, kth, masked_last);
-    case CA_UINT32: return partition_index_ki_native_u32(self, src, axis, kth, masked_last);
-    case CA_INT64: return partition_index_ki_native_i64(self, src, axis, kth, masked_last);
-    case CA_UINT64: return partition_index_ki_native_u64(self, src, axis, kth, masked_last);
-    case CA_FLOAT32: return partition_index_ki_native_f32(self, src, axis, kth, masked_last);
-    case CA_FLOAT64: return partition_index_ki_native_f64(self, src, axis, kth, masked_last);
-    case CA_BOOLEAN: return partition_index_ki_native_bool(self, src, axis, kth, masked_last);
-    case CA_OBJECT: return partition_index_ki_native_object(self, src, axis, kth, masked_last);
-    case CA_FIXLEN: return partition_index_ki_native_fixlen(self, src, axis, kth, masked_last);
+    case CA_INT8: CA_RETURN_KEEPING(self, partition_index_ki_native_i8(self, src, axis, kth, masked_last));
+    case CA_UINT8: CA_RETURN_KEEPING(self, partition_index_ki_native_u8(self, src, axis, kth, masked_last));
+    case CA_INT16: CA_RETURN_KEEPING(self, partition_index_ki_native_i16(self, src, axis, kth, masked_last));
+    case CA_UINT16: CA_RETURN_KEEPING(self, partition_index_ki_native_u16(self, src, axis, kth, masked_last));
+    case CA_INT32: CA_RETURN_KEEPING(self, partition_index_ki_native_i32(self, src, axis, kth, masked_last));
+    case CA_UINT32: CA_RETURN_KEEPING(self, partition_index_ki_native_u32(self, src, axis, kth, masked_last));
+    case CA_INT64: CA_RETURN_KEEPING(self, partition_index_ki_native_i64(self, src, axis, kth, masked_last));
+    case CA_UINT64: CA_RETURN_KEEPING(self, partition_index_ki_native_u64(self, src, axis, kth, masked_last));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, partition_index_ki_native_f32(self, src, axis, kth, masked_last));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, partition_index_ki_native_f64(self, src, axis, kth, masked_last));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, partition_index_ki_native_bool(self, src, axis, kth, masked_last));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, partition_index_ki_native_object(self, src, axis, kth, masked_last));
+    case CA_FIXLEN: CA_RETURN_KEEPING(self, partition_index_ki_native_fixlen(self, src, axis, kth, masked_last));
     default:
-      rb_raise(rb_eCADataTypeError, "partition_index_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object, fixlen)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object, fixlen)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -6093,19 +6157,15 @@ rb_ca_partition_index_kw (int argc, VALUE *argv, VALUE self)
   volatile VALUE raxis = Qnil;
   volatile VALUE rmasked_position = Qnil;
   rb_scan_options(ropt, "axis,masked_position", &raxis, &rmasked_position);
-  if ( NIL_P(raxis) ) raxis = INT2NUM(0);   /* default axis */
-  int masked_last = 1;   /* default masked_position: :last */
-  if ( ! NIL_P(rmasked_position) ) {
-    static ID sym_first = 0, sym_last = 0;
-    if ( ! sym_first ) sym_first = rb_intern("first");
-    if ( ! sym_last )  sym_last  = rb_intern("last");
-    ID mp_id = SYM2ID(rmasked_position);
-    if      ( mp_id == sym_last )  masked_last = 1;
-    else if ( mp_id == sym_first ) masked_last = 0;
-    else {
-      rb_raise(rb_eArgError, "partition_index: unknown masked_position %s (expected :first or :last)", rb_id2name(mp_id));
+  if ( NIL_P(raxis) ) {   /* no axis: the whole array */
+    {
+      volatile VALUE evaluated = ca_lazy_evaluated(self);
+      if ( ! NIL_P(evaluated) ) self = evaluated;
     }
+    self  = rb_ca_flatten(self);
+    raxis = INT2NUM(0);
   }
+  int masked_last = NIL_P(rmasked_position) ? 1 : ca_symbol_choice(rmasked_position, "masked_position", "first", "last", NULL);
   if ( argc != 1 ) {
     rb_raise(rb_eArgError, "partition_index: wrong number of positional arguments (given %d, expected 1: kth)", argc);
   }
@@ -6205,18 +6265,19 @@ partition_addr_ki_native_i8 (VALUE self, CArray *ca, int axis, ca_size_t kth, in
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_i8 *buf =
-    xmalloc(sizeof(partition_addr_pair_i8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_i8 *buf = ALLOCV_N(partition_addr_pair_i8, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -6317,7 +6378,8 @@ partition_addr_ki_native_i8 (VALUE self, CArray *ca, int axis, ca_size_t kth, in
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -6414,18 +6476,19 @@ partition_addr_ki_native_u8 (VALUE self, CArray *ca, int axis, ca_size_t kth, in
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_u8 *buf =
-    xmalloc(sizeof(partition_addr_pair_u8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_u8 *buf = ALLOCV_N(partition_addr_pair_u8, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -6526,7 +6589,8 @@ partition_addr_ki_native_u8 (VALUE self, CArray *ca, int axis, ca_size_t kth, in
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -6623,18 +6687,19 @@ partition_addr_ki_native_i16 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_i16 *buf =
-    xmalloc(sizeof(partition_addr_pair_i16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_i16 *buf = ALLOCV_N(partition_addr_pair_i16, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -6735,7 +6800,8 @@ partition_addr_ki_native_i16 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -6832,18 +6898,19 @@ partition_addr_ki_native_u16 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_u16 *buf =
-    xmalloc(sizeof(partition_addr_pair_u16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_u16 *buf = ALLOCV_N(partition_addr_pair_u16, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -6944,7 +7011,8 @@ partition_addr_ki_native_u16 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -7041,18 +7109,19 @@ partition_addr_ki_native_i32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_i32 *buf =
-    xmalloc(sizeof(partition_addr_pair_i32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_i32 *buf = ALLOCV_N(partition_addr_pair_i32, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -7153,7 +7222,8 @@ partition_addr_ki_native_i32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -7250,18 +7320,19 @@ partition_addr_ki_native_u32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_u32 *buf =
-    xmalloc(sizeof(partition_addr_pair_u32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_u32 *buf = ALLOCV_N(partition_addr_pair_u32, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -7362,7 +7433,8 @@ partition_addr_ki_native_u32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -7459,18 +7531,19 @@ partition_addr_ki_native_i64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_i64 *buf =
-    xmalloc(sizeof(partition_addr_pair_i64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_i64 *buf = ALLOCV_N(partition_addr_pair_i64, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -7571,7 +7644,8 @@ partition_addr_ki_native_i64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -7668,18 +7742,19 @@ partition_addr_ki_native_u64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_u64 *buf =
-    xmalloc(sizeof(partition_addr_pair_u64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_u64 *buf = ALLOCV_N(partition_addr_pair_u64, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -7780,7 +7855,8 @@ partition_addr_ki_native_u64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -7796,12 +7872,8 @@ partition_addr_cmp_f32 (const void *a, const void *b)
 {
   const partition_addr_pair_f32 *pa = (const partition_addr_pair_f32 *) a;
   const partition_addr_pair_f32 *pb = (const partition_addr_pair_f32 *) b;
-  int nan_a = isnan(pa->v);
-  int nan_b = isnan(pb->v);
-  if ( nan_a && !nan_b ) return 1;
-  if ( nan_b && !nan_a ) return -1;
-  if ( pa->v > pb->v ) return 1;
-  if ( pa->v < pb->v ) return -1;
+  int c = CA_FLOAT_ORDER_CMP(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -7881,18 +7953,19 @@ partition_addr_ki_native_f32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_f32 *buf =
-    xmalloc(sizeof(partition_addr_pair_f32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_f32 *buf = ALLOCV_N(partition_addr_pair_f32, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -7993,7 +8066,8 @@ partition_addr_ki_native_f32 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -8009,12 +8083,8 @@ partition_addr_cmp_f64 (const void *a, const void *b)
 {
   const partition_addr_pair_f64 *pa = (const partition_addr_pair_f64 *) a;
   const partition_addr_pair_f64 *pb = (const partition_addr_pair_f64 *) b;
-  int nan_a = isnan(pa->v);
-  int nan_b = isnan(pb->v);
-  if ( nan_a && !nan_b ) return 1;
-  if ( nan_b && !nan_a ) return -1;
-  if ( pa->v > pb->v ) return 1;
-  if ( pa->v < pb->v ) return -1;
+  int c = CA_FLOAT_ORDER_CMP(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -8094,18 +8164,19 @@ partition_addr_ki_native_f64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_f64 *buf =
-    xmalloc(sizeof(partition_addr_pair_f64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_f64 *buf = ALLOCV_N(partition_addr_pair_f64, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -8206,7 +8277,8 @@ partition_addr_ki_native_f64 (VALUE self, CArray *ca, int axis, ca_size_t kth, i
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -8303,18 +8375,19 @@ partition_addr_ki_native_bool (VALUE self, CArray *ca, int axis, ca_size_t kth,
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_bool *buf =
-    xmalloc(sizeof(partition_addr_pair_bool) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_bool *buf = ALLOCV_N(partition_addr_pair_bool, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -8415,7 +8488,8 @@ partition_addr_ki_native_bool (VALUE self, CArray *ca, int axis, ca_size_t kth,
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -8431,14 +8505,8 @@ partition_addr_cmp_object (const void *a, const void *b)
 {
   const partition_addr_pair_object *pa = (const partition_addr_pair_object *) a;
   const partition_addr_pair_object *pb = (const partition_addr_pair_object *) b;
-  VALUE r = rb_funcall(pa->v, rb_intern("<=>"), 1, pb->v);
-  if ( NIL_P(r) ) {
-    rb_raise(rb_eArgError, "partition_addr_ki: comparison of %s with %s failed",
-             rb_obj_classname(pa->v), rb_obj_classname(pb->v));
-  }
-  int c = NUM2INT(r);
-  if ( c > 0 ) return 1;
-  if ( c < 0 ) return -1;
+  int c = ca_obj_order_cmp(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
@@ -8500,9 +8568,34 @@ partition_addr_quickselect_object (partition_addr_pair_object *arr,
   }
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+  ca_size_t kth;
+  int masked_last;
+} partition_addr_ki_native_object_frame;
+
 static VALUE
-partition_addr_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth, int masked_last)
-{
+partition_addr_ki_native_object_body (VALUE arg)
+{
+  partition_addr_ki_native_object_frame *fr = (partition_addr_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+  ca_size_t kth = fr->kth;
+  (void) kth;
+  int masked_last = fr->masked_last;
+  (void) masked_last;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_SIZE),
                                           INT2NUM(0));
   CArray *co;
@@ -8513,23 +8606,23 @@ partition_addr_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth
      positions align between iterators. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_object *buf =
-    xmalloc(sizeof(partition_addr_pair_object) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_object *buf = ALLOCV_N(partition_addr_pair_object, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -8630,12 +8723,28 @@ partition_addr_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+partition_addr_ki_native_object (VALUE self, CArray *ca, int axis, ca_size_t kth, int masked_last)
+{
+  partition_addr_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  fr.kth = kth;
+  fr.masked_last = masked_last;
+  return ca_iter_ensure(2, fr.states, partition_addr_ki_native_object_body, (VALUE) &fr);
+}
+
+
 typedef struct {
   char     *vp;   /* pointer to the fiber cell (nb bytes wide) */
   ca_size_t nb;   /* element byte width (= ca->bytes) */
@@ -8728,18 +8837,19 @@ partition_addr_ki_native_fixlen (VALUE self, CArray *ca, int axis, ca_size_t kth
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "partition_addr_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  partition_addr_pair_fixlen *buf =
-    xmalloc(sizeof(partition_addr_pair_fixlen) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  partition_addr_pair_fixlen *buf = ALLOCV_N(partition_addr_pair_fixlen, hbuf, fiber_n);
+  (void) haux;
 
   /* :view_flat semantics: kernel computes view-flat address
      (= row-major position in ca's shape, 0..elements-1) for
@@ -8840,7 +8950,8 @@ partition_addr_ki_native_fixlen (VALUE self, CArray *ca, int axis, ca_size_t kth
       cur_outer_idx[m] = 0;
     }
   }
-  xfree(buf);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -8851,60 +8962,47 @@ partition_addr_ki_dispatch (VALUE self, VALUE vaxis, VALUE vkth, int masked_last
 {
   CArray *src;
   GetCArray(self, src);
-  /* Face gate (partition): same as the sort dispatcher --
-     fixlen -> memcmp default, numeric -> ORDERABLE required. */
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  /* Face gate (partition): same as the sort dispatcher. */
   if ( ca_is_face(src) ) {
-    VALUE _face = self;
-    int _orderable = ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE);
-    VALUE _st = rb_ca_strip_face_value(self);
-    CArray *_sc;
-    GetCArray(_st, _sc);
-    if ( _sc->data_type != CA_FIXLEN && ! _orderable ) {
-      rb_raise(rb_eArgError,
-               "partition_addr_ki: Face-typed input (%s) is not orderable "
-               "by storage; use ca.parent to descend to storage",
-               rb_obj_classname(_face));
-    }
-    self = _st;
-    src = _sc;
-  }
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "partition_addr_ki: axis %d out of range for ndim %d", NUM2INT(vaxis), src->ndim);
-  }
-  ca_size_t kth = NUM2SIZE(vkth);
+    self = ca_order_key(self, ca_calling_method_name());
+    GetCArray(self, src);
+  }
+  int axis = ca_normalize_axis_arg(vaxis, src->ndim, NULL);
+  ca_size_t kth_raw = (ca_size_t) ca_integer_arg(vkth, "kth", NULL);
+  ca_size_t kth = kth_raw;
   ca_size_t axis_n = src->dim[axis];
   if ( kth < 0 ) kth += axis_n;
   if ( kth < 0 || kth >= axis_n ) {
-    rb_raise(rb_eArgError, "partition_addr_ki: kth %lld out of range for axis size %lld", (long long) NUM2SIZE(vkth), (long long) axis_n);
+    rb_raise(rb_eArgError, "%s: kth %lld out of range for length %lld", ca_calling_method_name(), (long long) kth_raw, (long long) axis_n);
   }
   switch ( src->data_type ) {
-    case CA_INT8: return partition_addr_ki_native_i8(self, src, axis, kth, masked_last);
-    case CA_UINT8: return partition_addr_ki_native_u8(self, src, axis, kth, masked_last);
-    case CA_INT16: return partition_addr_ki_native_i16(self, src, axis, kth, masked_last);
-    case CA_UINT16: return partition_addr_ki_native_u16(self, src, axis, kth, masked_last);
-    case CA_INT32: return partition_addr_ki_native_i32(self, src, axis, kth, masked_last);
-    case CA_UINT32: return partition_addr_ki_native_u32(self, src, axis, kth, masked_last);
-    case CA_INT64: return partition_addr_ki_native_i64(self, src, axis, kth, masked_last);
-    case CA_UINT64: return partition_addr_ki_native_u64(self, src, axis, kth, masked_last);
-    case CA_FLOAT32: return partition_addr_ki_native_f32(self, src, axis, kth, masked_last);
-    case CA_FLOAT64: return partition_addr_ki_native_f64(self, src, axis, kth, masked_last);
-    case CA_BOOLEAN: return partition_addr_ki_native_bool(self, src, axis, kth, masked_last);
-    case CA_OBJECT: return partition_addr_ki_native_object(self, src, axis, kth, masked_last);
-    case CA_FIXLEN: return partition_addr_ki_native_fixlen(self, src, axis, kth, masked_last);
+    case CA_INT8: CA_RETURN_KEEPING(self, partition_addr_ki_native_i8(self, src, axis, kth, masked_last));
+    case CA_UINT8: CA_RETURN_KEEPING(self, partition_addr_ki_native_u8(self, src, axis, kth, masked_last));
+    case CA_INT16: CA_RETURN_KEEPING(self, partition_addr_ki_native_i16(self, src, axis, kth, masked_last));
+    case CA_UINT16: CA_RETURN_KEEPING(self, partition_addr_ki_native_u16(self, src, axis, kth, masked_last));
+    case CA_INT32: CA_RETURN_KEEPING(self, partition_addr_ki_native_i32(self, src, axis, kth, masked_last));
+    case CA_UINT32: CA_RETURN_KEEPING(self, partition_addr_ki_native_u32(self, src, axis, kth, masked_last));
+    case CA_INT64: CA_RETURN_KEEPING(self, partition_addr_ki_native_i64(self, src, axis, kth, masked_last));
+    case CA_UINT64: CA_RETURN_KEEPING(self, partition_addr_ki_native_u64(self, src, axis, kth, masked_last));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, partition_addr_ki_native_f32(self, src, axis, kth, masked_last));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, partition_addr_ki_native_f64(self, src, axis, kth, masked_last));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, partition_addr_ki_native_bool(self, src, axis, kth, masked_last));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, partition_addr_ki_native_object(self, src, axis, kth, masked_last));
+    case CA_FIXLEN: CA_RETURN_KEEPING(self, partition_addr_ki_native_fixlen(self, src, axis, kth, masked_last));
     default:
-      rb_raise(rb_eCADataTypeError, "partition_addr_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object, fixlen)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object, fixlen)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
 
-VALUE
-rb_ca_partition_addr_ki (VALUE self, VALUE vaxis, VALUE vkth)
-{
-  return partition_addr_ki_dispatch(self, vaxis, vkth, 1);
-}
-
 VALUE
 rb_ca_partition_addr_ki_mp (VALUE self, VALUE vaxis, VALUE vkth, int masked_last)
 {
@@ -8941,21 +9039,21 @@ rank_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int de
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_i8 *buf =
-    xmalloc(sizeof(rank_index_pair_i8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_i8 *buf = ALLOCV_N(rank_index_pair_i8, hbuf, fiber_n);
   rank_index_pair_i8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_i8) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_i8, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -8997,8 +9095,9 @@ rank_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int de
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9010,14 +9109,25 @@ rank_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int de
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9025,8 +9135,8 @@ rank_index_ki_native_i8 (VALUE self, CArray *ca, int axis, int do_stable, int de
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9060,21 +9170,21 @@ rank_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int de
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_u8 *buf =
-    xmalloc(sizeof(rank_index_pair_u8) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_u8 *buf = ALLOCV_N(rank_index_pair_u8, hbuf, fiber_n);
   rank_index_pair_u8 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_u8) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_u8, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9116,8 +9226,9 @@ rank_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int de
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9129,14 +9240,25 @@ rank_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int de
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9144,8 +9266,8 @@ rank_index_ki_native_u8 (VALUE self, CArray *ca, int axis, int do_stable, int de
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9179,21 +9301,21 @@ rank_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_i16 *buf =
-    xmalloc(sizeof(rank_index_pair_i16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_i16 *buf = ALLOCV_N(rank_index_pair_i16, hbuf, fiber_n);
   rank_index_pair_i16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_i16) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_i16, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9235,8 +9357,9 @@ rank_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9248,14 +9371,25 @@ rank_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9263,8 +9397,8 @@ rank_index_ki_native_i16 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9298,21 +9432,21 @@ rank_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_u16 *buf =
-    xmalloc(sizeof(rank_index_pair_u16) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_u16 *buf = ALLOCV_N(rank_index_pair_u16, hbuf, fiber_n);
   rank_index_pair_u16 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_u16) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_u16, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9354,8 +9488,9 @@ rank_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9367,14 +9502,25 @@ rank_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9382,8 +9528,8 @@ rank_index_ki_native_u16 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9417,21 +9563,21 @@ rank_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_i32 *buf =
-    xmalloc(sizeof(rank_index_pair_i32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_i32 *buf = ALLOCV_N(rank_index_pair_i32, hbuf, fiber_n);
   rank_index_pair_i32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_i32) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_i32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9473,8 +9619,9 @@ rank_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9486,14 +9633,25 @@ rank_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9501,8 +9659,8 @@ rank_index_ki_native_i32 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9536,21 +9694,21 @@ rank_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_u32 *buf =
-    xmalloc(sizeof(rank_index_pair_u32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_u32 *buf = ALLOCV_N(rank_index_pair_u32, hbuf, fiber_n);
   rank_index_pair_u32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_u32) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_u32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9592,8 +9750,9 @@ rank_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9605,14 +9764,25 @@ rank_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9620,8 +9790,8 @@ rank_index_ki_native_u32 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9655,21 +9825,21 @@ rank_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_i64 *buf =
-    xmalloc(sizeof(rank_index_pair_i64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_i64 *buf = ALLOCV_N(rank_index_pair_i64, hbuf, fiber_n);
   rank_index_pair_i64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_i64) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_i64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9711,8 +9881,9 @@ rank_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9724,14 +9895,25 @@ rank_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9739,8 +9921,8 @@ rank_index_ki_native_i64 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9774,21 +9956,21 @@ rank_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_u64 *buf =
-    xmalloc(sizeof(rank_index_pair_u64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_u64 *buf = ALLOCV_N(rank_index_pair_u64, hbuf, fiber_n);
   rank_index_pair_u64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_u64) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_u64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9830,8 +10012,9 @@ rank_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -9843,14 +10026,25 @@ rank_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int d
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9858,8 +10052,8 @@ rank_index_ki_native_u64 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -9893,21 +10087,21 @@ rank_index_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_f32 *buf =
-    xmalloc(sizeof(rank_index_pair_f32) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_f32 *buf = ALLOCV_N(rank_index_pair_f32, hbuf, fiber_n);
   rank_index_pair_f32 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_f32) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_f32, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -9953,27 +10147,41 @@ rank_index_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
         if ( dense ) {
-          if ( buf[r].v != buf[r - 1].v ) out_r++;
+          if ( buf[r].v != buf[r - 1].v
+               && ! ( isnan(buf[r].v) && isnan(buf[r - 1].v) ) ) out_r++;
         } else {
           out_r = r;
         }
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      while ( nan_start > 0 && isnan(buf[nan_start - 1].v) ) nan_start--;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -9981,8 +10189,8 @@ rank_index_ki_native_f32 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -10016,21 +10224,21 @@ rank_index_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int d
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_f64 *buf =
-    xmalloc(sizeof(rank_index_pair_f64) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_f64 *buf = ALLOCV_N(rank_index_pair_f64, hbuf, fiber_n);
   rank_index_pair_f64 *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_f64) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_f64, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -10076,27 +10284,41 @@ rank_index_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int d
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
         if ( dense ) {
-          if ( buf[r].v != buf[r - 1].v ) out_r++;
+          if ( buf[r].v != buf[r - 1].v
+               && ! ( isnan(buf[r].v) && isnan(buf[r - 1].v) ) ) out_r++;
         } else {
           out_r = r;
         }
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      while ( nan_start > 0 && isnan(buf[nan_start - 1].v) ) nan_start--;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -10104,8 +10326,8 @@ rank_index_ki_native_f64 (VALUE self, CArray *ca, int axis, int do_stable, int d
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -10139,21 +10361,21 @@ rank_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_bool *buf =
-    xmalloc(sizeof(rank_index_pair_bool) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_bool *buf = ALLOCV_N(rank_index_pair_bool, hbuf, fiber_n);
   rank_index_pair_bool *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_bool) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_bool, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -10195,8 +10417,9 @@ rank_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -10208,14 +10431,25 @@ rank_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -10223,8 +10457,8 @@ rank_index_ki_native_bool (VALUE self, CArray *ca, int axis, int do_stable, int
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -10240,23 +10474,42 @@ rank_index_cmp_object (const void *a, const void *b)
 {
   const rank_index_pair_object *pa = (const rank_index_pair_object *) a;
   const rank_index_pair_object *pb = (const rank_index_pair_object *) b;
-  VALUE r = rb_funcall(pa->v, rb_intern("<=>"), 1, pb->v);
-  if ( NIL_P(r) ) {
-    rb_raise(rb_eArgError, "rank_index_ki: comparison of %s with %s failed",
-             rb_obj_classname(pa->v), rb_obj_classname(pb->v));
-  }
-  int c = NUM2INT(r);
-  if ( c > 0 ) return 1;
-  if ( c < 0 ) return -1;
+  int c = ca_obj_order_cmp(pa->v, pb->v);
+  if ( c != 0 ) return c;
   /* Stable tie-break by original fiber-local index. */
   if ( pa->i < pb->i ) return -1;
   if ( pa->i > pb->i ) return 1;
   return 0;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+  int do_stable;
+  int dense;
+} rank_index_ki_native_object_frame;
+
 static VALUE
-rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int dense)
-{
+rank_index_ki_native_object_body (VALUE arg)
+{
+  rank_index_ki_native_object_frame *fr = (rank_index_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+  int do_stable = fr->do_stable;
+  (void) do_stable;
+  int dense = fr->dense;
+  (void) dense;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_SIZE),
                                           INT2NUM(0));
   CArray *co;
@@ -10272,27 +10525,23 @@ rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
      next_slab_axes will then be non-NULL).  Created up-front
      when input has any mask. */
   if ( ca_has_mask(ca) ) ca_create_mask(co);
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_object *buf =
-    xmalloc(sizeof(rank_index_pair_object) * (size_t) fiber_n);
-  rank_index_pair_object *aux = NULL;
-  if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_object) * (size_t) fiber_n);
-  }
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_object *buf = ALLOCV_N(rank_index_pair_object, hbuf, fiber_n);
+  rank_index_pair_object *aux = ALLOCV_N(rank_index_pair_object, haux, fiber_n);
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -10317,8 +10566,8 @@ rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
        mergesort (= aux ping-pong, sorted-skip merge), do_stable: 0
        selects introsort with mergesort escape (= AC1 1.88x payoff).
      */
-    (void) do_stable;   /* CA_OBJECT: qsort handles both stable / quick */
-    qsort(buf, (size_t) k_unmasked, sizeof(rank_index_pair_object), rank_index_cmp_object);
+    (void) do_stable;   /* CA_OBJECT: one stable sort serves both kinds */
+    ca_sort_merge_pair_object((ca_pair_object *) buf, (ca_pair_object *) aux, (ca_size_t) k_unmasked, rank_index_cmp_object);
     /* Pre-clear output fiber to 0 (= sentinel at masked positions). */
     for ( ca_size_t k = 0; k < fiber_n; k++ ) {
       *(ca_size_t *) (po + k * ostride) = (ca_size_t) 0;
@@ -10330,27 +10579,41 @@ rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
         if ( dense ) {
-          if ( ! rb_equal(buf[r].v, buf[r - 1].v) ) out_r++;
+          if ( ! ( ( CA_OBJ_ISNAN(buf[r].v) && CA_OBJ_ISNAN(buf[r - 1].v) )
+                   || ca_obj_equal(buf[r].v, buf[r - 1].v) ) ) out_r++;
         } else {
           out_r = r;
         }
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      while ( nan_start > 0 && CA_OBJ_ISNAN(buf[nan_start - 1].v) ) nan_start--;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -10358,13 +10621,28 @@ rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, in
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+rank_index_ki_native_object (VALUE self, CArray *ca, int axis, int do_stable, int dense)
+{
+  rank_index_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  fr.do_stable = do_stable;
+  fr.dense = dense;
+  return ca_iter_ensure(2, fr.states, rank_index_ki_native_object_body, (VALUE) &fr);
+}
+
+
 typedef struct {
   char     *vp;   /* pointer to the fiber cell (nb bytes wide) */
   ca_size_t nb;   /* element byte width (= ca->bytes) */
@@ -10407,21 +10685,21 @@ rank_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "rank_index_ki: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "rank_index_ki: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   ca_size_t fiber_n = st_in.slab_elements;
-  rank_index_pair_fixlen *buf =
-    xmalloc(sizeof(rank_index_pair_fixlen) * (size_t) fiber_n);
+  volatile VALUE hbuf = 0, haux = 0;
+  rank_index_pair_fixlen *buf = ALLOCV_N(rank_index_pair_fixlen, hbuf, fiber_n);
   rank_index_pair_fixlen *aux = NULL;
   if ( do_stable ) {
-    aux = xmalloc(sizeof(rank_index_pair_fixlen) * (size_t) fiber_n);
+    aux = ALLOCV_N(rank_index_pair_fixlen, haux, fiber_n);
   }
 
   char       *pi, *po;
@@ -10464,8 +10742,9 @@ rank_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
        gaps ordinal would have spent on the tie are never used, so a
        later out_r stays <= the ordinal r at that position, preserving
        both the ascending order and (via the order() method's
-       (n-1)-out_r descending transform) the descending order.  NaN
-       cells never tie with each other under dense (IEEE754 x != x). */
+       descending transform) the descending order.  NaN cells tie
+       with each other, as sort_addr and the value-hash family treat
+       every NaN as one value. */
     ca_size_t out_r = 0;
     for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
       if ( r > 0 ) {
@@ -10477,14 +10756,25 @@ rank_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
       }
       *(ca_size_t *) (po + buf[r].i * ostride) = (ca_size_t) out_r;
     }
+    if ( dense == 2 && k_unmasked > 0 ) {
+      ca_size_t nan_start = k_unmasked;
+      ca_size_t top = nan_start > 0
+        ? *(ca_size_t *) (po + buf[nan_start - 1].i * ostride) : (ca_size_t) -1;
+      for ( ca_size_t r = 0; r < k_unmasked; r++ ) {
+        ca_size_t *o = (ca_size_t *) (po + buf[r].i * ostride);
+        *o = ( r < nan_start ) ? top - *o : top + 1;
+      }
+    }
     /* Mirror input mask to output (= UNDEF rank for masked
-       cells).  Write via co->mask->ptr directly with the
-       output slab offset, because the iter's mo isn't
-       populated in CA_KERNEL_WRITE mode (= reduce form's
-       op_mask pattern). */
+       cells).  Write via co->mask->ptr directly, because a
+       mask written through a WRITE walk's cursor does not
+       reach the array.  co is a fresh row-major entity and
+       the walk cuts its slabs from a buffer laid out the
+       same way, so the slab's offset from st_out.alias_ptr
+       is its offset in co. */
     if ( mi && co->mask ) {
       boolean8_t *omask_base = (boolean8_t *) co->mask->ptr
-                              + ((po - (char *) co->ptr) / (ca_size_t) co->bytes);
+                              + ((po - st_out.alias_ptr) / (ca_size_t) co->bytes);
       ca_size_t mostride = st_out.slab_mask_strides[0];
       for ( ca_size_t k = 0; k < fiber_n; k++ ) {
         if ( mi[k * mstride] ) omask_base[k * mostride] = 1;
@@ -10492,8 +10782,8 @@ rank_index_ki_native_fixlen (VALUE self, CArray *ca, int axis, int do_stable, in
     }
     ca_iter_state_sync_slab(&st_out);
   }
-  xfree(buf);
-  if ( aux ) xfree(aux);
+  ALLOCV_END(hbuf);
+  ALLOCV_END(haux);
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
@@ -10504,46 +10794,39 @@ rank_index_ki_dispatch (VALUE self, VALUE vaxis, int do_stable, int dense)
 {
   CArray *src;
   GetCArray(self, src);
-  /* Face gate: descend to storage (fixlen -> memcmp default,
-     numeric -> ORDERABLE required).  The strip also makes the
-     switch below and every index/addr template output build on
-     the plain storage, not a face-lifted (NULL-ptr) view. */
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  /* Face gate: run on the array the Face's order is read from.
+     It is never a Face, so the switch below and every index/addr
+     template output build on a plain array, not a face-lifted
+     (NULL-ptr) view. */
   if ( ca_is_face(src) ) {
-    VALUE _face = self;
-    int _orderable = ca_test_flag(src, CA_FLAG_FACE_ORDERABLE_STORAGE);
-    VALUE _st = rb_ca_strip_face_value(self);
-    CArray *_sc;
-    GetCArray(_st, _sc);
-    if ( _sc->data_type != CA_FIXLEN && ! _orderable ) {
-      rb_raise(rb_eArgError,
-               "rank_index_ki: Face-typed input (%s) is not orderable "
-               "by storage; use ca.parent to descend to storage",
-               rb_obj_classname(_face));
-    }
-    self = _st;
-    src = _sc;
-  }
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "rank_index_ki: axis %d out of range for ndim %d", NUM2INT(vaxis), src->ndim);
+    self = ca_order_key(self, ca_calling_method_name());
+    GetCArray(self, src);
   }
+  int axis = ca_normalize_axis_arg(vaxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return rank_index_ki_native_i8(self, src, axis, do_stable, dense);
-    case CA_UINT8: return rank_index_ki_native_u8(self, src, axis, do_stable, dense);
-    case CA_INT16: return rank_index_ki_native_i16(self, src, axis, do_stable, dense);
-    case CA_UINT16: return rank_index_ki_native_u16(self, src, axis, do_stable, dense);
-    case CA_INT32: return rank_index_ki_native_i32(self, src, axis, do_stable, dense);
-    case CA_UINT32: return rank_index_ki_native_u32(self, src, axis, do_stable, dense);
-    case CA_INT64: return rank_index_ki_native_i64(self, src, axis, do_stable, dense);
-    case CA_UINT64: return rank_index_ki_native_u64(self, src, axis, do_stable, dense);
-    case CA_FLOAT32: return rank_index_ki_native_f32(self, src, axis, do_stable, dense);
-    case CA_FLOAT64: return rank_index_ki_native_f64(self, src, axis, do_stable, dense);
-    case CA_BOOLEAN: return rank_index_ki_native_bool(self, src, axis, do_stable, dense);
-    case CA_OBJECT: return rank_index_ki_native_object(self, src, axis, do_stable, dense);
-    case CA_FIXLEN: return rank_index_ki_native_fixlen(self, src, axis, do_stable, dense);
+    case CA_INT8: CA_RETURN_KEEPING(self, rank_index_ki_native_i8(self, src, axis, do_stable, dense));
+    case CA_UINT8: CA_RETURN_KEEPING(self, rank_index_ki_native_u8(self, src, axis, do_stable, dense));
+    case CA_INT16: CA_RETURN_KEEPING(self, rank_index_ki_native_i16(self, src, axis, do_stable, dense));
+    case CA_UINT16: CA_RETURN_KEEPING(self, rank_index_ki_native_u16(self, src, axis, do_stable, dense));
+    case CA_INT32: CA_RETURN_KEEPING(self, rank_index_ki_native_i32(self, src, axis, do_stable, dense));
+    case CA_UINT32: CA_RETURN_KEEPING(self, rank_index_ki_native_u32(self, src, axis, do_stable, dense));
+    case CA_INT64: CA_RETURN_KEEPING(self, rank_index_ki_native_i64(self, src, axis, do_stable, dense));
+    case CA_UINT64: CA_RETURN_KEEPING(self, rank_index_ki_native_u64(self, src, axis, do_stable, dense));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, rank_index_ki_native_f32(self, src, axis, do_stable, dense));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, rank_index_ki_native_f64(self, src, axis, do_stable, dense));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, rank_index_ki_native_bool(self, src, axis, do_stable, dense));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, rank_index_ki_native_object(self, src, axis, do_stable, dense));
+    case CA_FIXLEN: CA_RETURN_KEEPING(self, rank_index_ki_native_fixlen(self, src, axis, do_stable, dense));
     default:
-      rb_raise(rb_eCADataTypeError, "rank_index_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object, fixlen)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object, fixlen)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -10567,9 +10850,9 @@ rb_ca_rank_index_ki (VALUE self, VALUE vaxis)
 }
 
 VALUE
-rb_ca_rank_index_ki_quick_dense (VALUE self, VALUE vaxis, int dense)
+rb_ca_rank_index_ki_kind_dense (VALUE self, VALUE vaxis, int stable, int dense)
 {
-  return rank_index_ki_dispatch(self, vaxis, 0, dense);
+  return rank_index_ki_dispatch(self, vaxis, stable, dense);
 }
 
 static VALUE
@@ -10580,35 +10863,32 @@ rb_ca_rank_index_kw (int argc, VALUE *argv, VALUE self)
   volatile VALUE rkind = Qnil;
   volatile VALUE rmethod = Qnil;
   rb_scan_options(ropt, "axis,kind,method", &raxis, &rkind, &rmethod);
-  if ( NIL_P(raxis) ) raxis = INT2NUM(0);   /* default axis */
-  int dense = 0;   /* default method: :ordinal */
-  if ( ! NIL_P(rmethod) ) {
-    static ID sym_ordinal = 0, sym_dense = 0;
-    if ( ! sym_ordinal ) sym_ordinal = rb_intern("ordinal");
-    if ( ! sym_dense )   sym_dense   = rb_intern("dense");
-    ID method_id = SYM2ID(rmethod);
-    if      ( method_id == sym_ordinal ) dense = 0;
-    else if ( method_id == sym_dense )   dense = 1;
-    else {
-      rb_raise(rb_eArgError, "rank_index: unknown method %s (expected :ordinal or :dense)", rb_id2name(method_id));
+  volatile VALUE whole_src = Qnil;
+  if ( NIL_P(raxis) ) {   /* no axis: the whole array */
+    whole_src = self;
+    {
+      volatile VALUE evaluated = ca_lazy_evaluated(self);
+      if ( ! NIL_P(evaluated) ) self = evaluated;
     }
+    self  = rb_ca_flatten(self);
+    raxis = INT2NUM(0);
   }
+  int dense = NIL_P(rmethod) ? 0 : ca_symbol_choice(rmethod, "method", "ordinal", "dense", NULL);
   if ( argc != 0 ) {
     rb_raise(rb_eArgError, "rank_index: positional args no longer accepted (given %d args); use axis:/kind: kwargs", argc);
   }
-  int do_stable = 0;
-  if ( ! NIL_P(rkind) ) {
-    static ID sym_quick = 0, sym_stable = 0;
-    if ( ! sym_quick )  sym_quick  = rb_intern("quick");
-    if ( ! sym_stable ) sym_stable = rb_intern("stable");
-    ID kind_id = SYM2ID(rkind);
-    if      ( kind_id == sym_quick )  do_stable = 0;
-    else if ( kind_id == sym_stable ) do_stable = 1;
-    else {
-      rb_raise(rb_eArgError, "rank_index: unknown kind %s (expected :quick or :stable)", rb_id2name(kind_id));
+  int do_stable = NIL_P(rkind) ? 0 : ca_symbol_choice(rkind, "kind", "quick", "stable", NULL);
+  VALUE out = rank_index_ki_dispatch(self, raxis, do_stable, dense);
+  if ( ! NIL_P(whole_src) ) {
+    CArray *src;
+    VALUE shape_argv[CA_RANK_MAX];
+    GetCArray(whole_src, src);
+    for ( int k = 0; k < src->ndim; k++ ) {
+      shape_argv[k] = SIZE2NUM(src->dim[k]);
     }
+    out = rb_ca_reshape((int) src->ndim, shape_argv, out);
   }
-  return rank_index_ki_dispatch(self, raxis, do_stable, dense);
+  return out;
 }
 
 void