trellis-runner 0.2.1

Calculation runner
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

use crate::engine::EngineSignal;
use crate::progress::Progress;
use crate::state::StateView;
use crate::watchers::Observe;

use num_traits::float::FloatCore;
use std::sync::Mutex;

pub struct MetricsObserver<F> {
    inner: Mutex<MetricsState<F>>,
}

/// Aggregates run-level statistics into a final summary.
///
/// This observer is useful for post-run analysis and benchmarking.
#[derive(Clone)]
pub struct MetricsState<F> {
    best_metric: Option<F>,
    last_metric: Option<F>,

    best_absolute: Option<F>,
    best_relative: Option<F>,

    iterations: usize,
}

impl<F> Default for MetricsState<F> {
    fn default() -> Self {
        Self {
            best_metric: None,
            last_metric: None,
            best_absolute: None,
            best_relative: None,
            iterations: 0,
        }
    }
}

#[derive(Debug, Clone)]
pub struct RunSummary<F> {
    pub iterations: usize,
    pub best_metric: Option<F>,
    pub last_metric: Option<F>,
    pub best_absolute: Option<F>,
    pub best_relative: Option<F>,
}

impl<F> MetricsObserver<F>
where
    F: Copy + PartialOrd,
{
    pub fn new() -> Self {
        Self {
            inner: Mutex::new(MetricsState::default()),
        }
    }

    pub fn summary(self) -> RunSummary<F> {
        let inner = self.inner.lock().unwrap();
        RunSummary {
            iterations: inner.iterations,
            best_metric: inner.best_metric,
            last_metric: inner.last_metric,
            best_absolute: inner.best_absolute,
            best_relative: inner.best_relative,
        }
    }
}

impl<S> Observe<S> for MetricsObserver<S::Float>
where
    S: crate::UserState,
    S::Float: FloatCore + Send + Sync,
{
    fn observe(&self, _: &'static str, state: StateView<'_, S>, event: &EngineSignal<S::Float>) {
        let mut inner = self.inner.lock().unwrap();
        if let EngineSignal::Progress(progress) = event {
            inner.iterations = state.iteration();

            match progress {
                Progress::Measure(measure) => {
                    inner.last_metric = Some(*measure);

                    inner.best_metric = match inner.best_metric {
                        Some(best) if best <= *measure => Some(best),
                        _ => Some(*measure),
                    };
                }

                Progress::Report {
                    diagnostics,
                    measure,
                } => {
                    inner.last_metric = Some(*measure);

                    inner.best_metric = match inner.best_metric {
                        Some(best) if best <= *measure => Some(best),
                        _ => Some(*measure),
                    };

                    if let Some(a) = diagnostics.absolute_error {
                        inner.best_absolute = Some(inner.best_absolute.map_or(a, |b| b.min(a)));
                    }
                    if let Some(r) = diagnostics.relative_error {
                        inner.best_relative = Some(inner.best_relative.map_or(r, |b| b.min(r)));
                    }
                }

                Progress::Complete => {}
            }
        }
    }
}