carray 3.0.0 → 3.0.2

data/ext/carray_call_cfunc.c

@@ -25,6 +25,18 @@
  *  operand invariant established in PROPOSAL_EAGER_ELEMENTWISE_NO_ATTACH
  *  and extended in PROPOSAL_EAGER_SLOWPATH_CHUNKING_ARENA).
  *
+ *  Slab variants `ca_call_cslab_N` / `ca_call_cslab_N_r` take the chunked
+ *  path instead (ca_sweep_acquire_chunked / ca_sweep_next_chunk /
+ *  ca_sweep_release_chunked) and hand the callback a whole chunk -- base /
+ *  stride per operand, a cell count, and the chunk's slice of the mask --
+ *  rather than one cell.  A non-alias INPUT is then re-gathered into a
+ *  ~32KB arena scratch per chunk rather than materialised whole, so input
+ *  memory peak stops scaling with the operand; and the indirect call is
+ *  paid once per chunk, so the author's inner loop is one the compiler can
+ *  vectorise.  Use cfunc when the per-cell body is what you have (a math
+ *  function to wrap); use cslab when the operand is large, virtual, or the
+ *  body is worth vectorising.
+ *
  *  L0.1 (PROPOSAL_L0_AUTHOR_SURFACE, 2026-06-11): the per-operand acquire
  *  + broadcast check + mask OR + release lifecycle is now factored out
  *  into ext/ca_sweep_engine.{c,h} (ca_sweep_acquire / ca_sweep_release).  This
@@ -36,6 +48,80 @@
 #include "ca_sweep_engine.h"
 #include <string.h>
 
+/* Chunk walk for the ca_call_cslab_N family, run by ca_sweep_run_chunked
+   so that a callback raising part way through gives back what the engine
+   holds.  Hands the author one chunk at a time.  base[] is rewritten per
+   chunk by ca_sweep_next_chunk -- for a non-alias INPUT it points at the
+   arena scratch the chunk was just gathered into, which is packed, so
+   stride[] is the element size and the author's inner loop sees
+   contiguous data.  m0 is the chunk's iteration mask, or NULL when no
+   INPUT operand carried one: chunk-sized and re-gathered per chunk, so it
+   is already the slice -- one byte per cell, indexed 0..chunk_n-1
+   alongside base[] and stride[].  The arity does not appear here: the
+   operands reach the callback through base[] / stride[]. */
+typedef struct {
+  ca_sweep_state_t *st;
+  ca_cslab_t        func;      /* ca_call_cslab_N   */
+  ca_cslab_r_t      func_r;    /* ca_call_cslab_N_r */
+  void             *userdata;
+} ca_cslab_ctx_t;
+
+static VALUE
+ca_cslab_walk (VALUE arg)
+{
+  ca_cslab_ctx_t *c = (ca_cslab_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  while ( ca_sweep_next_chunk(st) ) {
+    c->func(st->base, st->stride, st->chunk_n, st->m0);
+  }
+  return Qnil;
+}
+
+static VALUE
+ca_cslab_r_walk (VALUE arg)
+{
+  ca_cslab_ctx_t *c = (ca_cslab_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  while ( ca_sweep_next_chunk(st) ) {
+    c->func_r(st->base, st->stride, st->chunk_n, st->m0, c->userdata);
+  }
+  return Qnil;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0);
+  void *userdata;
+} ca_call_cfunc_1_ctx_t;
+
+static VALUE
+ca_call_cfunc_1_walk (VALUE arg)
+{
+  ca_call_cfunc_1_ctx_t *c = (ca_call_cfunc_1_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[1];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 1; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
+        }
+        c->func(p[0]);
+      }
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 1; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
+      }
+      c->func(p[0]);
+    }
+  }
+  return Qnil;
+}
+
 VALUE
 ca_call_cfunc_1 (void (*func)(void *p0), const char *fsync,
                             VALUE rcx0)
