bimm-contracts 0.2.0

Runtime contracts for the bimm framework
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

use crate::{DimExpr, DimMatcher, ShapeContract, run_every_nth};
use test::Bencher;

static PATTERN: ShapeContract = ShapeContract::new(&[
    DimMatcher::any(),
    DimMatcher::expr(DimExpr::Param("b")),
    DimMatcher::ellipsis(),
    DimMatcher::expr(DimExpr::Prod(&[DimExpr::Param("h"), DimExpr::Param("p")])),
    DimMatcher::expr(DimExpr::Prod(&[DimExpr::Param("w"), DimExpr::Param("p")])),
    DimMatcher::expr(DimExpr::Pow(&DimExpr::Param("z"), 3)),
    DimMatcher::expr(DimExpr::Param("c")),
]);

static BATCH: usize = 2;
static HEIGHT: usize = 3;
static WIDTH: usize = 2;
static PADDING: usize = 4;
static CHANNELS: usize = 5;
static COLOR: usize = 4;

#[bench]
fn bench_unpack_shape(b: &mut Bencher) {
    let shape = [
        12,
        BATCH,
        1,
        2,
        3,
        HEIGHT * PADDING,
        WIDTH * PADDING,
        COLOR * COLOR * COLOR,
        CHANNELS,
    ];
    let env = [("p", PADDING), ("c", CHANNELS)];

    b.iter(|| {
        let [b, h, w, c] = PATTERN.unpack_shape(&shape, &["b", "h", "w", "z"], &env);

        assert_eq!(b, BATCH);
        assert_eq!(h, HEIGHT);
        assert_eq!(w, WIDTH);
        assert_eq!(c, COLOR);
    });
}

#[bench]
fn bench_assert_shape(b: &mut Bencher) {
    let shape = [
        12,
        BATCH,
        1,
        2,
        3,
        HEIGHT * PADDING,
        WIDTH * PADDING,
        COLOR * COLOR * COLOR,
        CHANNELS,
    ];
    let env = [("p", PADDING), ("c", CHANNELS)];

    b.iter(|| {
        PATTERN.assert_shape(&shape, &env);
    });
}

#[bench]
fn bench_assert_shape_every_nth(b: &mut Bencher) {
    let shape = [
        12,
        BATCH,
        1,
        2,
        3,
        HEIGHT * PADDING,
        WIDTH * PADDING,
        COLOR * COLOR * COLOR,
        CHANNELS,
    ];
    let env = [("p", PADDING), ("c", CHANNELS)];

    b.iter(|| {
        run_every_nth!(PATTERN.assert_shape(&shape, &env));
    });
}