vendor/tracing/benches/subscriber.rs

   1 extern crate criterion;
   2 extern crate tracing;
   3
   4 use criterion::{black_box, criterion_group, criterion_main, Criterion};
   5 use tracing::Level;
   6
   7 use std::{
   8     fmt,
   9     sync::{Mutex, MutexGuard},
  10 };
  11 use tracing::{field, span, Event, Id, Metadata};
  12
  13 /// A subscriber that is enabled but otherwise does nothing.
  14 struct EnabledSubscriber;
  15
  16 impl tracing::Subscriber for EnabledSubscriber {
  17     fn new_span(&self, span: &span::Attributes<'_>) -> Id {
  18         let _ = span;
  19         Id::from_u64(0xDEAD_FACE)
  20     }
  21
  22     fn event(&self, event: &Event<'_>) {
  23         let _ = event;
  24     }
  25
  26     fn record(&self, span: &Id, values: &span::Record<'_>) {
  27         let _ = (span, values);
  28     }
  29
  30     fn record_follows_from(&self, span: &Id, follows: &Id) {
  31         let _ = (span, follows);
  32     }
  33
  34     fn enabled(&self, metadata: &Metadata<'_>) -> bool {
  35         let _ = metadata;
  36         true
  37     }
  38
  39     fn enter(&self, span: &Id) {
  40         let _ = span;
  41     }
  42
  43     fn exit(&self, span: &Id) {
  44         let _ = span;
  45     }
  46 }
  47
  48 /// Simulates a subscriber that records span data.
  49 struct VisitingSubscriber(Mutex<String>);
  50
  51 struct Visitor<'a>(MutexGuard<'a, String>);
  52
  53 impl<'a> field::Visit for Visitor<'a> {
  54     fn record_debug(&mut self, _field: &field::Field, value: &dyn fmt::Debug) {
  55         use std::fmt::Write;
  56         let _ = write!(&mut *self.0, "{:?}", value);
  57     }
  58 }
  59
  60 impl tracing::Subscriber for VisitingSubscriber {
  61     fn new_span(&self, span: &span::Attributes<'_>) -> Id {
  62         let mut visitor = Visitor(self.0.lock().unwrap());
  63         span.record(&mut visitor);
  64         Id::from_u64(0xDEAD_FACE)
  65     }
  66
  67     fn record(&self, _span: &Id, values: &span::Record<'_>) {
  68         let mut visitor = Visitor(self.0.lock().unwrap());
  69         values.record(&mut visitor);
  70     }
  71
  72     fn event(&self, event: &Event<'_>) {
  73         let mut visitor = Visitor(self.0.lock().unwrap());
  74         event.record(&mut visitor);
  75     }
  76
  77     fn record_follows_from(&self, span: &Id, follows: &Id) {
  78         let _ = (span, follows);
  79     }
  80
  81     fn enabled(&self, metadata: &Metadata<'_>) -> bool {
  82         let _ = metadata;
  83         true
  84     }
  85
  86     fn enter(&self, span: &Id) {
  87         let _ = span;
  88     }
  89
  90     fn exit(&self, span: &Id) {
  91         let _ = span;
  92     }
  93 }
  94
  95 const N_SPANS: usize = 100;
  96
  97 fn criterion_benchmark(c: &mut Criterion) {
  98     c.bench_function("span_no_fields", |b| {
  99         tracing::subscriber::with_default(EnabledSubscriber, || {
 100             b.iter(|| span!(Level::TRACE, "span"))
 101         });
 102     });
 103
 104     c.bench_function("enter_span", |b| {
 105         tracing::subscriber::with_default(EnabledSubscriber, || {
 106             let span = span!(Level::TRACE, "span");
 107             #[allow(clippy::unit_arg)]
 108             b.iter(|| black_box(span.in_scope(|| {})))
 109         });
 110     });
 111
 112     c.bench_function("span_repeatedly", |b| {
 113         #[inline]
 114         fn mk_span(i: u64) -> tracing::Span {
 115             span!(Level::TRACE, "span", i = i)
 116         }
 117
 118         let n = black_box(N_SPANS);
 119         tracing::subscriber::with_default(EnabledSubscriber, || {
 120             b.iter(|| (0..n).fold(mk_span(0), |_, i| mk_span(i as u64)))
 121         });
 122     });
 123
 124     c.bench_function("span_with_fields", |b| {
 125         tracing::subscriber::with_default(EnabledSubscriber, || {
 126             b.iter(|| {
 127                 span!(
 128                     Level::TRACE,
 129                     "span",
 130                     foo = "foo",
 131                     bar = "bar",
 132                     baz = 3,
 133                     quuux = tracing::field::debug(0.99)
 134                 )
 135             })
 136         });
 137     });
 138
 139     c.bench_function("span_with_fields_record", |b| {
 140         let subscriber = VisitingSubscriber(Mutex::new(String::from("")));
 141         tracing::subscriber::with_default(subscriber, || {
 142             b.iter(|| {
 143                 span!(
 144                     Level::TRACE,
 145                     "span",
 146                     foo = "foo",
 147                     bar = "bar",
 148                     baz = 3,
 149                     quuux = tracing::field::debug(0.99)
 150                 )
 151             })
 152         });
 153     });
 154 }
 155
 156 fn bench_dispatch(c: &mut Criterion) {
 157     let mut group = c.benchmark_group("dispatch");
 158     group.bench_function("no_dispatch_get_ref", |b| {
 159         b.iter(|| {
 160             tracing::dispatcher::get_default(|current| {
 161                 black_box(&current);
 162             })
 163         })
 164     });
 165     group.bench_function("no_dispatch_get_clone", |b| {
 166         b.iter(|| {
 167             let current = tracing::dispatcher::get_default(|current| current.clone());
 168             black_box(current);
 169         })
 170     });
 171     group.bench_function("get_ref", |b| {
 172         tracing::subscriber::with_default(EnabledSubscriber, || {
 173             b.iter(|| {
 174                 tracing::dispatcher::get_default(|current| {
 175                     black_box(&current);
 176                 })
 177             })
 178         })
 179     });
 180     group.bench_function("get_clone", |b| {
 181         tracing::subscriber::with_default(EnabledSubscriber, || {
 182             b.iter(|| {
 183                 let current = tracing::dispatcher::get_default(|current| current.clone());
 184                 black_box(current);
 185             })
 186         })
 187     });
 188     group.finish();
 189 }
 190
 191 criterion_group!(benches, criterion_benchmark, bench_dispatch);
 192 criterion_main!(benches);