feat(specializer): slot-fill output + boundary bench with generic baseline (TASK-45 stretch 3)

Measurement killed an assumption: pydantic v2's model_construct is
pure-Python and SLOWER than model_validate (1432ns vs 882ns per row,
pydantic 2.13). The marshaller now builds output rows the way the
design doc meant — object.__new__ + direct slot writes (__dict__,
__pydantic_fields_set__, extra, private), 491ns measured — and the
bench gained a 'generic' engine (SPECIALIZER_GENERIC_BOUNDARY) as the
AC #2 baseline. Results: marshaller beats the generic boundary
1.9-2.5x on the no-op f; the specializer beats the shipping native
engine 3.7-4.2x end-to-end at n=1024 and 1.5-2.8x at n=1; the JIT-vs-
interp compute gap is finally visible through Python.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: 2 people

scripts/bench_specializer.py

@@ -1,16 +1,20 @@
 """Specializer ns/call bench — the design doc §10 measurement discipline.
 
 Reports p50/p99 ns per call at n in {1, 8, 64, 1024} for:
-  boundary   — a no-op passthrough (SELECT a FROM __THIS__) through the
-               generic pydantic path: the floor every engine pays today
-  cranelift  — the specializer's JIT backend (default)
+  cranelift  — the specializer's JIT backend through the generated row
+               marshaller (the default production path)
   interp     — the same programs on the interpreter backend (the control;
-               SPECIALIZER_FORCE_INTERP=1 in a subprocess)
+               SPECIALIZER_FORCE_INTERP=1 in a subprocess), also marshalled
+  generic    — the JIT backend behind the PRE-marshaller generic boundary
+               (SPECIALIZER_GENERIC_BOUNDARY=1): per-cell getattr with
+               fresh name strings, per-call buffers, model_validate per
+               output row. generic vs cranelift on the noop case IS the
+               marshaller's win (TASK-45 AC #2).
   native     — the existing DataFusion-semantics InferFn
   codegen    — the existing Python codegen engine
 
 Run: `uv run python scripts/bench_specializer.py [--json out.json]`
-The interp control re-execs this script in a subprocess so the env knob is
+The env-knob engines re-exec this script in a subprocess so the knob is
 set before the module builds its functions.
 """
 
@@ -79,7 +83,11 @@ def main():
     dim = pa.table({"id": list(range(60)), "name": [f"n{i}" for i in range(60)]})
     engine = os.environ.get("BENCH_ENGINE", "cranelift")
 
-    builders = {"cranelift": build_specializer, "interp": build_specializer}
+    builders = {
+        "cranelift": build_specializer,
+        "interp": build_specializer,
+        "generic": build_specializer,
+    }
     if engine in ("native", "codegen"):
         builders = {"native": build_native, "codegen": build_codegen}
 
@@ -90,9 +98,11 @@ def main():
         except Exception as e:  # noqa: BLE001 -- engines differ in coverage
             results[case] = {"error": str(e)[:120]}
             continue
-        if engine in ("cranelift", "interp"):
+        if engine in ("cranelift", "interp", "generic"):
             want = "interpreter" if engine == "interp" else "cranelift"
             assert fn.backend == want, f"{case}: backend is {fn.backend}, wanted {want}"
+            wantb = "generic" if engine == "generic" else "marshaller"
+            assert fn.boundary == wantb, f"{case}: boundary {fn.boundary} != {wantb}"
         per_n = {}
         for n in NS:
             objs = [model(**r) for r in rows_of(n)]
@@ -105,11 +115,13 @@ def main():
 def orchestrate():
     """Run every engine (interp in a subprocess for the env knob), merge."""
     merged = {}
-    for engine in ("cranelift", "interp", "native", "codegen"):
+    for engine in ("cranelift", "interp", "generic", "native", "codegen"):
         env = os.environ.copy()
         env["BENCH_ENGINE"] = engine
         if engine == "interp":
             env["SPECIALIZER_FORCE_INTERP"] = "1"
