carray 3.0.2 → 3.0.4

data/ext/ca_sort_kernels.h

@@ -129,4 +129,74 @@ void ca_sort_merge_pair_u64 (ca_pair_u64 *a, ca_pair_u64 *aux, ca_size_t n);
 void ca_sort_merge_pair_f32 (ca_pair_f32 *a, ca_pair_f32 *aux, ca_size_t n);
 void ca_sort_merge_pair_f64 (ca_pair_f64 *a, ca_pair_f64 *aux, ca_size_t n);
 
+/* Runs of this many elements are insertion-sorted before the merge passes. */
+#define CA_SORT_INSERTION_THRESHOLD 16
+
+/* The body of a stable bottom-up mergesort over TYPE, ordered by cmp alone
+   (the element type has no `<`), for a function taking
+     (TYPE *a, TYPE *aux, ca_size_t n, int (*cmp)(const void *, const void *))
+   aux holds n elements.  cmp may raise -- an object comparator calls <=> --
+   and the raise unwinds through this code's frames, which hold nothing;
+   libc's qsort / mergesort would have to be unwound instead.
+
+   A comparison is costly here (a call into Ruby) and a move is cheap, so
+   the runs are insertion-sorted with each insertion point found by binary
+   search: log2(k) comparisons where a linear walk takes k/2.  Merge passes
+   ping-pong between a and aux and skip a pair of runs already in order.
+   Stable: an element lands after every one that does not compare greater,
+   and a merge takes from the right run only on a strictly smaller one. */
+#define CA_SORT_MERGE_BY_CMP(TYPE)                                            \
+{                                                                             \
+  if ( n <= 1 ) return;                                                       \
+  for ( ca_size_t lo = 0; lo < n; lo += CA_SORT_INSERTION_THRESHOLD ) {       \
+    ca_size_t hi = lo + CA_SORT_INSERTION_THRESHOLD;                          \
+    if ( hi > n ) hi = n;                                                     \
+    for ( ca_size_t k = lo + 1; k < hi; k++ ) {                               \
+      TYPE v = a[k];                                                          \
+      ca_size_t l = lo, r = k;                                                \
+      while ( l < r ) {                                                       \
+        ca_size_t mid = l + (r - l) / 2;                                      \
+        if ( cmp(&a[mid], &v) > 0 ) r = mid;                                  \
+        else                        l = mid + 1;                              \
+      }                                                                       \
+      if ( l < k ) {                                                          \
+        memmove(a + l + 1, a + l, (size_t)(k - l) * sizeof(TYPE));            \
+        a[l] = v;                                                             \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+  TYPE *cur  = a;                                                             \
+  TYPE *next = aux;                                                           \
+  for ( ca_size_t width = CA_SORT_INSERTION_THRESHOLD; width < n;             \
+        width <<= 1 ) {                                                       \
+    for ( ca_size_t lo = 0; lo < n; lo += (width << 1) ) {                    \
+      ca_size_t mid = lo + width;                                             \
+      ca_size_t hi  = lo + (width << 1);                                      \
+      if ( mid > n ) mid = n;                                                 \
+      if ( hi  > n ) hi  = n;                                                 \
+      if ( mid >= hi || cmp(&cur[mid - 1], &cur[mid]) <= 0 ) {               \
+        memcpy(next + lo, cur + lo, (size_t)(hi - lo) * sizeof(TYPE));        \
+        continue;                                                             \
+      }                                                                       \
+      ca_size_t i = lo, j = mid, k = lo;                                      \
+      while ( i < mid && j < hi ) {                                           \
+        if ( cmp(&cur[j], &cur[i]) < 0 ) next[k++] = cur[j++];                \
+        else                             next[k++] = cur[i++];                \
+      }                                                                       \
+      while ( i < mid ) next[k++] = cur[i++];                                 \
+      while ( j < hi  ) next[k++] = cur[j++];                                 \
+    }                                                                         \
+    { TYPE *t = cur; cur = next; next = t; }                                  \
+  }                                                                           \
+  if ( cur != a ) {                                                           \
+    memcpy(a, cur, (size_t) n * sizeof(TYPE));                                \
+  }                                                                           \
+}
+
+/* (VALUE, index) pairs, as the object lane of the sort kernels holds them. */
+typedef struct ca_pair_object { VALUE v; ca_size_t i; } ca_pair_object;
+void ca_sort_merge_pair_object (ca_pair_object *a, ca_pair_object *aux,
+                                ca_size_t n,
+                                int (*cmp)(const void *, const void *));
+
 #endif /* CA_SORT_KERNELS_H */

data/ext/ca_sweep_engine.c

@@ -42,9 +42,9 @@ ca_sweep_refuse_shapes (CArray *a, CArray *b)
   volatile VALUE sa = ca_sweep_shape_str(a);
   volatile VALUE sb = ca_sweep_shape_str(b);
   rb_raise(rb_eArgError,
-           "shape mismatch between operands (%s and %s); a scalar pairs "
+           "%s: shape mismatch between operands (%s and %s); a scalar pairs "
            "with any array, two arrays only when their shapes agree",
-           StringValueCStr(sa), StringValueCStr(sb));
+           ca_calling_method_name(), StringValueCStr(sa), StringValueCStr(sb));
 }
 
 int
@@ -85,6 +85,26 @@ ca_sweep_pair_operands (ca_sweep_state_t *st)
   return donor;
 }
 
