SolitaryThinker
2f044c02dd
Add v2/platform/: the (recipe, runtime) backend membrane that lets CPU, GPU, and other devices coexist behind one dispatch substrate. - Two tuple-keyed registries: COMPONENTS(kind, device, variant) for weight-bearing components and KERNELS(op, device, arch, variant) for stateless primitives, each with an availability predicate and an enumerable manifest (declared-but-unavailable cells listed without importing torch). - Platform: detected (device, arch) owning the device + arch fallback chains and a per-platform cached KernelTable; detect() is honest (CPU/numpy unless torch+CUDA are actually present). Arch fallback is monotonic — only degrades to older/portable archs, never a newer binary-incompatible one. - Seams wired: ModelInstance.component() -> platform.build_component(spec,self) with spec.factory as the numpy terminal rung (existing cards untouched); the wan21 denoise thunk dispatches solver ops through model.platform.kernels. - Three backends: cpu (numpy terminal + parity oracle), accel (pure-python stand-in proving cross-device resolution, arch fallback, and the oracle), torch_cuda (declared-but-unavailable; no faked GPU). - test_platform.py: 16 tests — detection, terminal rung, arch-fallback walk + monotonicity, device precedence, variant fallback, component override + per-kind device fallback, the parity oracle (accel == cpu, bit_identical via the C1 ladder), and matrix enumeration without importing torch. Scope is honestly bounded in the README/docstrings: only wan21-denoise routes through the kernel table and only the dit kind is overridden today (each a one-line adoption); the torch/CUDA path and a cudagraph workspace-safety contract are declared/deferred, not implemented. 183 tests pass.
23 lines
1.3 KiB
Python
23 lines
1.3 KiB
Python
"""CPU / numpy backend — the terminal rung and parity oracle (design_v3 §17).
|
|
|
|
This backend registers the numpy reference kernels. It is the bottom of every device fallback
|
|
chain: any op a richer backend hasn't implemented resolves here, and every other backend's output
|
|
is checked against this one (the consistency ladder's C0/C1 oracle).
|
|
|
|
Components are NOT registered here: the card's ``ComponentSpec.factory`` *is* the cpu/numpy
|
|
component rung (``Platform.build_component`` falls back to it when no ``(kind, device, …)`` cell
|
|
matches). That keeps every existing card working with zero registration.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from ...loop.sampler import flow_match_euler_step, flow_sde_step_with_logprob
|
|
from ..registry import FLOW_MATCH_STEP, FLOW_SDE_STEP, register_kernel
|
|
|
|
# The numpy solver primitives, registered as the terminal (cpu, numpy) kernels. These are the exact
|
|
# same functions the loops used to call directly — so dispatching through the registry on a CPU box
|
|
# is bit-for-bit identical to the pre-registry behavior.
|
|
register_kernel(FLOW_MATCH_STEP, flow_match_euler_step,
|
|
device="cpu", arch="numpy", source="loop.sampler:flow_match_euler_step")
|
|
register_kernel(FLOW_SDE_STEP, flow_sde_step_with_logprob,
|
|
device="cpu", arch="numpy", source="loop.sampler:flow_sde_step_with_logprob")
|