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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::{Backend, Coverage, Dispatch, Fidelity, Formula, Numerics, Precision};

#[test]
fn the_matrix_pins_every_hardware_row() {
    // Accelerate is the one hardware implementer with kernels for
    // both leaf formulas and the batch-norm task, at both
    // precisions.
    for precision in Precision::ALL {
        assert!(Backend::Accelerate.serves(Formula::Gemm, *precision));
        assert!(Backend::Accelerate.serves(Formula::Map, *precision));
        assert!(Backend::Accelerate.serves(Formula::BatchNormTraining, *precision));
        assert!(
            !Backend::Accelerate
                .coverage(Formula::BatchNormTraining)
                .meets(Fidelity::BitIdentical)
        );
    }
    // Metal has no `f64` at all.
    assert!(Backend::Metal.serves(Formula::Gemm, Precision::F32));
    assert!(Backend::Metal.serves(Formula::Map, Precision::F32));
    assert!(!Backend::Metal.serves(Formula::Gemm, Precision::F64));
    assert!(!Backend::Metal.serves(Formula::Map, Precision::F64));
    // The gemm-only rungs.
    for backend in [Backend::Cuda, Backend::Simd] {
        for precision in Precision::ALL {
            assert!(backend.serves(Formula::Gemm, *precision));
            assert!(!backend.serves(Formula::Map, *precision));
        }
    }
    // No other hardware implementer serves a composed formula, and
    // nobody but the translation column serves the raise-only ones.
    for backend in [
        Backend::Accelerate,
        Backend::Metal,
        Backend::Cuda,
        Backend::Simd,
    ] {
        for formula in [
            Formula::WindowProduct,
            Formula::ReduceWindow,
            Formula::BatchNormInference,
        ] {
            assert_eq!(backend.coverage(formula), Coverage::Absent);
        }
    }
    for backend in [Backend::Metal, Backend::Cuda, Backend::Simd] {
        assert_eq!(
            backend.coverage(Formula::BatchNormTraining),
            Coverage::Absent
        );
    }
}

#[test]
fn fused_serves_its_kernels_bit_identically() {
    // Every in-process kernel either reduces in the recorded order
    // or falls back to composing the recorded formula, so every cell
    // clears bit identity; the envelope enters only through an
    // admitted hardware kernel.
    for formula in [
        Formula::WindowProduct,
        Formula::ReduceWindow,
        Formula::BatchNormTraining,
    ] {
        assert_eq!(
            Backend::Fused.coverage(formula),
            Coverage::Serves {
                fidelity: Fidelity::BitIdentical,
                precisions: Precision::ALL
            }
        );
    }
    for formula in [Formula::Gemm, Formula::Map, Formula::BatchNormInference] {
        assert_eq!(Backend::Fused.coverage(formula), Coverage::Absent);
    }
}

#[test]
fn the_stablehlo_column_is_total() {
    // Emission's repertoire reads this column; totality here is what
    // keeps every pattern raising on every posture.
    for formula in Formula::ALL {
        let cell = Backend::StableHlo.coverage(*formula);
        assert!(cell.serves(), "{formula:?} does not lower");
        assert!(!cell.meets(Fidelity::BitIdentical));
    }
}

#[test]
fn the_fidelity_rule_is_one_comparison() {
    assert!(Fidelity::BitIdentical.meets(Fidelity::BitIdentical));
    assert!(Fidelity::BitIdentical.meets(Fidelity::Envelope));
    assert!(Fidelity::Envelope.meets(Fidelity::Envelope));
    assert!(!Fidelity::Envelope.meets(Fidelity::BitIdentical));
    // The postures demand exactly the two fidelities.
    assert_eq!(Numerics::Exact.fidelity(), Fidelity::BitIdentical);
    assert_eq!(Numerics::Fast.fidelity(), Fidelity::Envelope);
}

#[test]
fn dispatch_names_each_execution_context() {
    for backend in [
        Backend::Accelerate,
        Backend::Metal,
        Backend::Cuda,
        Backend::Simd,
    ] {
        assert_eq!(backend.dispatch(), Dispatch::Offered);
    }
    assert_eq!(Backend::Fused.dispatch(), Dispatch::Elected);
    assert_eq!(Backend::StableHlo.dispatch(), Dispatch::Translated);
}