+/* Non-zero when INPUT k_op lives in the same root as an OUTPUT other
+ * than itself.  Read in place, or chunk by chunk after earlier chunks
+ * were written, it would show the kernel cells already written; such an
+ * input is read whole before the walk.  An input that is the output
+ * itself is read in place: each cell is read before it is written. */
+static int
+ca_sweep_input_overlaps_output (ca_sweep_state_t *st, int k_op)
+{
+  int j;
+  CArray *ca = st->cx[k_op];
+  if (st->fsync[k_op] != '0' || ca_is_scalar(ca)) return 0;
+  for (j = 0; j < st->n_ops; j++) {
+    if (st->fsync[j] == '1' && st->cx[j] != ca &&
+        ca_shares_root(ca, st->cx[j])) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
 /* Non-zero when any INPUT operand carries a mask.  Asks, allocates
  * nothing. */
 static int
@@ -97,18 +117,6 @@ ca_sweep_any_input_mask (ca_sweep_state_t *st)
   return 0;
 }
 
-NORETURN(static void ca_sweep_refuse_masked_input (ca_sweep_state_t *st,
-                                                  const char *fallback));
-
-static void
-ca_sweep_refuse_masked_input (ca_sweep_state_t *st, const char *fallback)
-{
-  rb_raise(rb_eRuntimeError,
-           "%s: masked INPUT not allowed in NO_MASK form "
-           "(use the *_MASKED form to handle masked cells explicitly)",
-           st->src_label ? st->src_label : fallback);
-}
-
 /* Give back everything acquire has taken so far, without syncing: detach
  * attached operands, free owned scratch (xmalloc on the whole-buffer path,
  * arena on the chunked one) and the mask buffers.  Called when a read
@@ -158,12 +166,14 @@ ca_sweep_acquire_body (VALUE arg)
   /* Per-operand acquire:
    *   OUTPUT (fsync == '1')       -> ca_attach + base = ca->ptr
    *   INPUT alias                 -> ca_attach + base = ca->ptr
-   *   INPUT non-alias non-scalar  -> xmalloc scratch + ca_xfer_all
+   *   INPUT non-alias non-scalar,
+   *   or sharing an OUTPUT's root -> xmalloc scratch + ca_xfer_all
    * INPUT non-alias never attaches the operand itself; the scratch
    * copy carries the values into the kernel. */
   for (k_op = 0; k_op < st->n_ops; k_op++) {
     CArray *ca = st->cx[k_op];
-    if (st->fsync[k_op] == '1' || ca_attach_is_alias(ca)) {
+    if (st->fsync[k_op] == '1' ||
+        (ca_attach_is_alias(ca) && ! ca_sweep_input_overlaps_output(st, k_op))) {
       ca_attach(ca);
       st->attached[k_op] = 1;
       st->base[k_op]     = (char *) ca->ptr;
@@ -204,8 +214,7 @@ ca_sweep_acquire_body (VALUE arg)
     for (k_op = 0; k_op < st->n_ops; k_op++) {
       CArray *ca = st->cx[k_op];
       if (st->fsync[k_op] != '1') continue;
-      ca_update_mask(ca);
-      if (!ca->mask) ca_create_mask(ca);
+      ca_create_mask(ca);
       memcpy(ca->mask->ptr, st->m0, st->n_kernel);
     }
   }
@@ -232,17 +241,12 @@ ca_sweep_acquire (ca_sweep_state_t *st)
     st->attached[k_op]  = 0;
   }
   st->m0       = NULL;
-  /* CAREFUL: do not reset st->no_mask here — caller sets it before
-   * acquire and the NO_MASK guard below consumes it. */
 
   /* Refusals come first, while nothing is held. */
   ca_sweep_pair_operands(st);
   ctx.st             = st;
   ctx.ms             = NULL;
   ctx.any_input_mask = ca_sweep_any_input_mask(st);
-  if (ctx.any_input_mask && st->no_mask) {
-    ca_sweep_refuse_masked_input(st, "ca_sweep_acquire");
-  }
 
   rb_protect(ca_sweep_acquire_body, (VALUE) &ctx, &tag);
   if (ctx.ms) xfree(ctx.ms);
@@ -280,14 +284,60 @@ ca_sweep_run_chunked (ca_sweep_state_t *st, VALUE (*walk)(VALUE), VALUE arg)
   ca_sweep_release_chunked(st);
 }
 
+static VALUE
+ca_sweep_sync_one (VALUE arg)
+{
+  ca_sync((CArray *) arg);
+  return Qnil;
+}
+
+/* Sync the OUTPUTs (reverse order).  Writing back through a view's slots
+ * can raise (a CAObject's store hook); the raise is held so that release
+ * still detaches and frees everything, and ca_sweep_reraise propagates
+ * it afterwards.  An entity's sync does nothing that can raise, so it is
+ * called directly: the outputs this library allocates itself pay nothing. */
+static int
+ca_sweep_sync_outputs (ca_sweep_state_t *st, volatile VALUE *error)
+{
+  int k_op, first = 0;
+  for (k_op = st->n_ops - 1; k_op >= 0; k_op--) {
+    CArray *ca = st->cx[k_op];
+    if (st->fsync[k_op] != '1') {
+      continue;
+    }
+    if (ca_is_entity(ca)) {
+      ca_sync(ca);
+    }
+    else {
+      int tag = 0;
+      rb_protect(ca_sweep_sync_one, (VALUE) ca, &tag);
+      if (tag) {
+        if (! first) {
+          first  = tag;
+          *error = rb_errinfo();
+        }
+        rb_set_errinfo(Qnil);
+      }
+    }
+  }
+  return first;
+}
+
+static void
+ca_sweep_reraise (int tag, VALUE error)
+{
+  if (tag) {
+    rb_set_errinfo(error);
+    rb_jump_tag(tag);
+  }
+}
+
 void
 ca_sweep_release (ca_sweep_state_t *st)
 {
   int k_op;
-  /* sync OUTPUTs (reverse order) */
-  for (k_op = st->n_ops - 1; k_op >= 0; k_op--) {
-    if (st->fsync[k_op] == '1') ca_sync(st->cx[k_op]);
-  }
+  volatile VALUE error = Qnil;
+  int tag = ca_sweep_sync_outputs(st, &error);
   /* detach attached / xfree owned buffers (reverse order) */
   for (k_op = st->n_ops - 1; k_op >= 0; k_op--) {
     if (st->attached[k_op]) {
@@ -301,6 +351,7 @@ ca_sweep_release (ca_sweep_state_t *st)
     xfree(st->m0);
     st->m0 = NULL;
   }
+  ca_sweep_reraise(tag, error);
 }
 
 /* ===== Chunked path implementation ===== */
@@ -315,13 +366,14 @@ ca_sweep_acquire_chunked_body (VALUE arg)
   /* per-operand acquire:
    *   OUTPUT (fsync == '1') : ca_attach + base_orig = ca->ptr (legitimate)
    *   INPUT  alias          : ca_attach + base_orig = ca->ptr (zero-copy)
-   *   INPUT  non-alias non-scalar : arena chunk scratch of chunk_n_max bytes
+   *   INPUT  non-alias non-scalar,
+   *   or sharing an OUTPUT's root : arena chunk scratch of chunk_n_max bytes
    *   INPUT  scalar         : ca_attach + base_orig = ca->ptr (1 cell)
    */
   for (k_op = 0; k_op < st->n_ops; k_op++) {
     CArray *ca = st->cx[k_op];
     if (st->fsync[k_op] == '1' || ca_is_scalar(ca) ||
-        ca_attach_is_alias(ca)) {
+        (ca_attach_is_alias(ca) && ! ca_sweep_input_overlaps_output(st, k_op))) {
       ca_attach(ca);
       st->attached[k_op]  = 1;
       st->base_orig[k_op] = (char *) ca->ptr;
@@ -352,8 +404,7 @@ ca_sweep_acquire_chunked_body (VALUE arg)
     for (k_op = 0; k_op < st->n_ops; k_op++) {
       CArray *ca = st->cx[k_op];
       if (st->fsync[k_op] != '1') continue;
-      ca_update_mask(ca);
-      if (!ca->mask) ca_create_mask(ca);
+      ca_create_mask(ca);
     }
   }
 
@@ -410,13 +461,20 @@ ca_sweep_acquire_chunked (ca_sweep_state_t *st)
     st->chunk_n_max = 1;
   }
 
+  /* An INPUT sharing an OUTPUT's root is read whole before anything is
+     written: the walk becomes a single chunk, so its data and its mask
+     are gathered before the first flush. */
+  for (k_op = 0; k_op < st->n_ops; k_op++) {
+    if (ca_sweep_input_overlaps_output(st, k_op) && st->n_kernel > 0) {
+      st->chunk_n_max = st->n_kernel;
+      break;
+    }
+  }
+
   /* Refusals come first, while nothing is held. */
   ctx.st             = st;
   ctx.ms             = NULL;
   ctx.any_input_mask = ca_sweep_any_input_mask(st);
-  if (ctx.any_input_mask && st->no_mask) {
-    ca_sweep_refuse_masked_input(st, "ca_sweep_acquire_chunked");
-  }
 
   rb_protect(ca_sweep_acquire_chunked_body, (VALUE) &ctx, &tag);
   if (tag) {
@@ -454,9 +512,7 @@ ca_sweep_gather_chunk_mask (ca_sweep_state_t *st, ca_size_t off, ca_size_t n)
   }
 }
 
-/* Copy the chunk just finished out to every OUTPUT operand's mask.  Runs
- * after the author's loop over that chunk, so m_out writes into m0 are
- * carried through. */
+/* Copy the chunk just finished out to every OUTPUT operand's mask. */
 static void
 ca_sweep_flush_chunk_mask (ca_sweep_state_t *st)
 {
@@ -510,7 +566,6 @@ ca_sweep_next_chunk (ca_sweep_state_t *st)
     st->chunk_off     = 0;
     st->chunked_state = 1;
   } else {
-    /* the chunk that just finished is the author's last word on its mask */
     ca_sweep_flush_chunk_mask(st);
     /* advance */
     st->chunk_off += st->chunk_n;
@@ -543,16 +598,15 @@ void
 ca_sweep_release_chunked (ca_sweep_state_t *st)
 {
   int k_op;
+  volatile VALUE error = Qnil;
+  int tag;
   /* a walk that raised has already given everything back */
   if (st->chunked_state == 3) return;
   /* The final chunk has no next_chunk call to flush it, so it is flushed
-   * here.  For INOUT_MASKED forms this is what captures the author's
-   * per-cell m_out writes over that last chunk. */
+   * here. */
   ca_sweep_flush_chunk_mask(st);
-  /* sync OUTPUTs (reverse order, regardless of whether chunk loop ran) */
-  for (k_op = st->n_ops - 1; k_op >= 0; k_op--) {
-    if (st->fsync[k_op] == '1') ca_sync(st->cx[k_op]);
-  }
+  /* sync OUTPUTs (regardless of whether chunk loop ran) */
+  tag = ca_sweep_sync_outputs(st, &error);
   /* detach attached / release arena scratch buffers (reverse order) */
   for (k_op = st->n_ops - 1; k_op >= 0; k_op--) {
     if (st->attached[k_op]) {
@@ -570,13 +624,16 @@ ca_sweep_release_chunked (ca_sweep_state_t *st)
     ca_lazy_arena_release(st->mask_scratch);
     st->mask_scratch = NULL;
   }
+  if (tag) {
+    st->chunked_state = 3;            /* everything has been given back */
+  }
+  ca_sweep_reraise(tag, error);
 }
 
 /* ===== WHOLE_BUFFER function form (rb_ensure-protected) ===== */
 
 typedef struct {
   CArray              *ca;
-  int                  writable;
   ca_with_buffer_body_fn body_fn;
   void                *user_data;
 } ca_with_buffer_ctx_t;
@@ -589,49 +646,15 @@ ca_with_buffer_body_trampoline (VALUE ctx_val)
   return Qnil;
 }
 
-static VALUE
-ca_with_buffer_ensure_trampoline (VALUE ctx_val)
-{
-  ca_with_buffer_ctx_t *ctx = (ca_with_buffer_ctx_t *) ctx_val;
-  if (ctx->writable) ca_sync(ctx->ca);
-  ca_detach(ctx->ca);
-  return Qnil;
-}
-
 void
 rb_ca_call_with_buffer (VALUE r_ca, int writable,
                    ca_with_buffer_body_fn body, void *user_data)
 {
   ca_with_buffer_ctx_t ctx;
   TypedData_Get_Struct(r_ca, CArray, &carray_data_type, ctx.ca);
-  /* CAREFUL: attach outside rb_ensure.  If attach raises, we are not
-   * yet inside the ensure scope, so the ensure trampoline will not
-   * fire on a not-attached ca (which would try to detach and crash). */
-  ca_attach(ctx.ca);
-  ctx.writable  = writable;
   ctx.body_fn   = body;
   ctx.user_data = user_data;
-  rb_ensure(ca_with_buffer_body_trampoline,    (VALUE) &ctx,
-            ca_with_buffer_ensure_trampoline,  (VALUE) &ctx);
+  ca_attach_window(1, &ctx.ca, writable ? "w" : "r",
+                   ca_with_buffer_body_trampoline, (VALUE) &ctx);
 }
 
-void
-ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out, const char *src_label)
-{
-  int k;
-  const char *lbl = src_label ? src_label : "ca_sweep_check_same_shape";
-  if (ca_in->ndim != ca_out->ndim) {
-    rb_raise(rb_eRuntimeError,
-             "%s: shape mismatch (ndim %d vs %d)",
-             lbl, ca_in->ndim, ca_out->ndim);
-  }
-  for (k = 0; k < ca_in->ndim; k++) {
-    if (ca_in->dim[k] != ca_out->dim[k]) {
-      rb_raise(rb_eRuntimeError,
-               "%s: shape mismatch at dim[%d] (%lld vs %lld)",
-               lbl, k,
-               (long long) ca_in->dim[k],
-               (long long) ca_out->dim[k]);
-    }
-  }
-}

data/ext/ca_sweep_engine.h

@@ -5,8 +5,7 @@
  *  Established in PROPOSAL_L0_AUTHOR_SURFACE L0.1 (2026-06-11).  Extracts
  *  the xfer_all-aware lifecycle template previously duplicated 7-times in
  *  ext/carray_call_cfunc.c (= one body per arity 1..7) into a single shared
- *  helper.  Same helper will back the forthcoming CA_FOR_EACH_ELEMENT macro
- *  family (L0.2a) and the WHOLE_BUFFER family (L0.2c).
+ *  helper, also used by the chunked slab family (ca_call_cslab_*).
  *
  *  Lifecycle template:
  *    (1) per-operand acquire
@@ -64,15 +63,10 @@ typedef struct ca_sweep_state {
   boolean8_t     *m0;
   ca_size_t       n_kernel;
   const char     *src_label;
-  /* no_mask: if non-zero, ca_sweep_acquire raises when any INPUT operand has
-   * a mask.  Used by the NO_MASK macro forms (CA_FOR_EACH_ELEMENT etc.) to
-   * implement Q3=(ii) runtime error policy.  Default 0 (= masked INPUT OK,
-   * m0 built as usual).  Caller sets before calling ca_sweep_acquire. */
-  int             no_mask;
 
   /* === chunked path fields (L0.1 chunk, PROPOSAL_L0_AUTHOR_SURFACE) === */
   /* Used by ca_sweep_acquire_chunked / ca_sweep_next_chunk / ca_sweep_release_chunked
-   * (= the sweep ELEMENT macro family).  Unused by the whole-materialise path
+   * (= the chunked slab family, ca_call_cslab_*).  Unused by the whole-materialise path
    * (ca_sweep_acquire / ca_sweep_release) — cfunc and other whole-buffer callers
    * leave these zero. */
   char          **base_orig;     /* per-op original ptr (= ca->ptr for
@@ -93,7 +87,7 @@ typedef struct ca_sweep_state {
 
 /* Validate fsync length, pair the operands (shape), acquire per-op
  * buffers, build mask m0, propagate mask to OUTPUTs.  May raise: refusals
- * (fsync length, shape mismatch, masked INPUT in a NO_MASK form) before
+ * (fsync length, shape mismatch) before
  * anything is held, and a raising operand read after -- in which case
  * everything acquired so far is detached / freed before the raise
  * propagates, so the caller must not call release.  The chunked path
@@ -120,13 +114,7 @@ void ca_sweep_run_chunked (ca_sweep_state_t *st, VALUE (*walk)(VALUE), VALUE arg
 int  ca_sweep_same_shape (CArray *a, CArray *b);
 NORETURN(void ca_sweep_refuse_shapes (CArray *a, CArray *b));
 
-/* Strict full-shape equality check used by INOUT macros (AC5: silent-
- * corruption seam prevention).  Raises if ndim differs or any dim[k]
- * differs.  Returns void; raises on mismatch. */
-void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
-                             const char *src_label);
-
-/* ===== Chunked path API (sweep ELEMENT macro family, L0.1 chunk) =====
+/* ===== Chunked path API (ca_call_cslab_*) =====
  *
  * Unlike ca_sweep_acquire / ca_sweep_release (= whole-buffer materialise used
  * by cfunc), the chunked path keeps INPUT memory peak bounded to chunk
@@ -134,7 +122,7 @@ void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
  * memory peak guarantee: shrinking views materialise into chunk scratch
  * sized to inner-axis multiples, not full operand size.
  *
- * Usage shape (inside a macro):
+ * Usage shape:
  *   ca_sweep_acquire_chunked(&st);
  *   while (ca_sweep_next_chunk(&st)) {
  *     for (k = 0; k < st.chunk_n; k++) {
@@ -162,9 +150,8 @@ void ca_sweep_check_same_shape (CArray *ca_in, CArray *ca_out,
  *   indexed within the chunk, NOT by the flat cell index.  (This differs
  *   from the whole-buffer path, where m0 spans n_kernel.)
  *
- *   An author may WRITE m0[k] during the chunk loop (= the INOUT_MASKED
- *   forms' m_out).  Those writes are flushed into the OUTPUT operands'
- *   masks when the chunk finishes -- at the top of the following
+ *   The chunk's m0 is flushed into the OUTPUT operands' masks when the
+ *   chunk finishes -- at the top of the following
  *   ca_sweep_next_chunk, and once more in ca_sweep_release_chunked for
  *   the last chunk -- so the OUTPUT masks are created up front in
  *   acquire_chunked rather than propagated in one go at release.

data/ext/ca_triop_dispatch.c

@@ -27,6 +27,7 @@ ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt)
     case CA_TRIOP_FMA:  return ca_triop_fma  [common_dt];
     case CA_TRIOP_FMS:  return ca_triop_fms  [common_dt];
     case CA_TRIOP_CLIP: return ca_triop_clip [common_dt];
+    case CA_TRIOP_SELECT: return ca_triop_select [common_dt];
     default:            return NULL;
   }
 }
@@ -38,7 +39,9 @@ ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt)
 int8_t
 ca_lazy_promote_triop (uint16_t op_id, int8_t dt1, int8_t dt2, int8_t dt3)
 {
-  (void) op_id;   /* uniform 3-way promote across all currently-defined triops */
+  if ( op_id == CA_TRIOP_SELECT ) {
+    return (int8_t) ca_promote_type(dt2, dt3);
+  }
   return (int8_t) ca_promote_type(ca_promote_type(dt1, dt2), dt3);
 }
 