@@ -46,13 +132,13 @@ ca_call_cfunc_1 (void (*func)(void *p0), const char *fsync,
   char     *owned_buf[1];
   int       attached[1];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_1_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 1;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -65,32 +151,46 @@ ca_call_cfunc_1 (void (*func)(void *p0), const char *fsync,
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[1];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 1; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_1_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1);
+  void *userdata;
+} ca_call_cfunc_2_ctx_t;
+
+static VALUE
+ca_call_cfunc_2_walk (VALUE arg)
+{
+  ca_call_cfunc_2_ctx_t *c = (ca_call_cfunc_2_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[2];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 2; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 1; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 2; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -103,14 +203,14 @@ ca_call_cfunc_2 (void (*func)(void *p0, void *p1), const char *fsync,
   char     *owned_buf[2];
   int       attached[2];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_2_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 2;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -123,32 +223,46 @@ ca_call_cfunc_2 (void (*func)(void *p0, void *p1), const char *fsync,
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[2];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 2; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_2_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2);
+  void *userdata;
+} ca_call_cfunc_3_ctx_t;
+
+static VALUE
+ca_call_cfunc_3_walk (VALUE arg)
+{
+  ca_call_cfunc_3_ctx_t *c = (ca_call_cfunc_3_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[3];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 3; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 2; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 3; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -161,15 +275,15 @@ ca_call_cfunc_3 (void (*func)(void *p0, void *p1, void *p2), const char *fsync,
   char     *owned_buf[3];
   int       attached[3];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_3_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
   TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 3;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -182,32 +296,46 @@ ca_call_cfunc_3 (void (*func)(void *p0, void *p1, void *p2), const char *fsync,
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[3];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 3; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_3_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3);
+  void *userdata;
+} ca_call_cfunc_4_ctx_t;
+
+static VALUE
+ca_call_cfunc_4_walk (VALUE arg)
+{
+  ca_call_cfunc_4_ctx_t *c = (ca_call_cfunc_4_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[4];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 4; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 3; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 4; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -220,7 +348,7 @@ ca_call_cfunc_4 (void (*func)(void *p0, void *p1, void *p2, void *p3), const cha
   char     *owned_buf[4];
   int       attached[4];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_4_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -228,8 +356,8 @@ ca_call_cfunc_4 (void (*func)(void *p0, void *p1, void *p2, void *p3), const cha
   TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 4;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -242,32 +370,46 @@ ca_call_cfunc_4 (void (*func)(void *p0, void *p1, void *p2, void *p3), const cha
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[4];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 4; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_4_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4);
+  void *userdata;
+} ca_call_cfunc_5_ctx_t;
+
+static VALUE
+ca_call_cfunc_5_walk (VALUE arg)
+{
+  ca_call_cfunc_5_ctx_t *c = (ca_call_cfunc_5_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[5];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 5; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 4; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 5; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -280,7 +422,7 @@ ca_call_cfunc_5 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4),
   char     *owned_buf[5];
   int       attached[5];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_5_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -289,8 +431,8 @@ ca_call_cfunc_5 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4),
   TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 5;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -303,32 +445,46 @@ ca_call_cfunc_5 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4),
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[5];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 5; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_5_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4, void *p5);
+  void *userdata;
+} ca_call_cfunc_6_ctx_t;
+
+static VALUE
+ca_call_cfunc_6_walk (VALUE arg)
+{
+  ca_call_cfunc_6_ctx_t *c = (ca_call_cfunc_6_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[6];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 6; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4], p[5]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 5; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 6; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4], p[5]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -341,7 +497,7 @@ ca_call_cfunc_6 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
   char     *owned_buf[6];
   int       attached[6];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_6_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -351,8 +507,8 @@ ca_call_cfunc_6 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
   TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 6;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -365,32 +521,46 @@ ca_call_cfunc_6 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[6];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 6; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4], p[5]);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_6_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4, void *p5, void *p6);
+  void *userdata;
+} ca_call_cfunc_7_ctx_t;
+
+static VALUE
+ca_call_cfunc_7_walk (VALUE arg)
+{
+  ca_call_cfunc_7_ctx_t *c = (ca_call_cfunc_7_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[7];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 7; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 6; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4], p[5]);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 7; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -403,7 +573,7 @@ ca_call_cfunc_7 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
   char     *owned_buf[7];
   int       attached[7];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_7_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -414,8 +584,8 @@ ca_call_cfunc_7 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
   TypedData_Get_Struct(rcx6, CArray, &carray_data_type, cx[6]);
 
   /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
