utrace 0.1.1

Instrumentation-based profiling library for embedded targets with async support
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

use utrace_core::encoding::encode;
use utrace_core::encoding::TracePoint;

pub struct Tracer {
    exit_id: Option<u8>,
}

pub enum SkipConfig {
    NoSkip,
    Skip {
        counter: &'static mut u32,
        limit: u32,
    },
}

impl Tracer {
    pub fn new(entry_id: Option<u8>, exit_id: Option<u8>, skip_config: SkipConfig) -> Option<Self> {
        match skip_config {
            SkipConfig::NoSkip => {
                if let Some(id) = entry_id {
                    Self::emit(id);
                }
                Some(Tracer { exit_id })
            }
            SkipConfig::Skip { counter, limit } => {
                *counter += 1;
                if *counter >= limit {
                    if let Some(id) = entry_id {
                        Self::emit(id);
                    }
                    *counter = 0;
                    Some(Tracer { exit_id })
                } else {
                    None
                }
            }
        }
    }

    fn emit(id: u8) {
        critical_section::with(|_| {
            let delta = crate::globals::default_timestamp_delta();
            encode(
                TracePoint { delta_t: delta, id },
                crate::globals::default_write,
            );
        });
    }
}

impl Drop for Tracer {
    fn drop(&mut self) {
        if let Some(id) = self.exit_id {
            Self::emit(id);
        }
    }
}

// Additional Implementations and Debug Trait for better logging
impl core::fmt::Debug for Tracer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Tracer")
            .field("exit_id", &self.exit_id)
            .finish()
    }
}

impl core::fmt::Debug for SkipConfig {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            SkipConfig::NoSkip => write!(f, "NoSkip"),
            SkipConfig::Skip { counter, limit } => f
                .debug_struct("Skip")
                .field("counter", counter)
                .field("limit", limit)
                .finish(),
        }
    }
}