data/ext/ca_triop_dispatch.h

@@ -11,7 +11,7 @@
   runs (cast-before invariant, mirrors CABinOp).  Output data_type is
   always the common data_type (preserve).
 
-  Scope: fma / fms / clip (see ext/mkkernel.rb :fma / :fms / :clip).
+  Scope: fma / fms / clip / select (see ext/mkkernel.rb).
   None of the currently-defined triops trap on integer zero divisor.
 
 ---------------------------------------------------------------------------- */
@@ -29,6 +29,7 @@ enum {
   CA_TRIOP_FMA  = 0,   /* a * b + c  (single-rounding on float)     */
   CA_TRIOP_FMS  = 1,   /* a * b - c  (single-rounding on float)     */
   CA_TRIOP_CLIP = 2,   /* min(max(a, lo), hi), NaN-preserving        */
+  CA_TRIOP_SELECT = 3, /* a ? b : c  (lazy then_else)                 */
 
   CA_TRIOP_COUNT
 };
@@ -40,6 +41,7 @@ enum {
 extern ca_triop_func_t ca_triop_fma        [CA_NTYPE];
 extern ca_triop_func_t ca_triop_fms        [CA_NTYPE];
 extern ca_triop_func_t ca_triop_clip       [CA_NTYPE];
+extern ca_triop_func_t ca_triop_select     [CA_NTYPE];
 
 /* ------------------------------------------------------------------- */
 /* Dispatch API                                                         */
@@ -49,7 +51,8 @@ extern ca_triop_func_t ca_triop_clip       [CA_NTYPE];
    not implemented at the requested data_type. */
 ca_triop_func_t ca_triop_kernel_lookup_vvv (uint16_t op_id, int8_t common_dt);
 
-/* 3-way promotion: common data_type of (dt1, dt2, dt3).                 */
+/* 3-way promotion: common data_type of (dt1, dt2, dt3).  For select it is
+   that of the two branches (dt2, dt3); the condition is converted to it. */
 int8_t ca_lazy_promote_triop (uint16_t op_id, int8_t dt1, int8_t dt2, int8_t dt3);
 
 /* Each operand's cast-target data_type (= common data_type for all three,