zhc_utils 0.8.2

Shared utilities for the ZHC compiler
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

use serde::Serialize;
use serde_json::Value;
use std::collections::HashMap;

use super::*;

#[derive(Serialize, Debug, Clone, Default)]
pub struct Trace {
    #[serde(rename = "traceEvents")]
    pub trace_events: Vec<Event>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "displayTimeUnit")]
    pub display_time_unit: Option<Unit>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "stackFrames")]
    pub stack_frames: Option<HashMap<String, Value>>,
}

impl Trace {
    pub fn new_instant<S: AsRef<str>>(
        &mut self,
        timestamp: Microseconds,
        pid: Pid,
        tid: Tid,
        name: S,
        args: Option<Value>,
        scope: Scope,
    ) {
        self.trace_events.push(Event::Instant(InstantEvent {
            name: name.as_ref().into(),
            timestamp,
            pid,
            tid,
            scope,
            args,
            ..InstantEvent::default()
        }));
    }

    pub fn new_complete<S: AsRef<str>>(
        &mut self,
        timestamp: Microseconds,
        pid: Pid,
        tid: Tid,
        name: S,
        args: Option<Value>,
        duration: Microseconds,
    ) {
        self.trace_events.push(Event::Complete(CompleteEvent {
            name: name.as_ref().into(),
            timestamp,
            duration,
            pid,
            tid,
            args,
            ..CompleteEvent::default()
        }));
    }

    pub fn set_thread_name<S: AsRef<str>>(&mut self, pid: Pid, tid: Tid, name: S) {
        self.trace_events.push(Event::Metadata(MetadataEvent {
            name: Metadata::ThreadName,
            pid,
            tid,
            args: MetadataArgs::ThreadName {
                name: name.as_ref().into(),
            },
            ..MetadataEvent::default()
        }));
    }

    pub fn set_process_name<S: AsRef<str>>(&mut self, pid: Pid, name: S) {
        self.trace_events.push(Event::Metadata(MetadataEvent {
            name: Metadata::ProcessName,
            pid,
            args: MetadataArgs::ProcessName {
                name: name.as_ref().into(),
            },
            ..MetadataEvent::default()
        }));
    }

    pub fn new_counter<S: AsRef<str>>(
        &mut self,
        timestamp: Microseconds,
        pid: Pid,
        tid: Tid,
        name: S,
        args: Option<Value>,
    ) {
        self.trace_events.push(Event::Counter(CounterEvent {
            name: name.as_ref().into(),
            ph: PhC,
            timestamp,
            pid,
            tid,
            args,
            ..CounterEvent::default()
        }));
    }
}