-     broadcast shape check, mask OR across INPUTs, mask propagate to
-     OUTPUTs.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 7;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -428,30 +598,10 @@ ca_call_cfunc_7 (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4,
 
   ca_sweep_acquire(&state);
 
-  /* inner loop: advance per-cell ptrs and invoke user kernel func */
-  {
-    char *p[7];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 7; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
-        }
-      }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 7; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
-      }
-    }
-  }
-
-  ca_sweep_release(&state);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = NULL;
+  ca_sweep_run(&state, ca_call_cfunc_7_walk, (VALUE) &ctx);
 
   return rcx0;
 }
@@ -845,6 +995,40 @@ ca_call_cfunc_3_3 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dt
 /* `void *userdata` parameter forwarded to every per-cell invocation. */
 /* -------------------------------------------------------------------- */
 
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *userdata);
+  void *userdata;
+} ca_call_cfunc_1_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_1_r_walk (VALUE arg)
+{
+  ca_call_cfunc_1_r_ctx_t *c = (ca_call_cfunc_1_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[1];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 1; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
+        }
+        c->func(p[0], c->userdata);
+      }
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 1; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
+      }
+      c->func(p[0], c->userdata);
+    }
+  }
+  return Qnil;
+}
+
 VALUE
 ca_call_cfunc_1_r (void (*func)(void *p0, void *userdata), const char *fsync,
                               VALUE rcx0,
@@ -856,12 +1040,13 @@ ca_call_cfunc_1_r (void (*func)(void *p0, void *userdata), const char *fsync,
   char     *owned_buf[1];
   int       attached[1];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_1_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_1; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 1;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -874,31 +1059,46 @@ ca_call_cfunc_1_r (void (*func)(void *p0, void *userdata), const char *fsync,
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[1];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 1; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_1_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *userdata);
+  void *userdata;
+} ca_call_cfunc_2_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_2_r_walk (VALUE arg)
+{
+  ca_call_cfunc_2_r_ctx_t *c = (ca_call_cfunc_2_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[2];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 2; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 1; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 2; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -912,13 +1112,14 @@ ca_call_cfunc_2_r (void (*func)(void *p0, void *p1, void *userdata), const char
   char     *owned_buf[2];
   int       attached[2];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_2_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_2; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 2;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -931,31 +1132,46 @@ ca_call_cfunc_2_r (void (*func)(void *p0, void *p1, void *userdata), const char
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[2];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 2; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_2_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *userdata);
+  void *userdata;
+} ca_call_cfunc_3_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_3_r_walk (VALUE arg)
+{
+  ca_call_cfunc_3_r_ctx_t *c = (ca_call_cfunc_3_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[3];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 3; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 2; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 3; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -969,14 +1185,15 @@ ca_call_cfunc_3_r (void (*func)(void *p0, void *p1, void *p2, void *userdata), c
   char     *owned_buf[3];
   int       attached[3];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_3_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
   TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_3; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 3;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -989,31 +1206,46 @@ ca_call_cfunc_3_r (void (*func)(void *p0, void *p1, void *p2, void *userdata), c
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[3];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 3; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_3_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *userdata);
+  void *userdata;
+} ca_call_cfunc_4_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_4_r_walk (VALUE arg)
+{
+  ca_call_cfunc_4_r_ctx_t *c = (ca_call_cfunc_4_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[4];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 4; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 3; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 4; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -1027,15 +1259,16 @@ ca_call_cfunc_4_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *us
   char     *owned_buf[4];
   int       attached[4];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_4_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
   TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
   TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_4; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 4;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -1048,31 +1281,46 @@ ca_call_cfunc_4_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *us
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[4];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 4; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_4_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4, void *userdata);
+  void *userdata;
+} ca_call_cfunc_5_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_5_r_walk (VALUE arg)
+{
+  ca_call_cfunc_5_r_ctx_t *c = (ca_call_cfunc_5_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[5];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 5; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 4; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 5; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -1086,7 +1334,7 @@ ca_call_cfunc_5_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   char     *owned_buf[5];
   int       attached[5];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_5_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -1094,8 +1342,9 @@ ca_call_cfunc_5_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
   TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_5; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 5;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -1108,31 +1357,46 @@ ca_call_cfunc_5_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[5];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 5; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_5_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4, void *p5, void *userdata);
+  void *userdata;
+} ca_call_cfunc_6_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_6_r_walk (VALUE arg)
+{
+  ca_call_cfunc_6_r_ctx_t *c = (ca_call_cfunc_6_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[6];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 6; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4], p[5], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 5; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 6; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4], p[5], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -1146,7 +1410,7 @@ ca_call_cfunc_6_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   char     *owned_buf[6];
   int       attached[6];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_6_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -1155,8 +1419,9 @@ ca_call_cfunc_6_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
   TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_6; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 6;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -1169,31 +1434,46 @@ ca_call_cfunc_6_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[6];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 6; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4], p[5], userdata);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_6_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+typedef struct {
+  ca_sweep_state_t *st;
+  void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4, void *p5, void *p6, void *userdata);
+  void *userdata;
+} ca_call_cfunc_7_r_ctx_t;
+
+static VALUE
+ca_call_cfunc_7_r_walk (VALUE arg)
+{
+  ca_call_cfunc_7_r_ctx_t *c = (ca_call_cfunc_7_r_ctx_t *) arg;
+  ca_sweep_state_t *st = c->st;
+  char *p[7];
+  ca_size_t k;
+  int k_op;
+  if ( st->m0 ) {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      if ( ! st->m0[k] ) {
+        for ( k_op = 0; k_op < 7; k_op++ ) {
+          p[k_op] = st->base[k_op] + k * st->stride[k_op];
         }
+        c->func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], c->userdata);
       }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 6; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4], p[5], userdata);
