Brummel
cd3d1ca9ed
Motivation
----------
`Scalar` was a tagged enum (I64/F64/Bool/Ts), so every scalar value
physically carried its own kind tag. But the kind is already known from
the schema/port/column the value flows through (C7: the type is a
property of the column, not of the value — the hot path is already
columnar `Column<T>`, and `AnyColumn::get` *reconstructs* the tag from
the column on the way out). The per-value tag was therefore redundant
with the kind the surrounding context already holds.
That redundancy had three costs:
* It baked an implicit `match` (a branch) into every function that read
a Scalar payload — even where the caller statically knew the type.
The tag could never be exploited away.
* Size: a tagged enum is tag + payload = 16 bytes (f64/i64 alignment),
twice the 8 bytes the value needs. A `Column<Scalar>` would be double
the memory and half the cache utilisation.
* It is the shared root of several downstream papercuts we keep hitting
— the lossy f64 manifest field, the `unreachable!` panic on a
non-numeric param, the serde-tag question — all symptoms of "the type
is baked into the value".
Change
------
Introduce `Cell`: a type-erased 64-bit word (`struct Cell(u64)`) that is
not readable without external type context. It is constructed per base
type (`from_i64/from_f64/from_bool/from_ts`) and read only by naming the
type at the call site (`i64()/f64()/bool()/ts()`) — each a branch-free
bit-cast. The hot path resolves the kind once at the boundary (from the
schema) and then reads natively, with no per-value branch. `Cell` knows
nothing of `Scalar` or `ScalarKind`; the dependency is strictly one-way,
and it lives in its own `cell.rs` (more is planned on top of it).
`Scalar` becomes `struct { kind: ScalarKind, cell: Cell }` — the
self-describing form for the dynamic boundaries (builder binding,
serialization, rendering), built on top of `Cell`. Its `as_*` accessors
now `debug_assert` the kind and return the native value (free in
release); calling the wrong accessor is a caller bug, not a checked
`Option`. The variant constructors `Scalar::I64(..)` become associated
fns `Scalar::i64(..)`.
`PartialEq` is hand-written (not derived) to preserve the former enum's
value semantics: kinds must match, then native payloads compare, so f64
keeps IEEE-754 behaviour (`NaN != NaN`, `+0.0 == -0.0`) and a kind
mismatch is never equal even when the raw words coincide. A fixture
(`scalar_eq_is_value_not_bitwise`) pins exactly the cases where bit- and
value-equality diverge, so it can't silently regress. `Cell`'s own
`Eq`/`Hash` stay bitwise — correct for a raw word.
The change is behaviour-preserving: Scalar's observable behaviour is
identical to the pre-Cell enum (the value-equality fixture proves it);
only the internal representation changed. The ~440 call sites across the
workspace are a mechanical constructor rename plus ~12 destructuring
sites (match-arms / `let`-patterns) rewritten to `kind()` + `as_*`.
Verified: cargo build --workspace --all-targets, cargo clippy --workspace
--all-targets -- -D warnings, cargo test --workspace — all green.
48 lines
1.8 KiB
Rust
48 lines
1.8 KiB
Rust
//! `aura-core` — the shared contract every aura component links against.
|
|
//!
|
|
//! This crate is the boundary forced by the cdylib hot-reload model: both the
|
|
//! engine and every hot-reloadable node cdylib depend on it, so it stays small
|
|
//! and stable.
|
|
//!
|
|
//! Delivered so far (cycle 0001 — the streaming substrate):
|
|
//!
|
|
//! - the four scalar base types streamed as SoA: [`Scalar`] / [`ScalarKind`] /
|
|
//! [`Timestamp`] (C7);
|
|
//! - [`Column`] — a fixed-capacity, bounded-lookback ring with financial
|
|
//! indexing (index 0 = newest) and a `run_count` freshness primitive (C5/C8),
|
|
//! read zero-copy through a [`Window`];
|
|
//! - [`AnyColumn`] — the type-erased edge over the four column kinds, with an
|
|
//! edge-time kind check ([`KindMismatch`]) (C7).
|
|
//!
|
|
//! Delivered in cycle 0002 — the node contract:
|
|
//!
|
|
//! - [`Node`] — the `lookbacks`/`eval` contract every node implements (C8); the
|
|
//! static signature ([`NodeSchema`] / [`PortSpec`] declaring input ports by kind
|
|
//! and the output record of [`FieldSpec`] columns; length 1 = scalar) is declared
|
|
//! on the node's [`PrimitiveBuilder`], pre-build;
|
|
//! - [`Ctx`] — the per-`eval` read-side: zero-copy, financial-indexed [`Window`]
|
|
//! access into each input (closing the cycle-0001 read-side gap on
|
|
//! [`AnyColumn`]).
|
|
//!
|
|
//! Still to come (subsequent cycles): the broker-independent
|
|
//! position-event output and downstream broker nodes (C10), and the run registry
|
|
//! (C18/C22).
|
|
|
|
mod any;
|
|
mod cell;
|
|
mod column;
|
|
mod ctx;
|
|
mod error;
|
|
mod node;
|
|
mod scalar;
|
|
|
|
pub use any::AnyColumn;
|
|
pub use cell::Cell;
|
|
pub use column::{Column, Window};
|
|
pub use ctx::Ctx;
|
|
pub use error::KindMismatch;
|
|
pub use node::{
|
|
zip_params, FieldSpec, Firing, Node, NodeSchema, ParamSpec, PortSpec, PrimitiveBuilder,
|
|
};
|
|
pub use scalar::{Scalar, ScalarKind, Timestamp};
|