refactor(aura-core): split Scalar into a tag-free Cell + ScalarKind
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.
This commit is contained in:
@@ -217,18 +217,18 @@ mod tests {
|
||||
let grid = GridSpace::new(
|
||||
&space,
|
||||
vec![
|
||||
vec![Scalar::I64(2), Scalar::I64(3)],
|
||||
vec![Scalar::I64(4), Scalar::I64(5)],
|
||||
vec![Scalar::i64(2), Scalar::i64(3)],
|
||||
vec![Scalar::i64(4), Scalar::i64(5)],
|
||||
],
|
||||
)
|
||||
.expect("valid grid");
|
||||
assert_eq!(
|
||||
grid.points(),
|
||||
vec![
|
||||
vec![Scalar::I64(2), Scalar::I64(4)],
|
||||
vec![Scalar::I64(2), Scalar::I64(5)],
|
||||
vec![Scalar::I64(3), Scalar::I64(4)],
|
||||
vec![Scalar::I64(3), Scalar::I64(5)],
|
||||
vec![Scalar::i64(2), Scalar::i64(4)],
|
||||
vec![Scalar::i64(2), Scalar::i64(5)],
|
||||
vec![Scalar::i64(3), Scalar::i64(4)],
|
||||
vec![Scalar::i64(3), Scalar::i64(5)],
|
||||
],
|
||||
);
|
||||
}
|
||||
@@ -243,9 +243,9 @@ mod tests {
|
||||
let grid = GridSpace::new(
|
||||
&space,
|
||||
vec![
|
||||
vec![Scalar::I64(2), Scalar::I64(3)],
|
||||
vec![Scalar::I64(4), Scalar::I64(5)],
|
||||
vec![Scalar::F64(0.5)],
|
||||
vec![Scalar::i64(2), Scalar::i64(3)],
|
||||
vec![Scalar::i64(4), Scalar::i64(5)],
|
||||
vec![Scalar::f64(0.5)],
|
||||
],
|
||||
)
|
||||
.expect("valid grid");
|
||||
@@ -256,14 +256,14 @@ mod tests {
|
||||
#[test]
|
||||
fn arity_mismatch_is_an_error() {
|
||||
let space = i64_space(2);
|
||||
let err = GridSpace::new(&space, vec![vec![Scalar::I64(2)]]).unwrap_err();
|
||||
let err = GridSpace::new(&space, vec![vec![Scalar::i64(2)]]).unwrap_err();
|
||||
assert_eq!(err, SweepError::Arity { expected: 2, got: 1 });
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_kind_is_a_kind_mismatch() {
|
||||
let space = i64_space(1);
|
||||
let err = GridSpace::new(&space, vec![vec![Scalar::F64(1.0)]]).unwrap_err();
|
||||
let err = GridSpace::new(&space, vec![vec![Scalar::f64(1.0)]]).unwrap_err();
|
||||
assert_eq!(
|
||||
err,
|
||||
SweepError::KindMismatch {
|
||||
@@ -312,9 +312,9 @@ mod tests {
|
||||
GridSpace::new(
|
||||
&space,
|
||||
vec![
|
||||
vec![Scalar::I64(2), Scalar::I64(3)], // fast ∈ {2, 3}
|
||||
vec![Scalar::I64(4), Scalar::I64(5)], // slow ∈ {4, 5}
|
||||
vec![Scalar::F64(0.5)], // scale ∈ {0.5}
|
||||
vec![Scalar::i64(2), Scalar::i64(3)], // fast ∈ {2, 3}
|
||||
vec![Scalar::i64(4), Scalar::i64(5)], // slow ∈ {4, 5}
|
||||
vec![Scalar::f64(0.5)], // scale ∈ {0.5}
|
||||
],
|
||||
)
|
||||
.expect("grid matches the sample param-space")
|
||||
@@ -328,11 +328,11 @@ mod tests {
|
||||
// params carried in enumeration (odometer) order, self-describing
|
||||
assert_eq!(
|
||||
family.points[0].params,
|
||||
vec![Scalar::I64(2), Scalar::I64(4), Scalar::F64(0.5)],
|
||||
vec![Scalar::i64(2), Scalar::i64(4), Scalar::f64(0.5)],
|
||||
);
|
||||
assert_eq!(
|
||||
family.points[3].params,
|
||||
vec![Scalar::I64(3), Scalar::I64(5), Scalar::F64(0.5)],
|
||||
vec![Scalar::i64(3), Scalar::i64(5), Scalar::f64(0.5)],
|
||||
);
|
||||
// each point's metrics equal a direct, independent run of the same point:
|
||||
// the sweep adds enumeration + execution, never a metrics change (C1).
|
||||
@@ -361,7 +361,7 @@ mod tests {
|
||||
.map(|(ps, v)| (ps.name, v))
|
||||
.collect();
|
||||
assert_eq!(family.named_params(0), expected);
|
||||
assert_eq!(family.named_params(0)[0].1, Scalar::I64(2));
|
||||
assert_eq!(family.named_params(0)[0].1, Scalar::i64(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
Reference in New Issue
Block a user