vize_l3 0.608.0

L3 - the Davinci reactivity IR (codename Impeto): flat scheduled ops with explicit state and effect edges
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
113

//! The pinned multi-metric commit rule, judged directly.

use vize_l3::extract::{
    Metric, Metrics, OptTier, OptimizationBudget, Rejection, TiePolicy, epsilon_pct, judge,
};

const BASE: Metrics = Metrics {
    emitted_size: 200,
    reactive_edges: 10,
    update_path: 20,
};

fn metrics(emitted_size: u64, reactive_edges: u64, update_path: u64) -> Metrics {
    Metrics {
        emitted_size,
        reactive_edges,
        update_path,
    }
}

fn loosened(size: u32, edges: u32, path: u32, required: u32) -> OptimizationBudget {
    OptimizationBudget {
        tier: OptTier::O3,
        candidate_budget: 128,
        emitted_size_epsilon_pct: size,
        reactive_edge_epsilon_pct: edges,
        update_path_epsilon_pct: path,
        required_improvements_min: required,
        tie_policy: TiePolicy::Reject,
    }
}

#[test]
fn pinned_tiers_commit_only_pareto_improvements() {
    for tier in [OptTier::O1, OptTier::O2, OptTier::O3] {
        let budget = tier.budget();
        assert_eq!(judge(BASE, metrics(199, 10, 20), &budget), Ok(()));
        assert_eq!(judge(BASE, metrics(200, 9, 20), &budget), Ok(()));
        assert_eq!(judge(BASE, metrics(200, 10, 19), &budget), Ok(()));
        assert_eq!(judge(BASE, BASE, &budget), Err(Rejection::NoImprovement));
        assert_eq!(
            judge(BASE, metrics(201, 9, 19), &budget),
            Err(Rejection::Regressed(Metric::EmittedSize))
        );
        assert_eq!(
            judge(BASE, metrics(150, 11, 19), &budget),
            Err(Rejection::Regressed(Metric::ReactiveEdge))
        );
        assert_eq!(
            judge(BASE, metrics(150, 9, 21), &budget),
            Err(Rejection::Regressed(Metric::UpdatePath))
        );
    }
}

#[test]
fn constraints_are_judged_before_the_objective() {
    let budget = OptTier::O2.budget();
    assert_eq!(
        judge(BASE, metrics(300, 11, 30), &budget),
        Err(Rejection::Regressed(Metric::ReactiveEdge))
    );
    assert_eq!(
        judge(BASE, metrics(300, 10, 30), &budget),
        Err(Rejection::Regressed(Metric::UpdatePath))
    );
}

#[test]
fn o0_still_rejects_ties() {
    let budget = OptTier::O0.budget();
    assert_eq!(judge(BASE, BASE, &budget), Err(Rejection::NoImprovement));
    assert_eq!(judge(BASE, metrics(199, 10, 20), &budget), Ok(()));
}

#[test]
fn an_epsilon_admits_a_regression_up_to_its_floor_percentage() {
    let budget = loosened(10, 0, 0, 1);
    assert_eq!(judge(BASE, metrics(220, 9, 20), &budget), Ok(()));
    assert_eq!(
        judge(BASE, metrics(221, 9, 20), &budget),
        Err(Rejection::Regressed(Metric::EmittedSize))
    );
    let budget = loosened(0, 15, 0, 1);
    assert_eq!(judge(BASE, metrics(199, 11, 20), &budget), Ok(()));
    assert_eq!(
        judge(BASE, metrics(199, 12, 20), &budget),
        Err(Rejection::Regressed(Metric::ReactiveEdge))
    );
}

#[test]
fn required_improvements_count_strict_gains_only() {
    let budget = loosened(0, 0, 0, 2);
    assert_eq!(
        judge(BASE, metrics(199, 10, 20), &budget),
        Err(Rejection::NoImprovement)
    );
    assert_eq!(judge(BASE, metrics(199, 9, 20), &budget), Ok(()));
}

#[test]
fn epsilons_are_read_per_metric() {
    let budget = loosened(1, 2, 3, 1);
    assert_eq!(
        Metric::CHECK_ORDER.map(|metric| (metric, epsilon_pct(&budget, metric))),
        [
            (Metric::ReactiveEdge, 2),
            (Metric::UpdatePath, 3),
            (Metric::EmittedSize, 1),
        ]
    );
}