Skip to content

Commit 03757b7

Browse files
not-matthiasnot-matthias
committed
feat(criterion_compat): use bench markers
1 parent e733f8b commit 03757b7

File tree

3 files changed

+61
-14
lines changed

3 files changed

+61
-14
lines changed

‎crates/criterion_compat/criterion_fork/src/analysis/mod.rs‎

Lines changed: 5 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -297,19 +297,13 @@ mod codspeed {
297297
) {
298298
let (uri, bench_name) = create_uri_and_name(id, c);
299299

300-
#[cfg(unix)]
300+
if let Err(error) =
301+
::codspeed::instrument_hooks::InstrumentHooks::instance().set_executed_benchmark(&uri)
301302
{
302-
if let Err(error) =
303-
::codspeed::fifo::send_cmd(codspeed::fifo::Command::CurrentBenchmark {
304-
pid: std::process::id(),
305-
uri: uri.clone(),
306-
})
303+
if ::codspeed::utils::running_with_codspeed_runner()
304+
&& ::codspeed::utils::is_perf_enabled()
307305
{
308-
if codspeed::utils::running_with_codspeed_runner()
309-
&& codspeed::utils::is_perf_enabled()
310-
{
311-
eprintln!("Failed to send benchmark URI to runner: {error:?}");
312-
}
306+
eprintln!("Failed to set executed benchmark URI: {error:?}");
313307
}
314308
}
315309

‎crates/criterion_compat/criterion_fork/src/bencher.rs‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,8 @@ use std::iter::IntoIterator;
44
use std::time::Duration;
55
use std::time::Instant;
66

7+
use codspeed::instrument_hooks::InstrumentHooks;
8+
79
use crate::black_box;
810
use crate::measurement::{Measurement, WallTime};
911
use crate::BatchSize;
@@ -93,13 +95,17 @@ impl<'a, M: Measurement> Bencher<'a, M> {
9395
R: FnMut() -> O,
9496
{
9597
self.iterated = true;
98+
99+
let bench_start = InstrumentHooks::current_timestamp();
96100
let time_start = Instant::now();
97101
let start = self.measurement.start();
98102
for _ in 0..self.iters {
99103
black_box(routine());
100104
}
101105
self.value = self.measurement.end(start);
102106
self.elapsed_time = time_start.elapsed();
107+
let bench_end = InstrumentHooks::current_timestamp();
108+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
103109
}
104110

105111
/// Times a `routine` by executing it many times and relying on `routine` to measure its own execution time.
@@ -153,9 +159,12 @@ impl<'a, M: Measurement> Bencher<'a, M> {
153159
R: FnMut(u64) -> M::Value,
154160
{
155161
self.iterated = true;
162+
let bench_start = InstrumentHooks::current_timestamp();
156163
let time_start = Instant::now();
157164
self.value = routine(self.iters);
158165
self.elapsed_time = time_start.elapsed();
166+
let bench_end = InstrumentHooks::current_timestamp();
167+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
159168
}
160169

161170
#[doc(hidden)]
@@ -282,9 +291,13 @@ impl<'a, M: Measurement> Bencher<'a, M> {
282291
for _ in 0..self.iters {
283292
let input = black_box(setup());
284293

294+
let bench_start = InstrumentHooks::current_timestamp();
285295
let start = self.measurement.start();
286296
let output = routine(input);
287297
let end = self.measurement.end(start);
298+
let bench_end = InstrumentHooks::current_timestamp();
299+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
300+
288301
self.value = self.measurement.add(&self.value, &end);
289302

290303
drop(black_box(output));
@@ -298,9 +311,13 @@ impl<'a, M: Measurement> Bencher<'a, M> {
298311
let inputs = black_box((0..batch_size).map(|_| setup()).collect::<Vec<_>>());
299312
let mut outputs = Vec::with_capacity(batch_size as usize);
300313

314+
let bench_start = InstrumentHooks::current_timestamp();
301315
let start = self.measurement.start();
302316
outputs.extend(inputs.into_iter().map(&mut routine));
303317
let end = self.measurement.end(start);
318+
let bench_end = InstrumentHooks::current_timestamp();
319+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
320+
304321
self.value = self.measurement.add(&self.value, &end);
305322

306323
black_box(outputs);
@@ -386,9 +403,13 @@ impl<'a, M: Measurement> Bencher<'a, M> {
386403
for _ in 0..self.iters {
387404
let mut input = black_box(setup());
388405

406+
let bench_start = InstrumentHooks::current_timestamp();
389407
let start = self.measurement.start();
390408
let output = routine(&mut input);
391409
let end = self.measurement.end(start);
410+
let bench_end = InstrumentHooks::current_timestamp();
411+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
412+
392413
self.value = self.measurement.add(&self.value, &end);
393414

394415
drop(black_box(output));
@@ -403,9 +424,13 @@ impl<'a, M: Measurement> Bencher<'a, M> {
403424
let mut inputs = black_box((0..batch_size).map(|_| setup()).collect::<Vec<_>>());
404425
let mut outputs = Vec::with_capacity(batch_size as usize);
405426

427+
let bench_start = InstrumentHooks::current_timestamp();
406428
let start = self.measurement.start();
407429
outputs.extend(inputs.iter_mut().map(&mut routine));
408430
let end = self.measurement.end(start);
431+
let bench_end = InstrumentHooks::current_timestamp();
432+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
433+
409434
self.value = self.measurement.add(&self.value, &end);
410435

411436
black_box(outputs);
@@ -497,13 +522,16 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
497522
let AsyncBencher { b, runner } = self;
498523
runner.block_on(async {
499524
b.iterated = true;
525+
let bench_start = InstrumentHooks::current_timestamp();
500526
let time_start = Instant::now();
501527
let start = b.measurement.start();
502528
for _ in 0..b.iters {
503529
black_box(routine().await);
504530
}
505531
b.value = b.measurement.end(start);
506532
b.elapsed_time = time_start.elapsed();
533+
let bench_end = InstrumentHooks::current_timestamp();
534+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
507535
});
508536
}
509537

@@ -565,9 +593,12 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
565593
let AsyncBencher { b, runner } = self;
566594
runner.block_on(async {
567595
b.iterated = true;
596+
let bench_start = InstrumentHooks::current_timestamp();
568597
let time_start = Instant::now();
569598
b.value = routine(b.iters).await;
570599
b.elapsed_time = time_start.elapsed();
600+
let bench_end = InstrumentHooks::current_timestamp();
601+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
571602
})
572603
}
573604

@@ -713,9 +744,13 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
713744
for _ in 0..b.iters {
714745
let input = black_box(setup());
715746

747+
let bench_start = InstrumentHooks::current_timestamp();
716748
let start = b.measurement.start();
717749
let output = routine(input).await;
718750
let end = b.measurement.end(start);
751+
let bench_end = InstrumentHooks::current_timestamp();
752+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
753+
719754
b.value = b.measurement.add(&b.value, &end);
720755

721756
drop(black_box(output));
@@ -729,12 +764,16 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
729764
let inputs = black_box((0..batch_size).map(|_| setup()).collect::<Vec<_>>());
730765
let mut outputs = Vec::with_capacity(batch_size as usize);
731766

767+
let bench_start = InstrumentHooks::current_timestamp();
732768
let start = b.measurement.start();
733769
// Can't use .extend here like the sync version does
734770
for input in inputs {
735771
outputs.push(routine(input).await);
736772
}
737773
let end = b.measurement.end(start);
774+
let bench_end = InstrumentHooks::current_timestamp();
775+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
776+
738777
b.value = b.measurement.add(&b.value, &end);
739778

740779
black_box(outputs);
@@ -826,9 +865,13 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
826865
for _ in 0..b.iters {
827866
let mut input = black_box(setup());
828867

868+
let bench_start = InstrumentHooks::current_timestamp();
829869
let start = b.measurement.start();
830870
let output = routine(&mut input).await;
831871
let end = b.measurement.end(start);
872+
let bench_end = InstrumentHooks::current_timestamp();
873+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
874+
832875
b.value = b.measurement.add(&b.value, &end);
833876

834877
drop(black_box(output));
@@ -843,12 +886,16 @@ impl<'a, 'b, A: AsyncExecutor, M: Measurement> AsyncBencher<'a, 'b, A, M> {
843886
let inputs = black_box((0..batch_size).map(|_| setup()).collect::<Vec<_>>());
844887
let mut outputs = Vec::with_capacity(batch_size as usize);
845888

889+
let bench_start = InstrumentHooks::current_timestamp();
846890
let start = b.measurement.start();
847891
// Can't use .extend here like the sync version does
848892
for mut input in inputs {
849893
outputs.push(routine(&mut input).await);
850894
}
851895
let end = b.measurement.end(start);
896+
let bench_end = InstrumentHooks::current_timestamp();
897+
InstrumentHooks::instance().add_benchmark_timestamps(bench_start, bench_end);
898+
852899
b.value = b.measurement.add(&b.value, &end);
853900

854901
black_box(outputs);

‎crates/criterion_compat/criterion_fork/src/routine.rs‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
use codspeed::instrument_hooks::InstrumentHooks;
2+
13
use crate::benchmark::BenchmarkConfig;
24
use crate::connection::OutgoingMessage;
35
use crate::measurement::Measurement;
@@ -192,9 +194,13 @@ pub(crate) trait Routine<M: Measurement, T: ?Sized> {
192194
}
193195

194196
let m_elapsed = {
195-
#[cfg(unix)]
196-
let _guard = codspeed::fifo::BenchGuard::new_with_runner_fifo();
197-
self.bench(measurement, &m_iters, parameter)
197+
let hooks = InstrumentHooks::instance();
198+
199+
let _ = hooks.start_benchmark();
200+
let value = self.bench(measurement, &m_iters, parameter);
201+
let _ = hooks.stop_benchmark();
202+
203+
value
198204
};
199205
let m_iters_f: Vec<f64> = m_iters.iter().map(|&x| x as f64).collect();
200206

0 commit comments

Comments
 (0)