DDIR: registered functions as corgi host kernels (and float math)

[frankmcsherry]

Rust functions an embedding program registers by name, callable from DDIR terms, and run as corgi host kernels (frankmcsherry/WIP#38) on the corgi backend. Float math comes along because the registered-function work was built on it and the programs that use one use the other.

Commits

1. Floating-point math: fsqrt, fexp, fln, rounding, trig, fpow/fpowi, fmin/fmax, IEEE compares, fint, over the F64 newtype, in both backends. (In this commit the functions other than fabs, the compares and fmin/fmax ran a row at a time on corgi; commit 6 makes them columnar.)
2. Registered functions: ir::register(Function { name, args, result, body }); the parser resolves a non-builtin name against the registry (a registered name may not shadow a builtin) to Term::Call. The row backend calls the body. The contract is purity.
3. Move, don't clone, in the corgi row fallback: transcode/untranscode take their input by value.
4. Calls lower to NumOp::Host: the term around a call stays columnar. A function's columnar body comes from ir::register_kernel; otherwise RowKernel runs the row body, converting only the call's arguments and result. kernel_of keeps one Arc per function, so CSE can merge equal calls. Argument shapes are checked when the program is typed at install, by the host op. Pins corgi at the merge of Implement indices for Traces #38.
5. Review follow-ups: a no-argument call passes a Unit over the anchor (corgi rejects an empty product as a kernel input, since it carries no row count); tests for a zero-argument call and a columnar kernel; Arc::clone; float-lowering locals renamed so nothing shadows an unrelated binding.
6. Float functions as host kernels; the row fallback goes. The F64 functions that are not compositions of corgi ops are built-in host kernels over the float column (decode the order key, apply as ir::eval does, encode), one per function. With nothing row-only left, Kernel, row_only, columnar_stand_in, literal_of_shape and Kernel::Rows are deleted and lowering returns a Graph<NumOp> again. Review fixes: register drops any kernel of the name it replaces; the row backend checks call arguments against the declared shapes (so both backends reject a mis-shaped call); keywords such as min cannot be registered (one keyword table, consulted by is_builtin); transcode requires a tuple's exact field count.

Tests

• tests/programs/registered.ddp calls five registered functions (list-valued, float-valued, nested-shape, zero-argument, and one with a columnar kernel) in a map, a filter, a flatmap, a join projection and a refinement fixpoint. The corgi-vs-vec gate runs it at 1–4 workers and over serializing channels.
• Every F64 op agrees with ir::eval on all pairs of special values (signed zeros, infinities, NaNs of both signs); a composite term over non-NaN pairs. One pre-existing difference, noted in the test: corgi's float Add returns the positive NaN where ir::eval keeps a NaN operand's sign.
• Re-registration drops the old kernel; a mis-shaped call fails on both backends; min cannot be registered.
• cargo test --release -p interactive: 110 passed, 5 ignored. Clippy warnings for interactive: 165 → 164.

Float functions, before and after commit 6 (a projection ($0 ; f($0)) over 2^20 F64 rows, lowered and run on one core, median of 7, ns per row): fsqrt 152 → 1.9, fexp 155 → 3.1, fln 157 → 3.3, ffloor 155 → 1.7, fsin 158 → 3.6, fint 130 → 1.1, fpow 178 → 5.6; a mixed term tuple(fadd(fsqrt($0), $0), flt($0, $0)) 264 → 13. fabs (already columnar) 1.5 → 1.7, unchanged. The old cost was the row fallback converting the whole term's input to rows and back, not the math.

Measured on worldgen's DDIR program (33 registered rules, 6 as columnar kernels; 27/27 tour steps agree with the native engine):

• One worker, tour: 16.7 s → 12.6 s from commit 3.
• Four workers, tour: 8.6 s → 5.0 s, and a 1 km move 263 → 60 ms, from commit 4 with the columnar rules.

Not in this PR (follow-ups): columnar exports and export taps; a check that join key shapes agree (a mismatch silently yields nothing today); running corgi::cse on lowered graphs; resolving a call's function once at lowering instead of a registry lookup per row on the row backend; whether the process-wide registry should become one passed with the program.

🤖 Generated with Claude Code