Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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);