+        if engine == "generic":
+            env["SPECIALIZER_GENERIC_BOUNDARY"] = "1"
         out = subprocess.run(  # noqa: S603 -- fixed argv
             [sys.executable, __file__, "--engine-run"],
             env=env,

src/duckdb/mod.rs

@@ -10,7 +10,7 @@
 use std::collections::HashMap;
 
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString};
+use pyo3::types::{PyDict, PySet, PyString};
 
 use crate::error::InterpError;
 use crate::schema;
@@ -209,10 +209,21 @@ impl Backend {
 struct Marshaller {
     in_names: Vec<Py<PyString>>,
     out_names: Vec<Py<PyString>>,
-    /// `output_model.model_construct`, resolved at build. Outputs come out
-    /// of the typed engine already conformant; re-validating them per row
-    /// was the single largest boundary cost.
-    construct: Py<PyAny>,
+    /// Output rows are built by filling pydantic v2's instance slots
+    /// directly (`object.__new__` + `object.__setattr__` of `__dict__`,
+    /// `__pydantic_fields_set__`, `__pydantic_extra__`,
+    /// `__pydantic_private__`) — what `model_construct` does, minus its
+    /// pure-Python per-field loop (measured 2026-07-26 on pydantic 2.13:
+    /// construct 1432ns > validate 882ns > slot fill 491ns per row).
+    /// Assumes a plain model: no `extra="allow"`, no private attrs —
+    /// true of synthesized output models; supplied ones are v0-trusted.
+    model: Py<PyAny>,
+    object_new: Py<PyAny>,
+    object_setattr: Py<PyAny>,
+    s_dict: Py<PyString>,
+    s_fields_set: Py<PyString>,
+    s_extra: Py<PyString>,
+    s_private: Py<PyString>,
     cols: Vec<ColData>,
     state: RunState,
 }
@@ -225,6 +236,7 @@ impl Marshaller {
         output_model: &Py<PyAny>,
         fun: &Backend,
     ) -> PyResult<Marshaller> {
+        let object = PyModule::import(py, "builtins")?.getattr("object")?;
         Ok(Marshaller {
             in_names: in_cols
                 .iter()
@@ -234,7 +246,13 @@ impl Marshaller {
                 .iter()
                 .map(|c| PyString::intern(py, &c.name).unbind())
                 .collect(),
-            construct: output_model.bind(py).getattr("model_construct")?.unbind(),
+            model: output_model.clone_ref(py),
+            object_new: object.getattr("__new__")?.unbind(),
+            object_setattr: object.getattr("__setattr__")?.unbind(),
+            s_dict: PyString::intern(py, "__dict__").unbind(),
+            s_fields_set: PyString::intern(py, "__pydantic_fields_set__").unbind(),
+            s_extra: PyString::intern(py, "__pydantic_extra__").unbind(),
+            s_private: PyString::intern(py, "__pydantic_private__").unbind(),
             cols: in_cols.iter().map(|c| ColData::new(c.ty.ty)).collect(),
             state: fun.new_state(),
         })
@@ -314,7 +332,14 @@ impl Marshaller {
         self.cols = batch.cols;
         res.map_err(|t| PyErr::from(InterpError::Eval(t.0)))?;
 
-        let construct = self.construct.bind(py);
+        let model = self.model.bind(py);
+        let object_new = self.object_new.bind(py);
+        let object_setattr = self.object_setattr.bind(py);
+        let s_dict = self.s_dict.bind(py);
+        let s_fields_set = self.s_fields_set.bind(py);
+        let s_extra = self.s_extra.bind(py);
+        let s_private = self.s_private.bind(py);
+        let none = py.None();
         let mut out = Vec::with_capacity(self.state.emitted);
         for r in 0..self.state.emitted {
             let d = PyDict::new(py);
@@ -339,7 +364,13 @@ impl Marshaller {
                     }
                 }
             }
-            out.push(construct.call((), Some(&d))?.unbind());
+            let fields_set = PySet::new(py, self.out_names.iter().map(|n| n.bind(py)))?;
+            let inst = object_new.call1((model,))?;
+            object_setattr.call1((&inst, s_dict, &d))?;
+            object_setattr.call1((&inst, s_fields_set, fields_set))?;
+            object_setattr.call1((&inst, s_extra, &none))?;
+            object_setattr.call1((&inst, s_private, &none))?;
+            out.push(inst.unbind());
         }
         Ok(out)
     }