xentrace-parser 2.1.0

A XenTrace files parser with a study purpose
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

mod code;

use std::cmp::Ordering;

pub use self::code::EventCode;

/// Maximum value of an event's list of additional information.
pub const EVENT_EXTRA_CAPACITY: usize = 7;

/// Contains the information of a single event.
/// It is a sub-structure of [`Record`](super::Record).
#[derive(Clone, Debug, Eq)]
pub struct Event {
    /// The [code](ecode::EventCode) of the event.
    pub(crate) code: EventCode,
    /// The timestamp of the event (the value of the CPU cycle counter).
    pub(crate) tsc: u64,
    /// The list of additional event information (at most [`EVENT_EXTRA_MAXLEN`](super::EVENT_EXTRA_MAXLEN) items).
    pub(crate) extra: [Option<u32>; EVENT_EXTRA_CAPACITY],
}

impl Event {
    /// Returns the [code](ecode::EventCode) of the event.
    pub fn code(&self) -> EventCode {
        self.code
    }

    /// Returns the timestamp of the event (the value of the CPU cycle counter).
    pub fn tsc(&self) -> u64 {
        self.tsc
    }

    /// Returns the list of additional event information (maximum [`EVENT_EXTRA_MAXLEN`](super::EVENT_EXTRA_MAXLEN) items).
    pub fn extra(&self) -> &[Option<u32>; EVENT_EXTRA_CAPACITY] {
        &self.extra
    }
}

impl PartialEq for Event {
    fn eq(&self, other: &Self) -> bool {
        self.code == other.code && self.tsc == other.tsc && self.extra == other.extra
    }
}

impl Ord for Event {
    fn cmp(&self, other: &Self) -> Ordering {
        self.tsc.cmp(&other.tsc)
    }
}

impl PartialOrd for Event {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

#[cfg(test)]
mod tests {
    use super::{Event, EventCode, EVENT_EXTRA_CAPACITY};

    #[test]
    fn equality_test() {
        let event1 = Event {
            code: EventCode::from(0x00015003),
            tsc: 0,
            extra: [None; EVENT_EXTRA_CAPACITY],
        };
        let event2 = Event {
            code: EventCode::from(0x00015003),
            tsc: 0,
            extra: [None; EVENT_EXTRA_CAPACITY],
        };

        assert_eq!(event1, event2);
    }

    #[test]
    fn sorting_test() {
        let mut events = vec![
            Event {
                code: EventCode::from(0x00015004),
                tsc: 4,
                extra: [None; EVENT_EXTRA_CAPACITY],
            },
            Event {
                code: EventCode::from(0x00015001),
                tsc: 0,
                extra: [None; EVENT_EXTRA_CAPACITY],
            },
            Event {
                code: EventCode::from(0x00015003),
                tsc: 98,
                extra: [None; EVENT_EXTRA_CAPACITY],
            },
        ];

        events.sort_unstable();

        let first_event = Event {
            code: EventCode::from(0x00015001),
            tsc: 0,
            extra: [None; EVENT_EXTRA_CAPACITY],
        };
        let last_event = &events[2];

        assert_eq!(0x00015003u32, last_event.code);
        assert_eq!(u32::from(first_event.code), 0x00015001);
    }
}