Struct TotalTimeProfiler

Source

pub struct TotalTimeProfiler<Reporter> { /* private fields */ }

Expand description

A simple basic profiler implementation which tracks the accumulative time and calls a handler function with it.

§Example

use dpc_pariter::{IteratorExt, TotalTimeProfiler};

dpc_pariter::scope(|scope| {
    (0..22)
        .readahead_scoped_profiled(
            scope,
            TotalTimeProfiler::periodically_millis(10_000, || eprintln!("Blocked on sending")),
            TotalTimeProfiler::periodically_millis(10_000, || eprintln!("Blocked on receving")),
        )
        .for_each(|i| {
            println!("{i}");
        })
})
.expect("thread panicked");

Implementations§

Source §

impl<F> TotalTimeProfiler<F>
where F: for<'a> Fn(&'a mut TotalTimeStats),

Source

pub fn new(f: F) -> TotalTimeProfiler<F>

Create a TotalTimeProfiler with any handle

§Example

use dpc_pariter::{IteratorExt, TotalTimeProfiler};

let profiler = TotalTimeProfiler::new(|stats| eprintln!("accumulative sending time so far: {}", stats.total().as_millis()));

Examples found in repository ?

examples/simple_profiler.rs (lines 68-73)

55fn main() {
56    dpc_pariter::scope(|scope| {
57        (0..22)
58            .map(|i| {
59                // make producting values slow
60                std::thread::sleep(time::Duration::from_millis(10));
61                i
62            })
63            .readahead_scoped_profiled(
64                scope,
65                dpc_pariter::TotalTimeProfiler::periodically_millis(2_000, || {
66                    eprintln!("Blocked on sending")
67                }),
68                dpc_pariter::TotalTimeProfiler::new(|stat| {
69                    eprintln!(
70                        "Sending receiving wait time: {}ms",
71                        stat.total().as_millis()
72                    )
73                }),
74            )
75            .for_each(|i| {
76                println!("{i}");
77            })
78    })
79    .expect("thread panicked");
80
81    (0..22)
82        .profile_egress(StderrMsgProfiler::new("sending"))
83        .readahead()
84        .profile_ingress(StderrMsgProfiler::new("receiving"))
85        .for_each(|i| {
86            println!("{i}");
87            // make consuming values slow
88            std::thread::sleep(time::Duration::from_millis(10));
89        });
90
91    dpc_pariter::scope(|scope| {
92        (0..22)
93            .map(|i| {
94                // make producting values slow
95                std::thread::sleep(time::Duration::from_millis(10));
96                i
97            })
98            .readahead_scoped_profiled(
99                scope,
100                StderrMsgProfiler::new("sending2"),
101                StderrMsgProfiler::new("receiving2"),
102            )
103            .for_each(|i| {
104                println!("{i}");
105            })
106    })
107    .expect("thread panicked");
108}

Source §

impl<F> TotalTimeProfiler<PeriodicReporter<F>>
where F: Fn(),

Source

pub fn periodically_millis( millis: u64, f: F, ) -> TotalTimeProfiler<PeriodicReporter<F>>

Examples found in repository ?

examples/simple_profiler.rs (lines 65-67)

55fn main() {
56    dpc_pariter::scope(|scope| {
57        (0..22)
58            .map(|i| {
59                // make producting values slow
60                std::thread::sleep(time::Duration::from_millis(10));
61                i
62            })
63            .readahead_scoped_profiled(
64                scope,
65                dpc_pariter::TotalTimeProfiler::periodically_millis(2_000, || {
66                    eprintln!("Blocked on sending")
67                }),
68                dpc_pariter::TotalTimeProfiler::new(|stat| {
69                    eprintln!(
70                        "Sending receiving wait time: {}ms",
71                        stat.total().as_millis()
72                    )
73                }),
74            )
75            .for_each(|i| {
76                println!("{i}");
77            })
78    })
79    .expect("thread panicked");
80
81    (0..22)
82        .profile_egress(StderrMsgProfiler::new("sending"))
83        .readahead()
84        .profile_ingress(StderrMsgProfiler::new("receiving"))
85        .for_each(|i| {
86            println!("{i}");
87            // make consuming values slow
88            std::thread::sleep(time::Duration::from_millis(10));
89        });
90
91    dpc_pariter::scope(|scope| {
92        (0..22)
93            .map(|i| {
94                // make producting values slow
95                std::thread::sleep(time::Duration::from_millis(10));
96                i
97            })
98            .readahead_scoped_profiled(
99                scope,
100                StderrMsgProfiler::new("sending2"),
101                StderrMsgProfiler::new("receiving2"),
102            )
103            .for_each(|i| {
104                println!("{i}");
105            })
106    })
107    .expect("thread panicked");
108}