+    }
+  } else {
+    for ( k = 0; k < st->n_kernel; k++ ) {
+      for ( k_op = 0; k_op < 7; k_op++ ) {
+        p[k_op] = st->base[k_op] + k * st->stride[k_op];
       }
+      c->func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], c->userdata);
     }
   }
-
-  ca_sweep_release(&state);
-
-  return rcx0;
+  return Qnil;
 }
 
 VALUE
@@ -1207,7 +1487,7 @@ ca_call_cfunc_7_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   char     *owned_buf[7];
   int       attached[7];
   ca_sweep_state_t state;
-  int k_op;
+  ca_call_cfunc_7_r_ctx_t ctx;
 
   TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
   TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
@@ -1217,8 +1497,9 @@ ca_call_cfunc_7_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
   TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
   TypedData_Get_Struct(rcx6, CArray, &carray_data_type, cx[6]);
 
-  /* sweep engine: same lifecycle as ca_call_cfunc_7; the difference is
-     the per-cell `func(...)` call has `userdata` as its last argument. */
+  /* sweep engine: per-operand acquire (alias / xmalloc + ca_xfer_all),
+     operand pairing, mask OR across INPUTs, mask propagate to OUTPUTs.
+     Lifecycle template lives in ext/ca_sweep_engine.{c,h}. */
   state.n_ops     = 7;
   state.fsync     = fsync;
   state.cx        = cx;
@@ -1231,29 +1512,10 @@ ca_call_cfunc_7_r (void (*func)(void *p0, void *p1, void *p2, void *p3, void *p4
 
   ca_sweep_acquire(&state);
 
-  {
-    char *p[7];
-    ca_size_t k;
-    if ( state.m0 ) {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        if ( ! state.m0[k] ) {
-          for ( k_op = 0; k_op < 7; k_op++ ) {
-            p[k_op] = base[k_op] + k * stride[k_op];
-          }
-          func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], userdata);
-        }
-      }
-    } else {
-      for ( k = 0; k < state.n_kernel; k++ ) {
-        for ( k_op = 0; k_op < 7; k_op++ ) {
-          p[k_op] = base[k_op] + k * stride[k_op];
-        }
-        func(p[0], p[1], p[2], p[3], p[4], p[5], p[6], userdata);
-      }
-    }
-  }
-
-  ca_sweep_release(&state);
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.userdata = userdata;
+  ca_sweep_run(&state, ca_call_cfunc_7_r_walk, (VALUE) &ctx);
 
   return rcx0;
 }
