topos 0.12.0

An autodiff compiler stack in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//! The acceleration stack's one relation: an implementer may serve
//! a named formula, at a fidelity, against the oracle.
//!
//! Coverage declares *may* — the [`Backend::coverage`] matrix over
//! [`Formula`] and [`Precision`], with a certified [`Fidelity`] per
//! cell. The offer decides *will* — [`offered`] walks a task's
//! declared chain, admitting each member by fidelity-meets-posture, and
//! every member may still decline (thresholds, stride mappings,
//! device presence). The oracle defines *is* — the reference paths
//! are the substrate every decline falls to, in every build; on a
//! build without backend features every offer answers `None`, the
//! seam's fixed point, not dead code. Each task type carries its
//! formula and precision through the crate-internal `Task` contract,
//! so a task can only walk its own chain. Everything here exists in
//! every build: interrogating the stack never needs a `cfg`.

// Every backend module is compiled in every build: it holds the
// always-answering manifest, and keeps its kernels (with their
// scoped `unsafe` allow) behind the feature `cfg` internally.
mod accelerate;
#[allow(clippy::module_inception)]
mod backend;
mod coverage;
mod cuda;
mod formula;
mod fused;
mod manifest;
mod metal;
mod numerics;
mod task;
// Safe stride classification shared by the BLAS-shaped backends;
// compiled exactly where one of them is.
#[cfg(any(
    all(feature = "accelerate", target_os = "macos"),
    all(feature = "cuda", target_os = "linux")
))]
mod operand;
mod simd;
mod stablehlo;

pub use backend::{Backend, BackendUnavailable};
pub use coverage::{Coverage, Dispatch, Fidelity};
pub use formula::{Formula, Precision};
pub use numerics::Numerics;
pub use task::MapTask;

pub(crate) use numerics::NumericsScope;

use task::Task;

/// It offers a task down its formula's chain, answering `None` when
/// every member declines: the chain's one entry point, monomorphized
/// per task type.
///
/// Admission is the fidelity rule, not a posture special case: a chain
/// member serves only if its declared fidelity meets the fidelity the
/// current posture demands, so `Exact` excludes every envelope
/// kernel and would admit a bit-certified one.
pub(crate) fn offered<T: Task>(task: &T) -> Option<T::Product> {
    let required = numerics::current().fidelity();
    T::FORMULA
        .chain(T::PRECISION)
        .iter()
        .filter(|backend| backend.coverage(T::FORMULA).meets(required))
        .find_map(|&backend| task.offer(backend))
}

#[cfg(test)]
#[path = "tests/chain_tests.rs"]
mod tests;