Struct Bencher 

pub struct Bencher<'a> { /* private fields */ }

Timing harness passed to a #[pg_bench] benchmark function.

Bench functions register exactly one timing loop with either Bencher::iter or Bencher::iter_batched.

use pgrx_bench::{Bencher, black_box};

#[pg_bench]
fn bench_normalize_phrase(b: &mut Bencher) {
    let phrase = "the quick brown fox";
    b.iter(|| crate::normalize_phrase(black_box(phrase)));
}

Implementations

impl<'a> Bencher<'a>

pub fn iter<R, F>(&mut self, routine: F)

where F: FnMut() -> R + 'a,

Registers a simple timing loop for a benchmark.

Use this when the benchmark body can reuse the same captured inputs for each iteration.

use pgrx_bench::{Bencher, black_box};

#[pg_bench]
fn bench_parse_uuid(b: &mut Bencher) {
    let input = "550e8400-e29b-41d4-a716-446655440000";
    b.iter(|| crate::parse_uuid(black_box(input)));
}

pub fn iter_batched<I, R, S, F>( &mut self, setup: S, routine: F, batch_size: BatchSize, )

where I: 'static, S: FnMut() -> I + 'a, F: FnMut(I) -> R + 'a,

Registers a timing loop that performs per-batch setup outside the measured routine body.

Use this when each timing sample needs fresh inputs or temporary state.

use pgrx_bench::{BatchSize, Bencher};

#[pg_bench]
fn bench_transform_rows(b: &mut Bencher) {
    b.iter_batched(
        || (0..100).collect::<Vec<i32>>(),
        |rows| rows.into_iter().map(|value| value * 2).collect::<Vec<_>>(),
        BatchSize::SmallInput,
    );
}