summaryrefslogtreecommitdiffstats
path: root/vendor/tracing-subscriber/benches/fmt.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/tracing-subscriber/benches/fmt.rs')
-rw-r--r--vendor/tracing-subscriber/benches/fmt.rs331
1 files changed, 331 insertions, 0 deletions
diff --git a/vendor/tracing-subscriber/benches/fmt.rs b/vendor/tracing-subscriber/benches/fmt.rs
new file mode 100644
index 000000000..a039e66d4
--- /dev/null
+++ b/vendor/tracing-subscriber/benches/fmt.rs
@@ -0,0 +1,331 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::{io, time::Duration};
+
+mod support;
+use support::MultithreadedBench;
+
+/// A fake writer that doesn't actually do anything.
+///
+/// We want to measure the subscriber's overhead, *not* the performance of
+/// stdout/file writers. Using a no-op Write implementation lets us only measure
+/// the subscriber's overhead.
+struct NoWriter;
+
+impl io::Write for NoWriter {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ Ok(buf.len())
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
+}
+
+impl NoWriter {
+ fn new() -> Self {
+ Self
+ }
+}
+
+fn bench_new_span(c: &mut Criterion) {
+ bench_thrpt(c, "new_span", |group, i| {
+ group.bench_with_input(BenchmarkId::new("single_thread", i), i, |b, &i| {
+ tracing::dispatcher::with_default(&mk_dispatch(), || {
+ b.iter(|| {
+ for n in 0..i {
+ let _span = tracing::info_span!("span", n);
+ }
+ })
+ });
+ });
+ group.bench_with_input(BenchmarkId::new("multithreaded", i), i, |b, &i| {
+ b.iter_custom(|iters| {
+ let mut total = Duration::from_secs(0);
+ let dispatch = mk_dispatch();
+ for _ in 0..iters {
+ let bench = MultithreadedBench::new(dispatch.clone());
+ let elapsed = bench
+ .thread(move || {
+ for n in 0..i {
+ let _span = tracing::info_span!("span", n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ let _span = tracing::info_span!("span", n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ let _span = tracing::info_span!("span", n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ let _span = tracing::info_span!("span", n);
+ }
+ })
+ .run();
+ total += elapsed;
+ }
+ total
+ })
+ });
+ });
+}
+
+type Group<'a> = criterion::BenchmarkGroup<'a, criterion::measurement::WallTime>;
+fn bench_thrpt(c: &mut Criterion, name: &'static str, mut f: impl FnMut(&mut Group<'_>, &usize)) {
+ const N_SPANS: &[usize] = &[1, 10, 50];
+
+ let mut group = c.benchmark_group(name);
+ for spans in N_SPANS {
+ group.throughput(Throughput::Elements(*spans as u64));
+ f(&mut group, spans);
+ }
+ group.finish();
+}
+
+fn mk_dispatch() -> tracing::Dispatch {
+ let subscriber = tracing_subscriber::FmtSubscriber::builder()
+ .with_writer(NoWriter::new)
+ .finish();
+ tracing::Dispatch::new(subscriber)
+}
+
+fn bench_event(c: &mut Criterion) {
+ bench_thrpt(c, "event", |group, i| {
+ group.bench_with_input(BenchmarkId::new("root/single_threaded", i), i, |b, &i| {
+ let dispatch = mk_dispatch();
+ tracing::dispatcher::with_default(&dispatch, || {
+ b.iter(|| {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ });
+ });
+ group.bench_with_input(BenchmarkId::new("root/multithreaded", i), i, |b, &i| {
+ b.iter_custom(|iters| {
+ let mut total = Duration::from_secs(0);
+ let dispatch = mk_dispatch();
+ for _ in 0..iters {
+ let bench = MultithreadedBench::new(dispatch.clone());
+ let elapsed = bench
+ .thread(move || {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread(move || {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .run();
+ total += elapsed;
+ }
+ total
+ })
+ });
+ group.bench_with_input(
+ BenchmarkId::new("unique_parent/single_threaded", i),
+ i,
+ |b, &i| {
+ tracing::dispatcher::with_default(&mk_dispatch(), || {
+ let span = tracing::info_span!("unique_parent", foo = false);
+ let _guard = span.enter();
+ b.iter(|| {
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ });
+ },
+ );
+ group.bench_with_input(
+ BenchmarkId::new("unique_parent/multithreaded", i),
+ i,
+ |b, &i| {
+ b.iter_custom(|iters| {
+ let mut total = Duration::from_secs(0);
+ let dispatch = mk_dispatch();
+ for _ in 0..iters {
+ let bench = MultithreadedBench::new(dispatch.clone());
+ let elapsed = bench
+ .thread_with_setup(move |start| {
+ let span = tracing::info_span!("unique_parent", foo = false);
+ let _guard = span.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread_with_setup(move |start| {
+ let span = tracing::info_span!("unique_parent", foo = false);
+ let _guard = span.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread_with_setup(move |start| {
+ let span = tracing::info_span!("unique_parent", foo = false);
+ let _guard = span.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .thread_with_setup(move |start| {
+ let span = tracing::info_span!("unique_parent", foo = false);
+ let _guard = span.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ })
+ .run();
+ total += elapsed;
+ }
+ total
+ })
+ },
+ );
+ group.bench_with_input(
+ BenchmarkId::new("shared_parent/multithreaded", i),
+ i,
+ |b, &i| {
+ b.iter_custom(|iters| {
+ let dispatch = mk_dispatch();
+ let mut total = Duration::from_secs(0);
+ for _ in 0..iters {
+ let parent = tracing::dispatcher::with_default(&dispatch, || {
+ tracing::info_span!("shared_parent", foo = "hello world")
+ });
+ let bench = MultithreadedBench::new(dispatch.clone());
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ for n in 0..i {
+ tracing::info!(n);
+ }
+ });
+ let elapsed = bench.run();
+ total += elapsed;
+ }
+ total
+ })
+ },
+ );
+ group.bench_with_input(
+ BenchmarkId::new("multi-parent/multithreaded", i),
+ i,
+ |b, &i| {
+ b.iter_custom(|iters| {
+ let dispatch = mk_dispatch();
+ let mut total = Duration::from_secs(0);
+ for _ in 0..iters {
+ let parent = tracing::dispatcher::with_default(&dispatch, || {
+ tracing::info_span!("multiparent", foo = "hello world")
+ });
+ let bench = MultithreadedBench::new(dispatch.clone());
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ let mut span = tracing::info_span!("parent");
+ for n in 0..i {
+ let s = tracing::info_span!(parent: &span, "parent2", n, i);
+ s.in_scope(|| {
+ tracing::info!(n);
+ });
+ span = s;
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ let mut span = tracing::info_span!("parent");
+ for n in 0..i {
+ let s = tracing::info_span!(parent: &span, "parent2", n, i);
+ s.in_scope(|| {
+ tracing::info!(n);
+ });
+ span = s;
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ let mut span = tracing::info_span!("parent");
+ for n in 0..i {
+ let s = tracing::info_span!(parent: &span, "parent2", n, i);
+ s.in_scope(|| {
+ tracing::info!(n);
+ });
+ span = s;
+ }
+ });
+ let parent2 = parent.clone();
+ bench.thread_with_setup(move |start| {
+ let _guard = parent2.enter();
+ start.wait();
+ let mut span = tracing::info_span!("parent");
+ for n in 0..i {
+ let s = tracing::info_span!(parent: &span, "parent2", n, i);
+ s.in_scope(|| {
+ tracing::info!(n);
+ });
+ span = s;
+ }
+ });
+ let elapsed = bench.run();
+ total += elapsed;
+ }
+ total
+ })
+ },
+ );
+ });
+}
+
+criterion_group!(benches, bench_new_span, bench_event);
+criterion_main!(benches);
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-22 00:04:14 +0000