@@ -1635,3 +1897,1416 @@ ca_call_cfunc_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t
   return rb_ary_new3(3, ry1, ry2, ry3);
 }
 
+/* -------------------------------------------------------------------- */
+/* Slab variants: the chunked counterpart of ca_call_cfunc_N.  The    */
+/* callback is handed a whole chunk (base / stride / count / mask     */
+/* slice) rather than one cell, and non-alias INPUTs are gathered     */
+/* into a ~32KB arena scratch per chunk instead of materialised       */
+/* whole, so input memory peak stops scaling with the operand.        */
+/* -------------------------------------------------------------------- */
+
+VALUE
+ca_call_cslab_1 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0)
+{
+  CArray   *cx[1];
+  char     *base[1];
+  char     *base_orig[1];
+  ca_size_t stride[1];
+  char     *owned_buf[1];
+  int       attached[1];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 1;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_1";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_2 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1)
+{
+  CArray   *cx[2];
+  char     *base[2];
+  char     *base_orig[2];
+  ca_size_t stride[2];
+  char     *owned_buf[2];
+  int       attached[2];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 2;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_2";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_3 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2)
+{
+  CArray   *cx[3];
+  char     *base[3];
+  char     *base_orig[3];
+  ca_size_t stride[3];
+  char     *owned_buf[3];
+  int       attached[3];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 3;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_3";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_4 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3)
+{
+  CArray   *cx[4];
+  char     *base[4];
+  char     *base_orig[4];
+  ca_size_t stride[4];
+  char     *owned_buf[4];
+  int       attached[4];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 4;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_4";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_5 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4)
+{
+  CArray   *cx[5];
+  char     *base[5];
+  char     *base_orig[5];
+  ca_size_t stride[5];
+  char     *owned_buf[5];
+  int       attached[5];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 5;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_5";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_6 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5)
+{
+  CArray   *cx[6];
+  char     *base[6];
+  char     *base_orig[6];
+  ca_size_t stride[6];
+  char     *owned_buf[6];
+  int       attached[6];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+  TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 6;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_6";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_7 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6)
+{
+  CArray   *cx[7];
+  char     *base[7];
+  char     *base_orig[7];
+  ca_size_t stride[7];
+  char     *owned_buf[7];
+  int       attached[7];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+  TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
+  TypedData_Get_Struct(rcx6, CArray, &carray_data_type, cx[6]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 7;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_7";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = func;
+  ctx.func_r   = NULL;
+  ctx.userdata = NULL;
+  ca_sweep_run_chunked(&state, ca_cslab_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_1_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0,
+                               void *userdata)
+{
+  CArray   *cx[1];
+  char     *base[1];
+  char     *base_orig[1];
+  ca_size_t stride[1];
+  char     *owned_buf[1];
+  int       attached[1];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 1;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_1_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_2_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1,
+                               void *userdata)
+{
+  CArray   *cx[2];
+  char     *base[2];
+  char     *base_orig[2];
+  ca_size_t stride[2];
+  char     *owned_buf[2];
+  int       attached[2];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 2;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_2_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_3_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2,
+                               void *userdata)
+{
+  CArray   *cx[3];
+  char     *base[3];
+  char     *base_orig[3];
+  ca_size_t stride[3];
+  char     *owned_buf[3];
+  int       attached[3];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 3;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_3_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_4_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3,
+                               void *userdata)
+{
+  CArray   *cx[4];
+  char     *base[4];
+  char     *base_orig[4];
+  ca_size_t stride[4];
+  char     *owned_buf[4];
+  int       attached[4];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 4;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_4_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_5_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4,
+                               void *userdata)
+{
+  CArray   *cx[5];
+  char     *base[5];
+  char     *base_orig[5];
+  ca_size_t stride[5];
+  char     *owned_buf[5];
+  int       attached[5];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 5;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_5_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_6_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5,
+                               void *userdata)
+{
+  CArray   *cx[6];
+  char     *base[6];
+  char     *base_orig[6];
+  ca_size_t stride[6];
+  char     *owned_buf[6];
+  int       attached[6];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+  TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 6;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_6_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_7_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6,
+                               void *userdata)
+{
+  CArray   *cx[7];
+  char     *base[7];
+  char     *base_orig[7];
+  ca_size_t stride[7];
+  char     *owned_buf[7];
+  int       attached[7];
+  ca_sweep_state_t state;
+  ca_cslab_ctx_t ctx;
+
+  TypedData_Get_Struct(rcx0, CArray, &carray_data_type, cx[0]);
+  TypedData_Get_Struct(rcx1, CArray, &carray_data_type, cx[1]);
+  TypedData_Get_Struct(rcx2, CArray, &carray_data_type, cx[2]);
+  TypedData_Get_Struct(rcx3, CArray, &carray_data_type, cx[3]);
+  TypedData_Get_Struct(rcx4, CArray, &carray_data_type, cx[4]);
+  TypedData_Get_Struct(rcx5, CArray, &carray_data_type, cx[5]);
+  TypedData_Get_Struct(rcx6, CArray, &carray_data_type, cx[6]);
+
+  /* sweep engine, chunked path: per-operand acquire (attach for OUTPUT
+     and alias INPUT, arena chunk scratch for non-alias INPUT), broadcast
+     shape check, mask OR across INPUTs, mask propagate to OUTPUTs at
+     release.  Lifecycle template lives in ext/ca_sweep_engine.{c,h}.
+     base_orig is the field the whole-buffer path leaves zero; the
+     chunked path walks it, so it has to be given here. */
+  state.n_ops     = 7;
+  state.fsync     = fsync;
+  state.cx        = cx;
+  state.base      = base;
+  state.base_orig = base_orig;
+  state.stride    = stride;
+  state.owned_buf = owned_buf;
+  state.attached  = attached;
+  state.no_mask   = 0;
+  state.src_label = "ca_call_cslab_7_r";
+
+  ca_sweep_acquire_chunked(&state);
+
+  ctx.st       = &state;
+  ctx.func     = NULL;
+  ctx.func_r   = func;
+  ctx.userdata = userdata;
+  ca_sweep_run_chunked(&state, ca_cslab_r_walk, (VALUE) &ctx);
+
+  return rcx0;
+}
+
+VALUE
+ca_call_cslab_1_1 (int8_t dty, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty != dtx1 ) {
+    ry = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_2(slabfunc, "10", ry, rx1);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_2 (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty != dtx1 || dty != dtx2 ) {
+    ry = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_3(slabfunc, "100", ry, rx1, rx2);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_3 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 ) {
+    ry = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_4(slabfunc, "1000", ry, rx1, rx2, rx3);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_4 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 ) {
+    ry = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+
+  ca_call_cslab_5(slabfunc, "10000", ry, rx1, rx2, rx3, rx4);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_5 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+  rx5 = rb_ca_wrap_readonly(rx5, INT2NUM(dtx5));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 || dty != dtx5 ) {
+    ry = rb_ca_template_n(5, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)), rb_ca_wrap_readonly(rx5, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(5, rx1, rx2, rx3, rx4, rx5);
+  }
+
+  ca_call_cslab_6(slabfunc, "100000", ry, rx1, rx2, rx3, rx4, rx5);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_6 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+  rx5 = rb_ca_wrap_readonly(rx5, INT2NUM(dtx5));
+  rx6 = rb_ca_wrap_readonly(rx6, INT2NUM(dtx6));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 || dty != dtx5 || dty != dtx6 ) {
+    ry = rb_ca_template_n(6, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)), rb_ca_wrap_readonly(rx5, INT2NUM(dty)), rb_ca_wrap_readonly(rx6, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(6, rx1, rx2, rx3, rx4, rx5, rx6);
+  }
+
+  ca_call_cslab_7(slabfunc, "1000000", ry, rx1, rx2, rx3, rx4, rx5, rx6);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_2_1 (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty1 != dtx1 ) {
+    ry1 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty2 != dtx1 ) {
+    ry2 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_3(slabfunc, "110", ry1, ry2, rx1);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_2 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 ) {
+    ry1 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 ) {
+    ry2 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_4(slabfunc, "1100", ry1, ry2, rx1, rx2);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_3 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 ) {
+    ry1 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 ) {
+    ry2 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_5(slabfunc, "11000", ry1, ry2, rx1, rx2, rx3);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_4 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 || dty1 != dtx4 ) {
+    ry1 = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)), rb_ca_wrap_readonly(rx4, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 || dty2 != dtx4 ) {
+    ry2 = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)), rb_ca_wrap_readonly(rx4, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+
+  ca_call_cslab_6(slabfunc, "110000", ry1, ry2, rx1, rx2, rx3, rx4);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_3_1 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty1 != dtx1 ) {
+    ry1 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty2 != dtx1 ) {
+    ry2 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty3 != dtx1 ) {
+    ry3 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_4(slabfunc, "1110", ry1, ry2, ry3, rx1);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+
+VALUE
+ca_call_cslab_3_2 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 ) {
+    ry1 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 ) {
+    ry2 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty3 != dtx1 || dty3 != dtx2 ) {
+    ry3 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)), rb_ca_wrap_readonly(rx2, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_5(slabfunc, "11100", ry1, ry2, ry3, rx1, rx2);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+
+VALUE
+ca_call_cslab_3_3 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 ) {
+    ry1 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 ) {
+    ry2 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty3 != dtx1 || dty3 != dtx2 || dty3 != dtx3 ) {
+    ry3 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)), rb_ca_wrap_readonly(rx2, INT2NUM(dty3)), rb_ca_wrap_readonly(rx3, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_6(slabfunc, "111000", ry1, ry2, ry3, rx1, rx2, rx3);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+
+VALUE
+ca_call_cslab_1_1_r (int8_t dty, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty != dtx1 ) {
+    ry = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_2_r(slabfunc, "10", ry, rx1, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_2_r (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty != dtx1 || dty != dtx2 ) {
+    ry = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_3_r(slabfunc, "100", ry, rx1, rx2, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_3_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 ) {
+    ry = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_4_r(slabfunc, "1000", ry, rx1, rx2, rx3, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_4_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 ) {
+    ry = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+
+  ca_call_cslab_5_r(slabfunc, "10000", ry, rx1, rx2, rx3, rx4, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_5_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+  rx5 = rb_ca_wrap_readonly(rx5, INT2NUM(dtx5));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 || dty != dtx5 ) {
+    ry = rb_ca_template_n(5, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)), rb_ca_wrap_readonly(rx5, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(5, rx1, rx2, rx3, rx4, rx5);
+  }
+
+  ca_call_cslab_6_r(slabfunc, "100000", ry, rx1, rx2, rx3, rx4, rx5, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_1_6_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6, void *userdata)
+{
+  volatile VALUE ry = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+  rx5 = rb_ca_wrap_readonly(rx5, INT2NUM(dtx5));
+  rx6 = rb_ca_wrap_readonly(rx6, INT2NUM(dtx6));
+
+  if ( dty != dtx1 || dty != dtx2 || dty != dtx3 || dty != dtx4 || dty != dtx5 || dty != dtx6 ) {
+    ry = rb_ca_template_n(6, rb_ca_wrap_readonly(rx1, INT2NUM(dty)), rb_ca_wrap_readonly(rx2, INT2NUM(dty)), rb_ca_wrap_readonly(rx3, INT2NUM(dty)), rb_ca_wrap_readonly(rx4, INT2NUM(dty)), rb_ca_wrap_readonly(rx5, INT2NUM(dty)), rb_ca_wrap_readonly(rx6, INT2NUM(dty)));
+  } else {
+    ry = rb_ca_template_n(6, rx1, rx2, rx3, rx4, rx5, rx6);
+  }
+
+  ca_call_cslab_7_r(slabfunc, "1000000", ry, rx1, rx2, rx3, rx4, rx5, rx6, userdata);
+
+  if ( rb_ca_is_scalar(ry) ) {
+    ry = rb_ca_fetch_addr(ry, 0);
+  }
+  return ry;
+}
+
+VALUE
+ca_call_cslab_2_1_r (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty1 != dtx1 ) {
+    ry1 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty2 != dtx1 ) {
+    ry2 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_3_r(slabfunc, "110", ry1, ry2, rx1, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_2_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 ) {
+    ry1 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 ) {
+    ry2 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_4_r(slabfunc, "1100", ry1, ry2, rx1, rx2, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_3_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 ) {
+    ry1 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 ) {
+    ry2 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_5_r(slabfunc, "11000", ry1, ry2, rx1, rx2, rx3, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_2_4_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+  rx4 = rb_ca_wrap_readonly(rx4, INT2NUM(dtx4));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 || dty1 != dtx4 ) {
+    ry1 = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)), rb_ca_wrap_readonly(rx4, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 || dty2 != dtx4 ) {
+    ry2 = rb_ca_template_n(4, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)), rb_ca_wrap_readonly(rx4, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(4, rx1, rx2, rx3, rx4);
+  }
+
+  ca_call_cslab_6_r(slabfunc, "110000", ry1, ry2, rx1, rx2, rx3, rx4, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  return rb_ary_new3(2, ry1, ry2);
+}
+
+VALUE
+ca_call_cslab_3_1_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+
+  if ( dty1 != dtx1 ) {
+    ry1 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty2 != dtx1 ) {
+    ry2 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(1, rx1);
+  }
+  if ( dty3 != dtx1 ) {
+    ry3 = rb_ca_template_n(1, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(1, rx1);
+  }
+
+  ca_call_cslab_4_r(slabfunc, "1110", ry1, ry2, ry3, rx1, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+
+VALUE
+ca_call_cslab_3_2_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 ) {
+    ry1 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 ) {
+    ry2 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(2, rx1, rx2);
+  }
+  if ( dty3 != dtx1 || dty3 != dtx2 ) {
+    ry3 = rb_ca_template_n(2, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)), rb_ca_wrap_readonly(rx2, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(2, rx1, rx2);
+  }
+
+  ca_call_cslab_5_r(slabfunc, "11100", ry1, ry2, ry3, rx1, rx2, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+
+VALUE
+ca_call_cslab_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata)
+{
+  volatile VALUE ry1 = Qnil, ry2 = Qnil, ry3 = Qnil;
+
+  rx1 = rb_ca_wrap_readonly(rx1, INT2NUM(dtx1));
+  rx2 = rb_ca_wrap_readonly(rx2, INT2NUM(dtx2));
+  rx3 = rb_ca_wrap_readonly(rx3, INT2NUM(dtx3));
+
+  if ( dty1 != dtx1 || dty1 != dtx2 || dty1 != dtx3 ) {
+    ry1 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty1)), rb_ca_wrap_readonly(rx2, INT2NUM(dty1)), rb_ca_wrap_readonly(rx3, INT2NUM(dty1)));
+  } else {
+    ry1 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty2 != dtx1 || dty2 != dtx2 || dty2 != dtx3 ) {
+    ry2 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty2)), rb_ca_wrap_readonly(rx2, INT2NUM(dty2)), rb_ca_wrap_readonly(rx3, INT2NUM(dty2)));
+  } else {
+    ry2 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+  if ( dty3 != dtx1 || dty3 != dtx2 || dty3 != dtx3 ) {
+    ry3 = rb_ca_template_n(3, rb_ca_wrap_readonly(rx1, INT2NUM(dty3)), rb_ca_wrap_readonly(rx2, INT2NUM(dty3)), rb_ca_wrap_readonly(rx3, INT2NUM(dty3)));
+  } else {
+    ry3 = rb_ca_template_n(3, rx1, rx2, rx3);
+  }
+
+  ca_call_cslab_6_r(slabfunc, "111000", ry1, ry2, ry3, rx1, rx2, rx3, userdata);
+
+  if ( rb_ca_is_scalar(ry1) ) {
+    ry1 = rb_ca_fetch_addr(ry1, 0);
+  }
+  if ( rb_ca_is_scalar(ry2) ) {
+    ry2 = rb_ca_fetch_addr(ry2, 0);
+  }
+  if ( rb_ca_is_scalar(ry3) ) {
+    ry3 = rb_ca_fetch_addr(ry3, 0);
+  }
+  return rb_ary_new3(3, ry1, ry2, ry3);
+}
+