hermit-verify 0.4.0

Run-to-run verification harness for the Hermit deterministic execution engine.
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
114
115
116
117
118

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree.
 */

use std::path::Path;

use detcore::preemptions::PreemptionReader;
use detcore_model::collections::ReplayCursor;
use detcore_model::schedule::Op;
use detcore_model::schedule::SchedEvent;
use detcore_model::time::LogicalTime;

fn split_one(event: SchedEvent) -> Vec<SchedEvent> {
    let first_count = event.count / 2;
    let second_count = event.count - first_count;

    let first_end_time = event.end_time.map(|t| {
        LogicalTime::from_nanos((t.as_nanos() as i64 - 10i64 * second_count as i64) as u64)
    });

    vec![
        SchedEvent {
            count: first_count,
            op: Op::Branch,
            end_time: first_end_time,
            start_rip: None,
            end_rip: None,
            ..event
        },
        SchedEvent {
            count: second_count,
            op: Op::Branch,
            start_rip: None,
            end_rip: None,
            ..event
        },
    ]
}

fn split_branches(
    event: SchedEvent,
    cursor: &ReplayCursor<SchedEvent>,
) -> impl IntoIterator<Item = SchedEvent> + use<> {
    match (&event, cursor.peek_nth(0), cursor.peek_nth(1)) {
        (
            SchedEvent {
                op: Op::Branch,
                count,
                ..
            },
            Some(SchedEvent {
                op: Op::OtherInstructions,
                ..
            }),
            Some(SchedEvent { op: Op::Branch, .. }),
        )
        | (
            SchedEvent {
                op: Op::Branch,
                count,
                ..
            },
            Some(SchedEvent { op: Op::Branch, .. }),
            _,
        ) if *count > 1 => split_one(event),
        _ => vec![event],
    }
}

pub fn split_branches_in_file(from_file: impl AsRef<Path>, backup: bool) -> anyhow::Result<()> {
    let mut preemptions = PreemptionReader::new(from_file.as_ref()).into_inner();
    preemptions.split_map(split_branches);

    if backup {
        let mut new_name = from_file.as_ref().to_path_buf();
        new_name.set_extension("bak");
        std::fs::rename(&from_file, &new_name)?;
    }

    preemptions
        .write_to_disk(from_file.as_ref())
        .map_err(anyhow::Error::msg)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use detcore::types::DetPid;
    use detcore::types::LogicalTime;
    use detcore::types::Op;
    use detcore::types::SchedEvent;
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    pub fn test_split_one() {
        let event = SchedEvent {
            count: 3,
            dettid: DetPid::from_raw(3),
            end_time: Some(LogicalTime::from_nanos(10000)),
            op: Op::Branch,
            start_rip: None,
            end_rip: None,
        };

        let counts: Vec<_> = split_one(event)
            .into_iter()
            .map(|x| (x.op, x.count, x.end_time.unwrap().as_nanos()))
            .collect();

        assert_eq!(counts, vec![(Op::Branch, 1, 9980), (Op::Branch, 2, 10000)]);
    }
}