SKEEP-003 addendum: placement, eager lifetime, and graph-level planning — resolved

Placement joined WeightForm as a resolved decision — a pure function of three inputs, none of which the model author knows:

AllocationResolver.resolve(weight, profile, platform) produces the AllocationSpec; AllocationResolver.explain(…​) renders the same decision with its reason, so a plan can say where every tensor lands and why, before a byte of payload is read. Consumers — the plan (PlanTensor.allocation), the loader (ResolvedGguf), a context — carry and obey; none decide.

Mapping requires all three conditions: the form asks MAPPED, the platform can map, and the bytes really are the file’s bytes — a dequantized or feed-ordered weight is a load-time copy, and a copy cannot be paged from a file it no longer matches. Everything else falls to the profile’s heap/off-heap threshold over the bytes actually held.

No graph is needed. Placement of weights is per-tensor and depends on nothing downstream; activations are a lifetime question (§2), not a device question. Every backend today is CPU; device arbitration policy would be untestable speculation, deferred until a second device exists.

The user always wins. The precedence order, explicit and documented on the loader: per-tensor weightFormFor > uniform weightForm > the resolver (the three legacy parameters were removed outright in #1159). WeightForm(DequantizeTo(FP32), residency = HEAP) — everything dense, on the managed heap — is a supported one-liner, not a fight with the planner.

Deleted, as this SKEEP scheduled: @Place/@Weights (declared, retained, read by nothing — they asked the model author, who does not know the three deciding facts), the dead tensor.storage.MemoryPlanner (name-collided with the live memory.plan.*), StorageSpec, and Placement.Residency. Residency vocabulary reconciled by deletion: lifetime is ScopeKind (MODEL/FORWARD/AMBIENT, enforced by Storage/Scope), weight staging is WeightForm.WeightResidency (HEAP/MAPPED, decided by the resolver). Placement itself stays — the KV-cache stores carry it as device/domain intent.

The Scope split is the mechanism. Eager lifetimes follow call structure — the generation loop knows where a step ends — so ForwardScope.reset() at step boundaries replaces graph liveness analysis: one pre-sized slab, bump allocation, overflow accounting for slab sizing, retain() as the sanctioned escape, and a use-after-reset that throws StorageClosedException instead of corrupting.

What was missing was any reader of ExecutionContext.memoryScope. The creation path is now that reader: zeros/ones/full/fromFloatArray draw dense-FP32 bytes from the active scope (StorageFloatTensorData), opt-in via ctx.forwardScope(slabFloats) { scoped, scope → … }, with Scope.Ambient — the default everywhere — byte-for-byte the old path.

Two boundaries held on purpose:

Op outputs draw from the active scope too since #1146 (TensorDataFactory.adoptFloatArray, ScopedTensorDataFactory), with offset-aware FP32 fast paths and Panama vector kernels (#1173) so slab-backed tensors keep SIMD speed.

On the recorded path (tape → ComputeGraph → StableHLO text + .irpa), iree-compile performs buffer allocation, liveness and scheduling on the very MLIR SKaiNET emits — and it does so after fusion and layout decisions SKaiNET cannot see, so an upstream planner’s liveness answers would be invalidated by the consumer. Meanwhile nothing in this repository executes IREE at all: the integration is a format contract (text-shape assertions in tests, IrpaWriter for the weights sidecar), with compilation and execution in external tooling.

Resolution: core decides and carries; planning stays downstream. Decisions made by core resolvers (WeightFormResolver, AllocationResolver) must survive to the MLIR so the downstream compiler can honour them — that is carriage, not planning.

The carry work landed as the #1178/#1179/#1180 arc (0.49.0): TensorRef carries identity, encoding and block order; TensorSpec metadata accessors follow the untyped precedent; the structural skainet.tensor_layouts module attribute and ExternalParameterRef.blockOrder declare the facts to the consumer; and LayoutAssignmentPass runs on the production path via HloGenerator.generate(target = …), populating the pre-built ResolvedComputeGraph seams. Until the conformity pipeline exists (#1148, the future IREE-validation SKEEP), the carriage tests are the metadata’s reader.

The SKEEP-003 items "`StorageSpec`, MemoryPlanner and the annotations are deleted unless wired" and "one planner per context, consulted by the creation path" are both discharged — the first by #1142, the second in the resolver-owned form described above (a per-context planner object turned out to be the wrong shape; a stateless resolver plus the context’s scope covers both halves).