one_collect 0.1.34811

Cross-platform library for capturing machine-level traces.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

use one_collect::helpers::dotnet::*;

use one_collect::helpers::exporting::*;
use one_collect::helpers::exporting::graph::*;
use one_collect::helpers::exporting::formats::perf_view::*;

fn main() {
    let args: Vec<_> = std::env::args().collect();

    if args.len() == 1 {
        println!("Usage: {} <output_directory>", args[0]);
        return;
    }

    let out_dir = &args[1];

    let duration = std::time::Duration::from_secs(5);

    let settings = ExportSettings::default()
        .with_cpu_profiling(1000)
        .with_cswitches();

    let dotnet = UniversalDotNetHelper::default()
        .with_dynamic_symbols();

    let universal = UniversalExporter::new(settings)
        .with_dotnet_help(dotnet);

    println!("Capturing...");
    let exporter = universal.parse_for_duration("perf_export", duration)
        .expect("Check permissions.");

    let mut exporter = exporter.borrow_mut();

    exporter.capture_and_resolve_symbols();

    println!("Exporting...");

    /* Split by comm name */
    let comm_map = exporter.split_processes_by_comm();

    let cpu = exporter.find_sample_kind("cpu").expect("CPU sample kind should be known.");
    let cswitch = exporter.find_sample_kind("cswitch").expect("CSwitch sample kind should be known.");

    let mut graph = ExportGraph::new();
    let mut buf: String;

    for (comm_id, pids) in comm_map {
        match comm_id {
            None => {
                for pid in pids {
                    let single_pid = vec![pid];

                    let path = format!("{}/t.Unknown.{}.CPU.PerfView.xml", out_dir, pid);

                    export_pids(
                        &exporter,
                        &mut graph,
                        &single_pid,
                        cpu,
                        &path,
                        "CPU Samples");

                    let path = format!("{}/t.Unknown.{}.CSwitch.PerfView.xml", out_dir, pid);

                    export_pids(
                        &exporter,
                        &mut graph,
                        &single_pid,
                        cswitch,
                        &path,
                        "Wait Time");
                }
            },
            Some(comm_id) => {
                /* Merge by name */
                let comm = match exporter.strings().from_id(comm_id) {
                    Ok(comm) => {
                        if comm.contains(":") || comm.contains("/") {
                            buf = comm.replace(":", "_").replace("/", "_");
                            &buf
                        } else {
                            comm
                        }
                    },
                    Err(_) => { "Unknown" },
                };

                let path = format!("{}/t.{}.CPU.PerfView.xml", out_dir, comm);

                export_pids(
                    &exporter,
                    &mut graph,
                    &pids,
                    cpu,
                    &path,
                    "CPU Samples");

                let path = format!("{}/t.{}.CSwitch.PerfView.xml", out_dir, comm);

                export_pids(
                    &exporter,
                    &mut graph,
                    &pids,
                    cswitch,
                    &path,
                    "Wait Time");
            }
        }
    }
}

fn export_pids(
    exporter: &ExportMachine,
    graph: &mut ExportGraph,
    pids: &[u32],
    kind: u16,
    path: &str,
    sample_desc: &str) {
    graph.reset();

    for pid in pids {
        let process = exporter.find_process(*pid).expect("PID should be found.");

        graph.add_samples(
            &exporter,
            process,
            kind,
            None);
    }

    let total = graph.nodes()[graph.root_node()].total();

    if total != 0 {
        graph.to_perf_view_xml(path).expect("Export should work.");

        println!("{}: {} {}", path, total, sample_desc);
    }
}