feat(rust): port benchmark loop and CLI bench mode
Move the implementation of programs/benchfn.c into rust/src/benchfn.rs and wire benchmark mode (-b/-e/-i) into the Rust CLI frontend, which previously rejected those options as not yet implemented. `zstd -b1 -i0 FILE` and range runs like `zstd -b5e6 -i0 FILE` work again, including the synthetic-sample benchmark when no file is given. benchfn.rs is a faithful port of the run/timing state machine: BMK_benchFunction keeps the exact loop accounting (first-loop blockResults and errorFn checks, dstSize summed on the first loop only, 0xE5 warm-up of result buffers, nbLoops minimum of 1) and BMK_benchTimedFn keeps the same convergence behavior (x10 workload growth for short runs, budget-based nbLoops estimation, runs below half the run budget re-tried rather than reported, best qualifying run returned). Arithmetic that C leaves to unsigned wrap-around uses wrapping operations so debug builds cannot panic where release C would wrap. ABI notes: BMK_runTime_t and BMK_runOutcome_t are returned by value across the C boundary and BMK_benchParams_t is passed by value, so all three are repr(C) mirrors of benchfn.h; their field offsets are pinned by const asserts in Rust and matching C static asserts in the benchfn.c shim, which is now declaration-only. BMK_timedFnState_t stays opaque, fits the 64-byte BMK_timedFnState_shell (compile-time checked), and is malloc/free-managed so creation and destruction remain interchangeable with C callers. The CLI parses -b (bench mode), -e (range end, digits attach directly, defaulting to 0 like readU32FromChar) and -i (duration in seconds), then dispatches through a new ZSTD_rust_cli_bench bridge in the zstdcli.c shim. The bridge exists because benchmark availability is a C preprocessor property (ZSTD_NOBENCH): orchestration and reporting stay in C benchzstd.c, stripped variants (zstd-small, zstd-compress, zstd-decompress) compile the stub branch and report "benchmark mode is not available in this build", and the Rust side never references benchmark symbols directly. Level clamping against ZSTD_maxCLevel() happens in the bridge, where the symbol is guaranteed to exist whenever benchmarking is compiled in. -T selects the worker count, defaulting to single-threaded like the C bench path; -S (separate files) and --priority=rt remain unimplemented. Makefile updates only extend the Rust source prerequisite lists with benchfn.rs; the helpers-archive plumbing from the timefn commit already links fullbench(-lib/-dll/32) and paramgrill, the benchfn consumers among the C tests. Original C test sources are untouched. Known pre-existing issues, unchanged by this commit: tests/fullbench-lib fails to link at the base commit too (libzstd.a precedes fullbench.c in its link line), and the cli-tests basic/help.sh, compression/levels.sh, compression/golden.sh, and decompression/pass-through.sh scripts fail identically with a base-commit binary because the Rust CLI frontend is still a partial reimplementation. Test Plan: - cd rust && cargo fmt --check && cargo clippy --all-targets -- -D warnings && cargo test --all-targets && cargo build --release - cd rust/cli && cargo fmt --check && cargo clippy --all-targets -- -D warnings && cargo test --all-targets; repeat tests with --no-default-features plus features compression / decompression / (none) - make -C programs zstd; ./programs/zstd -b1 -i0 lib/common/xxhash.c; ./programs/zstd -b5e6 -i0 programs/fileio.c; ./programs/zstd -b1 -i0 (synthetic); echo roundtrip via zstd | zstd -d - make -C programs zstd-small zstd-compress zstd-decompress zstd-nolegacy zstd-dictBuilder; zstd-small -b reports benchmark unavailable; compress/ decompress roundtrip across the split binaries - make -C tests fullbench fuzzer zstreamtest paramgrill decodecorpus poolTests fullbench32 fuzzer32; ./tests/fullbench -i0 (exercises Rust BMK_benchTimedFn from C); ./tests/fullbench32 -i0; ./tests/fuzzer -i1 --no-big-tests; ./tests/poolTests; make -C tests test-rust-lib-smoke - cli-tests subset: basic/version.sh, compression/basic.sh, compression/multiple-files.sh pass; failing scripts match the base commit Refs: rust/README.md
This commit is contained in:
@@ -0,0 +1,575 @@
|
||||
#![allow(non_camel_case_types)]
|
||||
#![allow(non_snake_case)]
|
||||
#![allow(clippy::missing_safety_doc)]
|
||||
|
||||
//! Benchmark loop for arbitrary functions over a set of blocks.
|
||||
//!
|
||||
//! Port of `programs/benchfn.c`. `BMK_benchFunction` measures one batch of
|
||||
//! runs; `BMK_benchTimedFn` repeats batches, growing the loop count until a
|
||||
//! run lasts long enough to be reported reliably against `run_ms`, within a
|
||||
//! `total_ms` budget tracked by `BMK_timedFnState_t`.
|
||||
//!
|
||||
//! ABI notes: `BMK_runOutcome_t` and `BMK_runTime_t` are returned by value
|
||||
//! across the C boundary and `BMK_benchParams_t` is passed by value, so all
|
||||
//! three are `repr(C)` mirrors of the `benchfn.h` layout, pinned by asserts
|
||||
//! here and in the C shim. `BMK_timedFnState_t` is opaque to C, but
|
||||
//! `BMK_initStatic_timedFnState` guarantees it fits the 64-byte
|
||||
//! `BMK_timedFnState_shell`, and `BMK_createTimedFnState` uses `malloc` so
|
||||
//! creation and destruction stay interchangeable with C callers.
|
||||
|
||||
use std::os::raw::{c_int, c_uint, c_void};
|
||||
use std::ptr;
|
||||
|
||||
use crate::timefn::{PTime, UTIL_clockSpanNano, UTIL_getTime, UTIL_time_t};
|
||||
|
||||
const TIMELOOP_NANOSEC: PTime = 1_000_000_000;
|
||||
|
||||
/// Valid benchmark result (`BMK_runTime_t` in benchfn.h).
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct BMK_runTime_t {
|
||||
/// Time per iteration, over all blocks.
|
||||
pub nanoSecPerRun: f64,
|
||||
/// Sum of the benchmarked function's return values, first loop only.
|
||||
pub sumOfReturn: usize,
|
||||
}
|
||||
|
||||
/// Outcome variant of a benchmark run (`BMK_runOutcome_t` in benchfn.h):
|
||||
/// either a valid `BMK_runTime_t` or an error result. C callers treat it as
|
||||
/// opaque and use the accessor functions below.
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct BMK_runOutcome_t {
|
||||
pub internal_never_ever_use_directly: BMK_runTime_t,
|
||||
pub error_result_never_ever_use_directly: usize,
|
||||
pub error_tag_never_ever_use_directly: c_int,
|
||||
}
|
||||
|
||||
// These mirror the static asserts in the programs/benchfn.c shim: the structs
|
||||
// cross the ABI by value, so field offsets must match the C header exactly.
|
||||
const _: () =
|
||||
assert!(std::mem::offset_of!(BMK_runTime_t, sumOfReturn) == std::mem::size_of::<f64>());
|
||||
const _: () = assert!(
|
||||
std::mem::offset_of!(BMK_runOutcome_t, error_result_never_ever_use_directly)
|
||||
== std::mem::size_of::<BMK_runTime_t>()
|
||||
);
|
||||
const _: () = assert!(
|
||||
std::mem::offset_of!(BMK_runOutcome_t, error_tag_never_ever_use_directly)
|
||||
== std::mem::size_of::<BMK_runTime_t>() + std::mem::size_of::<usize>()
|
||||
);
|
||||
|
||||
/// `size_t (*BMK_benchFn_t)(const void*, size_t, void*, size_t, void*)`
|
||||
pub type BMK_benchFn_t = Option<
|
||||
unsafe extern "C" fn(
|
||||
src: *const c_void,
|
||||
srcSize: usize,
|
||||
dst: *mut c_void,
|
||||
dstCapacity: usize,
|
||||
customPayload: *mut c_void,
|
||||
) -> usize,
|
||||
>;
|
||||
/// `size_t (*BMK_initFn_t)(void*)`
|
||||
pub type BMK_initFn_t = Option<unsafe extern "C" fn(initPayload: *mut c_void) -> usize>;
|
||||
/// `unsigned (*BMK_errorFn_t)(size_t)`
|
||||
pub type BMK_errorFn_t = Option<unsafe extern "C" fn(result: usize) -> c_uint>;
|
||||
|
||||
/// Parameters of `BMK_benchFunction`, passed by value (`BMK_benchParams_t`).
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct BMK_benchParams_t {
|
||||
pub benchFn: BMK_benchFn_t,
|
||||
pub benchPayload: *mut c_void,
|
||||
pub initFn: BMK_initFn_t,
|
||||
pub initPayload: *mut c_void,
|
||||
pub errorFn: BMK_errorFn_t,
|
||||
pub blockCount: usize,
|
||||
pub srcBuffers: *const *const c_void,
|
||||
pub srcSizes: *const usize,
|
||||
pub dstBuffers: *const *mut c_void,
|
||||
pub dstCapacities: *const usize,
|
||||
pub blockResults: *mut usize,
|
||||
}
|
||||
|
||||
/// Aborts, like benchfn.c's `CONTROL`, when an accessor is used on the wrong
|
||||
/// outcome variant.
|
||||
fn control(condition: bool) {
|
||||
if !condition {
|
||||
std::process::abort();
|
||||
}
|
||||
}
|
||||
|
||||
fn error_outcome(errorResult: usize) -> BMK_runOutcome_t {
|
||||
BMK_runOutcome_t {
|
||||
internal_never_ever_use_directly: BMK_runTime_t {
|
||||
nanoSecPerRun: 0.0,
|
||||
sumOfReturn: 0,
|
||||
},
|
||||
error_result_never_ever_use_directly: errorResult,
|
||||
error_tag_never_ever_use_directly: 1,
|
||||
}
|
||||
}
|
||||
|
||||
fn valid_outcome(runTime: BMK_runTime_t) -> BMK_runOutcome_t {
|
||||
BMK_runOutcome_t {
|
||||
internal_never_ever_use_directly: runTime,
|
||||
error_result_never_ever_use_directly: 0,
|
||||
error_tag_never_ever_use_directly: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// Tells if the outcome carries a valid measurement.
|
||||
#[no_mangle]
|
||||
pub extern "C" fn BMK_isSuccessful_runOutcome(outcome: BMK_runOutcome_t) -> c_int {
|
||||
c_int::from(outcome.error_tag_never_ever_use_directly == 0)
|
||||
}
|
||||
|
||||
/// Extracts the measurement; aborts if the outcome is an error, so validity
|
||||
/// must be checked first with `BMK_isSuccessful_runOutcome`.
|
||||
#[no_mangle]
|
||||
pub extern "C" fn BMK_extract_runTime(outcome: BMK_runOutcome_t) -> BMK_runTime_t {
|
||||
control(outcome.error_tag_never_ever_use_directly == 0);
|
||||
outcome.internal_never_ever_use_directly
|
||||
}
|
||||
|
||||
/// Extracts the faulty `benchFn` return value; aborts if the outcome is
|
||||
/// valid, so failure must be checked first.
|
||||
#[no_mangle]
|
||||
pub extern "C" fn BMK_extract_errorResult(outcome: BMK_runOutcome_t) -> usize {
|
||||
control(outcome.error_tag_never_ever_use_directly != 0);
|
||||
outcome.error_result_never_ever_use_directly
|
||||
}
|
||||
|
||||
/// Runs `initFn` once, then `benchFn` `nbLoops` times over every block, and
|
||||
/// reports the mean time per loop. On the first loop, per-block results are
|
||||
/// stored into `blockResults` (when provided) and checked with `errorFn`
|
||||
/// (when provided); the first failing block aborts the measurement and
|
||||
/// produces an error outcome carrying the faulty return value.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_benchFunction(
|
||||
p: BMK_benchParams_t,
|
||||
mut nbLoops: c_uint,
|
||||
) -> BMK_runOutcome_t {
|
||||
// Minimum nbLoops is 1.
|
||||
nbLoops += c_uint::from(nbLoops == 0);
|
||||
|
||||
// Warm up and erase the result buffers.
|
||||
for blockNb in 0..p.blockCount {
|
||||
unsafe {
|
||||
let dst = *p.dstBuffers.add(blockNb);
|
||||
ptr::write_bytes(dst.cast::<u8>(), 0xE5, *p.dstCapacities.add(blockNb));
|
||||
}
|
||||
}
|
||||
|
||||
let benchFn = p.benchFn.expect("benchFn is mandatory");
|
||||
let mut dstSize = 0usize;
|
||||
let clockStart = UTIL_getTime();
|
||||
if let Some(initFn) = p.initFn {
|
||||
unsafe { initFn(p.initPayload) };
|
||||
}
|
||||
for loopNb in 0..nbLoops {
|
||||
for blockNb in 0..p.blockCount {
|
||||
let res = unsafe {
|
||||
benchFn(
|
||||
*p.srcBuffers.add(blockNb),
|
||||
*p.srcSizes.add(blockNb),
|
||||
*p.dstBuffers.add(blockNb),
|
||||
*p.dstCapacities.add(blockNb),
|
||||
p.benchPayload,
|
||||
)
|
||||
};
|
||||
if loopNb == 0 {
|
||||
if !p.blockResults.is_null() {
|
||||
unsafe { *p.blockResults.add(blockNb) = res };
|
||||
}
|
||||
if let Some(errorFn) = p.errorFn {
|
||||
if unsafe { errorFn(res) } != 0 {
|
||||
return error_outcome(res);
|
||||
}
|
||||
}
|
||||
dstSize = dstSize.wrapping_add(res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let totalTime = UTIL_clockSpanNano(clockStart);
|
||||
valid_outcome(BMK_runTime_t {
|
||||
nanoSecPerRun: totalTime as f64 / f64::from(nbLoops),
|
||||
sumOfReturn: dstSize,
|
||||
})
|
||||
}
|
||||
|
||||
/// Benchmark session state (`struct BMK_timedFnState_s`), opaque to C.
|
||||
#[repr(C)]
|
||||
pub struct BMK_timedFnState_t {
|
||||
timeSpent_ns: PTime,
|
||||
timeBudget_ns: PTime,
|
||||
runBudget_ns: PTime,
|
||||
fastestRun: BMK_runTime_t,
|
||||
nbLoops: c_uint,
|
||||
coolTime: UTIL_time_t,
|
||||
}
|
||||
|
||||
/// `BMK_TIMEDFNSTATE_SIZE` in benchfn.h: capacity of the caller-provided
|
||||
/// `BMK_timedFnState_shell`, which the state must always fit.
|
||||
const BMK_TIMEDFNSTATE_SIZE: usize = 64;
|
||||
const _: () = assert!(std::mem::size_of::<BMK_timedFnState_t>() <= BMK_TIMEDFNSTATE_SIZE);
|
||||
// The shell aligns via a `long long` member; the state must not need more.
|
||||
const _: () = assert!(std::mem::align_of::<BMK_timedFnState_t>() <= std::mem::align_of::<u64>());
|
||||
|
||||
/// Allocates and initializes a benchmark session lasting a minimum of
|
||||
/// `total_ms`, paced at intervals of approximately `run_ms`. Uses `malloc`
|
||||
/// so ownership stays interchangeable with the original C implementation.
|
||||
#[no_mangle]
|
||||
pub extern "C" fn BMK_createTimedFnState(
|
||||
total_ms: c_uint,
|
||||
run_ms: c_uint,
|
||||
) -> *mut BMK_timedFnState_t {
|
||||
let state = unsafe { libc::malloc(std::mem::size_of::<BMK_timedFnState_t>()) }
|
||||
.cast::<BMK_timedFnState_t>();
|
||||
if state.is_null() {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
unsafe { BMK_resetTimedFnState(state, total_ms, run_ms) };
|
||||
state
|
||||
}
|
||||
|
||||
/// Releases a state obtained from `BMK_createTimedFnState`.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_freeTimedFnState(state: *mut BMK_timedFnState_t) {
|
||||
unsafe { libc::free(state.cast()) };
|
||||
}
|
||||
|
||||
/// Places the session state into a caller-provided buffer, typically a
|
||||
/// `BMK_timedFnState_shell`. Returns NULL when the buffer is missing, too
|
||||
/// small, or misaligned.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_initStatic_timedFnState(
|
||||
buffer: *mut c_void,
|
||||
size: usize,
|
||||
total_ms: c_uint,
|
||||
run_ms: c_uint,
|
||||
) -> *mut BMK_timedFnState_t {
|
||||
if buffer.is_null() {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
if size < std::mem::size_of::<BMK_timedFnState_t>() {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
if !(buffer as usize).is_multiple_of(std::mem::align_of::<BMK_timedFnState_t>()) {
|
||||
return ptr::null_mut();
|
||||
}
|
||||
let state = buffer.cast::<BMK_timedFnState_t>();
|
||||
unsafe { BMK_resetTimedFnState(state, total_ms, run_ms) };
|
||||
state
|
||||
}
|
||||
|
||||
/// Re-arms a session for a new benchmark of `total_ms`, paced at `run_ms`.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_resetTimedFnState(
|
||||
timedFnState: *mut BMK_timedFnState_t,
|
||||
total_ms: c_uint,
|
||||
run_ms: c_uint,
|
||||
) {
|
||||
let total_ms = if total_ms == 0 { 1 } else { total_ms };
|
||||
let mut run_ms = if run_ms == 0 { 1 } else { run_ms };
|
||||
if run_ms > total_ms {
|
||||
run_ms = total_ms;
|
||||
}
|
||||
let state = BMK_timedFnState_t {
|
||||
timeSpent_ns: 0,
|
||||
timeBudget_ns: PTime::from(total_ms) * TIMELOOP_NANOSEC / 1000,
|
||||
runBudget_ns: PTime::from(run_ms) * TIMELOOP_NANOSEC / 1000,
|
||||
fastestRun: BMK_runTime_t {
|
||||
// Must be larger than any potential measurement.
|
||||
nanoSecPerRun: TIMELOOP_NANOSEC as f64 * 2_000_000_000.0,
|
||||
sumOfReturn: usize::MAX,
|
||||
},
|
||||
nbLoops: 1,
|
||||
coolTime: UTIL_getTime(),
|
||||
};
|
||||
unsafe { timedFnState.write(state) };
|
||||
}
|
||||
|
||||
/// Tells if the total time budget of the session is spent. Also reports 1
|
||||
/// after `BMK_benchTimedFn` returned an error.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_isCompleted_TimedFn(timedFnState: *const BMK_timedFnState_t) -> c_int {
|
||||
let state = unsafe { &*timedFnState };
|
||||
c_int::from(state.timeSpent_ns >= state.timeBudget_ns)
|
||||
}
|
||||
|
||||
/// Runs one measurement supposed to last about `run_ms`, automatically
|
||||
/// scaling `nbLoops`. Runs shorter than half the run budget are re-tried
|
||||
/// with a larger workload instead of being reported, limiting rounding-error
|
||||
/// risks; the best (fastest) qualifying run is returned.
|
||||
#[no_mangle]
|
||||
pub unsafe extern "C" fn BMK_benchTimedFn(
|
||||
cont: *mut BMK_timedFnState_t,
|
||||
p: BMK_benchParams_t,
|
||||
) -> BMK_runOutcome_t {
|
||||
let cont = unsafe { &mut *cont };
|
||||
let runBudget_ns = cont.runBudget_ns;
|
||||
let runTimeMin_ns = runBudget_ns / 2;
|
||||
let mut bestRunTime = cont.fastestRun;
|
||||
|
||||
loop {
|
||||
let runResult = unsafe { BMK_benchFunction(p, cont.nbLoops) };
|
||||
|
||||
if BMK_isSuccessful_runOutcome(runResult) == 0 {
|
||||
// Error: move out.
|
||||
return runResult;
|
||||
}
|
||||
|
||||
let newRunTime = BMK_extract_runTime(runResult);
|
||||
let loopDuration_ns = newRunTime.nanoSecPerRun * f64::from(cont.nbLoops);
|
||||
|
||||
cont.timeSpent_ns = cont.timeSpent_ns.wrapping_add(loopDuration_ns as PTime);
|
||||
|
||||
// Estimate nbLoops for the next run to last approximately run_ms.
|
||||
if loopDuration_ns > runBudget_ns as f64 / 50.0 {
|
||||
let fastestRun_ns = bestRunTime.nanoSecPerRun.min(newRunTime.nanoSecPerRun);
|
||||
cont.nbLoops = ((runBudget_ns as f64 / fastestRun_ns) as c_uint).wrapping_add(1);
|
||||
} else {
|
||||
// Previous run was too short: blindly increase workload by a
|
||||
// x10 multiplier.
|
||||
const MULTIPLIER: c_uint = 10;
|
||||
debug_assert!(cont.nbLoops < c_uint::MAX / MULTIPLIER); // avoid overflow
|
||||
cont.nbLoops = cont.nbLoops.wrapping_mul(MULTIPLIER);
|
||||
}
|
||||
|
||||
if loopDuration_ns < runTimeMin_ns as f64 {
|
||||
// Don't report results when the run time was too small, which
|
||||
// increases the risk of rounding errors.
|
||||
continue;
|
||||
}
|
||||
if newRunTime.nanoSecPerRun < bestRunTime.nanoSecPerRun {
|
||||
bestRunTime = newRunTime;
|
||||
}
|
||||
return valid_outcome(bestRunTime);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// Test payload observed through `benchPayload`/`initPayload` pointers.
|
||||
#[derive(Default)]
|
||||
struct CallLog {
|
||||
bench_calls: usize,
|
||||
init_calls: usize,
|
||||
}
|
||||
|
||||
/// Counts invocations and reports `srcSize`, like a size-preserving codec.
|
||||
unsafe extern "C" fn counting_bench_fn(
|
||||
_src: *const c_void,
|
||||
srcSize: usize,
|
||||
_dst: *mut c_void,
|
||||
_dstCapacity: usize,
|
||||
payload: *mut c_void,
|
||||
) -> usize {
|
||||
let log = unsafe { &mut *payload.cast::<CallLog>() };
|
||||
log.bench_calls += 1;
|
||||
srcSize
|
||||
}
|
||||
|
||||
unsafe extern "C" fn counting_init_fn(payload: *mut c_void) -> usize {
|
||||
let log = unsafe { &mut *payload.cast::<CallLog>() };
|
||||
log.init_calls += 1;
|
||||
0
|
||||
}
|
||||
|
||||
/// Flags results of 5 bytes and above as errors.
|
||||
unsafe extern "C" fn error_on_5(result: usize) -> c_uint {
|
||||
c_uint::from(result >= 5)
|
||||
}
|
||||
|
||||
struct Fixture {
|
||||
srcs: Vec<Vec<u8>>,
|
||||
dsts: Vec<Vec<u8>>,
|
||||
src_ptrs: Vec<*const c_void>,
|
||||
src_sizes: Vec<usize>,
|
||||
dst_ptrs: Vec<*mut c_void>,
|
||||
dst_capacities: Vec<usize>,
|
||||
block_results: Vec<usize>,
|
||||
log: CallLog,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new(block_sizes: &[usize]) -> Box<Self> {
|
||||
let srcs: Vec<Vec<u8>> = block_sizes.iter().map(|size| vec![0u8; *size]).collect();
|
||||
let mut dsts: Vec<Vec<u8>> = block_sizes.iter().map(|size| vec![0u8; *size]).collect();
|
||||
let src_ptrs = srcs.iter().map(|src| src.as_ptr().cast()).collect();
|
||||
let src_sizes = srcs.iter().map(Vec::len).collect();
|
||||
let dst_ptrs = dsts.iter_mut().map(|dst| dst.as_mut_ptr().cast()).collect();
|
||||
let dst_capacities = dsts.iter().map(Vec::len).collect();
|
||||
let block_results = vec![0usize; block_sizes.len()];
|
||||
Box::new(Self {
|
||||
srcs,
|
||||
dsts,
|
||||
src_ptrs,
|
||||
src_sizes,
|
||||
dst_ptrs,
|
||||
dst_capacities,
|
||||
block_results,
|
||||
log: CallLog::default(),
|
||||
})
|
||||
}
|
||||
|
||||
fn params(&mut self, errorFn: BMK_errorFn_t) -> BMK_benchParams_t {
|
||||
let payload: *mut CallLog = &mut self.log;
|
||||
BMK_benchParams_t {
|
||||
benchFn: Some(counting_bench_fn),
|
||||
benchPayload: payload.cast(),
|
||||
initFn: Some(counting_init_fn),
|
||||
initPayload: payload.cast(),
|
||||
errorFn,
|
||||
blockCount: self.srcs.len(),
|
||||
srcBuffers: self.src_ptrs.as_ptr(),
|
||||
srcSizes: self.src_sizes.as_ptr(),
|
||||
dstBuffers: self.dst_ptrs.as_ptr(),
|
||||
dstCapacities: self.dst_capacities.as_ptr(),
|
||||
blockResults: self.block_results.as_mut_ptr(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_function_accounts_loops_blocks_and_first_loop_results() {
|
||||
let mut fixture = Fixture::new(&[3, 8]);
|
||||
let params = fixture.params(None);
|
||||
|
||||
let outcome = unsafe { BMK_benchFunction(params, 4) };
|
||||
|
||||
assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
|
||||
let run_time = BMK_extract_runTime(outcome);
|
||||
// benchFn ran nbLoops times over each block; initFn ran once.
|
||||
assert_eq!(fixture.log.bench_calls, 4 * 2);
|
||||
assert_eq!(fixture.log.init_calls, 1);
|
||||
// sumOfReturn and blockResults reflect the first loop only.
|
||||
assert_eq!(run_time.sumOfReturn, 3 + 8);
|
||||
assert_eq!(fixture.block_results, vec![3, 8]);
|
||||
assert!(run_time.nanoSecPerRun >= 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_function_treats_zero_loops_as_one_and_warms_up_buffers() {
|
||||
let mut fixture = Fixture::new(&[4]);
|
||||
let params = fixture.params(None);
|
||||
|
||||
let outcome = unsafe { BMK_benchFunction(params, 0) };
|
||||
|
||||
assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
|
||||
assert_eq!(fixture.log.bench_calls, 1);
|
||||
// The result buffer was erased with the 0xE5 warm-up pattern.
|
||||
assert_eq!(fixture.dsts[0], vec![0xE5; 4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_function_reports_the_first_failing_block() {
|
||||
let mut fixture = Fixture::new(&[3, 5, 7]);
|
||||
let params = fixture.params(Some(error_on_5));
|
||||
|
||||
let outcome = unsafe { BMK_benchFunction(params, 10) };
|
||||
|
||||
assert_eq!(BMK_isSuccessful_runOutcome(outcome), 0);
|
||||
assert_eq!(BMK_extract_errorResult(outcome), 5);
|
||||
// Execution stopped at the failing block, before the third one.
|
||||
assert_eq!(fixture.log.bench_calls, 2);
|
||||
// blockResults were recorded up to and including the failure.
|
||||
assert_eq!(fixture.block_results[..2], [3, 5]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_clamps_budgets_and_rearms_the_loop_counter() {
|
||||
let state = BMK_createTimedFnState(0, 7);
|
||||
assert!(!state.is_null());
|
||||
|
||||
{
|
||||
let state = unsafe { &*state };
|
||||
// total_ms 0 becomes 1ms, and run_ms is clamped to total_ms.
|
||||
assert_eq!(state.timeBudget_ns, 1_000_000);
|
||||
assert_eq!(state.runBudget_ns, 1_000_000);
|
||||
assert_eq!(state.nbLoops, 1);
|
||||
assert_eq!(state.timeSpent_ns, 0);
|
||||
assert_eq!(state.fastestRun.sumOfReturn, usize::MAX);
|
||||
}
|
||||
assert_eq!(unsafe { BMK_isCompleted_TimedFn(state) }, 0);
|
||||
|
||||
unsafe { BMK_resetTimedFnState(state, 2_000, 500) };
|
||||
{
|
||||
let state = unsafe { &*state };
|
||||
assert_eq!(state.timeBudget_ns, 2_000_000_000);
|
||||
assert_eq!(state.runBudget_ns, 500_000_000);
|
||||
}
|
||||
|
||||
unsafe { BMK_freeTimedFnState(state) };
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn static_state_initialization_validates_its_buffer() {
|
||||
let mut shell = [0u64; BMK_TIMEDFNSTATE_SIZE / 8];
|
||||
let buffer: *mut c_void = shell.as_mut_ptr().cast();
|
||||
|
||||
// A properly sized and aligned buffer is accepted.
|
||||
let state = unsafe { BMK_initStatic_timedFnState(buffer, 64, 1_000, 100) };
|
||||
assert!(!state.is_null());
|
||||
assert_eq!(unsafe { BMK_isCompleted_TimedFn(state) }, 0);
|
||||
|
||||
// NULL, undersized, and misaligned buffers are rejected.
|
||||
let too_small = std::mem::size_of::<BMK_timedFnState_t>() - 1;
|
||||
unsafe {
|
||||
assert!(BMK_initStatic_timedFnState(ptr::null_mut(), 64, 1, 1).is_null());
|
||||
assert!(BMK_initStatic_timedFnState(buffer, too_small, 1, 1).is_null());
|
||||
assert!(
|
||||
BMK_initStatic_timedFnState(buffer.cast::<u8>().add(1).cast(), 63, 1, 1).is_null()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timed_runs_grow_the_workload_and_spend_the_budget() {
|
||||
let mut fixture = Fixture::new(&[16]);
|
||||
let params = fixture.params(None);
|
||||
let state = BMK_createTimedFnState(4, 2);
|
||||
assert!(!state.is_null());
|
||||
|
||||
let mut rounds = 0usize;
|
||||
while unsafe { BMK_isCompleted_TimedFn(state) } == 0 {
|
||||
let outcome = unsafe { BMK_benchTimedFn(state, params) };
|
||||
assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
|
||||
let run_time = BMK_extract_runTime(outcome);
|
||||
assert_eq!(run_time.sumOfReturn, 16);
|
||||
rounds += 1;
|
||||
assert!(rounds < 1_000, "the time budget must eventually be spent");
|
||||
}
|
||||
|
||||
{
|
||||
let state = unsafe { &*state };
|
||||
// A reported run had to last at least runBudget/2, which is only
|
||||
// reachable for this trivial function with a grown loop counter.
|
||||
assert!(state.nbLoops > 1);
|
||||
assert!(state.timeSpent_ns >= state.timeBudget_ns);
|
||||
}
|
||||
// Every reported outcome came from a run of >= runBudget/2, and the
|
||||
// budget accounting matches BMK_isCompleted_TimedFn.
|
||||
assert!(rounds >= 1);
|
||||
assert!(fixture.log.bench_calls >= rounds);
|
||||
|
||||
unsafe { BMK_freeTimedFnState(state) };
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timed_runs_propagate_errors_without_aborting() {
|
||||
let mut fixture = Fixture::new(&[9]);
|
||||
let params = fixture.params(Some(error_on_5));
|
||||
let state = BMK_createTimedFnState(1_000, 100);
|
||||
|
||||
let outcome = unsafe { BMK_benchTimedFn(state, params) };
|
||||
|
||||
assert_eq!(BMK_isSuccessful_runOutcome(outcome), 0);
|
||||
assert_eq!(BMK_extract_errorResult(outcome), 9);
|
||||
|
||||
unsafe { BMK_freeTimedFnState(state) };
|
||||
}
|
||||
}
|
||||
+147
-5
@@ -10,9 +10,15 @@
|
||||
//! writes, dictionary loading, streaming, and metadata preservation remain in
|
||||
//! `programs/fileio.c` for this first migration step.
|
||||
//!
|
||||
//! Benchmark mode (`-b`) parses here and dispatches through the
|
||||
//! `ZSTD_rust_cli_bench` bridge in `programs/zstdcli.c`: the run/timing loop
|
||||
//! (benchfn, timefn) is Rust, while orchestration and result formatting
|
||||
//! (`benchzstd.c`) remain C behind the preprocessor-gated bridge, so builds
|
||||
//! with `ZSTD_NOBENCH` never reference benchmark symbols.
|
||||
//!
|
||||
//! Remaining C-only CLI boundaries are called out in `unsupported()` below:
|
||||
//! benchmark execution, dictionary training, recursive/file-list expansion,
|
||||
//! tracing, alternate-format selection, and the advanced directory modes.
|
||||
//! dictionary training, recursive/file-list expansion, tracing,
|
||||
//! alternate-format selection, and the advanced directory modes.
|
||||
|
||||
use std::env;
|
||||
use std::ffi::{CStr, CString, OsStr, OsString};
|
||||
@@ -30,6 +36,7 @@ use std::os::unix::fs::FileTypeExt;
|
||||
const DEFAULT_CLEVEL: i32 = 3;
|
||||
#[cfg(feature = "compression")]
|
||||
const DEFAULT_MAX_CLEVEL: i32 = 19;
|
||||
const DEFAULT_BENCH_NB_SECONDS: u32 = 3;
|
||||
const DEFAULT_MEM_LIMIT: u32 = 1 << 27;
|
||||
const DEFAULT_LONG_WINDOW_LOG: u32 = 27;
|
||||
const MAX_FAST_ACCELERATION: i32 = 128 << 10;
|
||||
@@ -173,6 +180,22 @@ unsafe extern "C" {
|
||||
output: *const c_char,
|
||||
dict: *const c_char,
|
||||
) -> c_int;
|
||||
|
||||
/// Benchmark bridge implemented by the `programs/zstdcli.c` shim, which
|
||||
/// owns the `ZSTD_NOBENCH` preprocessor decision. Returns the benchmark
|
||||
/// result (>= 0), or -1 when benchmarking is compiled out.
|
||||
fn ZSTD_rust_cli_bench(
|
||||
file_names: *const *const c_char,
|
||||
nb_files: c_uint,
|
||||
dict_file_name: *const c_char,
|
||||
start_level: c_int,
|
||||
end_level: c_int,
|
||||
compression_params: *const ZSTD_compressionParameters,
|
||||
display_level: c_int,
|
||||
nb_seconds: c_uint,
|
||||
block_size: usize,
|
||||
nb_workers: c_int,
|
||||
) -> c_int;
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
@@ -180,6 +203,7 @@ enum Operation {
|
||||
Compress,
|
||||
Decompress,
|
||||
Test,
|
||||
Bench,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -230,6 +254,8 @@ struct Cli {
|
||||
row_match_finder: i32,
|
||||
exclude_compressed: bool,
|
||||
compression_params: ZSTD_compressionParameters,
|
||||
bench_end_level: Option<i32>,
|
||||
bench_nb_seconds: Option<u32>,
|
||||
unsupported_program: Option<String>,
|
||||
}
|
||||
|
||||
@@ -275,6 +301,8 @@ impl Cli {
|
||||
row_match_finder: ZSTD_PS_AUTO,
|
||||
exclude_compressed: false,
|
||||
compression_params: ZSTD_compressionParameters::default(),
|
||||
bench_end_level: None,
|
||||
bench_nb_seconds: None,
|
||||
unsupported_program: None,
|
||||
};
|
||||
|
||||
@@ -404,9 +432,22 @@ fn usage(advanced: bool) {
|
||||
out,
|
||||
" --adapt[=min=#,max=#], --rsyncable, --[no-]row-match-finder"
|
||||
);
|
||||
let _ = writeln!(out, "\nBenchmark options:");
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"\nNot yet migrated: benchmark, dictionary training, recursive/file-list expansion,"
|
||||
" -b# Benchmark file(s) at compression level #"
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
" -e# Test all levels from -b# up to # included"
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
" -i# Set the minimum evaluation time to # seconds"
|
||||
);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"\nNot yet migrated: dictionary training, recursive/file-list expansion,"
|
||||
);
|
||||
let _ = writeln!(out, "trace, alternate formats, and output-directory modes.");
|
||||
}
|
||||
@@ -905,6 +946,33 @@ fn parse_short_options(
|
||||
'd' => cli.operation = Operation::Decompress,
|
||||
'z' => cli.operation = Operation::Compress,
|
||||
't' => cli.operation = Operation::Test,
|
||||
'b' => cli.operation = Operation::Bench,
|
||||
'e' | 'i' => {
|
||||
// Benchmark range end (-e#) and duration (-i#): like the C
|
||||
// parser, digits attach directly and default to 0.
|
||||
let mut digits_end = offset + 1;
|
||||
while digits_end < bytes.len() && bytes[digits_end].is_ascii_digit() {
|
||||
digits_end += 1;
|
||||
}
|
||||
let digits = &value[offset + 1..digits_end];
|
||||
if option == 'e' {
|
||||
cli.bench_end_level = Some(if digits.is_empty() {
|
||||
0
|
||||
} else {
|
||||
parse_i32(digits, "benchmark end level")?
|
||||
});
|
||||
} else {
|
||||
cli.bench_nb_seconds = Some(if digits.is_empty() {
|
||||
0
|
||||
} else {
|
||||
digits
|
||||
.parse::<u32>()
|
||||
.map_err(|_| format!("invalid benchmark duration: {digits:?}"))?
|
||||
});
|
||||
}
|
||||
offset = digits_end;
|
||||
continue;
|
||||
}
|
||||
'c' => {
|
||||
cli.output = Some(cstring(STDOUT_MARK)?);
|
||||
cli.force_stdout = true;
|
||||
@@ -940,7 +1008,7 @@ fn parse_short_options(
|
||||
}
|
||||
break;
|
||||
}
|
||||
'b' | 'e' | 'i' | 'l' | 'p' | 'P' | 'r' | 's' | 'S' => {
|
||||
'l' | 'p' | 'P' | 'r' | 's' | 'S' => {
|
||||
unsupported(&format!("-{option}"))?;
|
||||
}
|
||||
_ => return Err(format!("unknown option -{option}")),
|
||||
@@ -1231,16 +1299,52 @@ unsafe fn run_decompress(
|
||||
dictionary,
|
||||
)
|
||||
},
|
||||
Operation::Compress => unreachable!("compression is dispatched separately"),
|
||||
Operation::Compress | Operation::Bench => {
|
||||
unreachable!("compression and benchmark are dispatched separately")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs benchmark mode through the C bridge. Level clamping against
|
||||
/// `ZSTD_maxCLevel()` happens on the C side, where the symbol is always
|
||||
/// available when benchmarking is compiled in. No input file means a
|
||||
/// synthetic-sample benchmark, matching the C CLI.
|
||||
fn run_bench(cli: &Cli) -> Result<i32, String> {
|
||||
let inputs: Vec<*const c_char> = cli.inputs.iter().map(|value| value.as_ptr()).collect();
|
||||
let dictionary = cli
|
||||
.dictionary
|
||||
.as_ref()
|
||||
.map_or(ptr::null(), |value| value.as_ptr());
|
||||
let result = unsafe {
|
||||
ZSTD_rust_cli_bench(
|
||||
inputs.as_ptr(),
|
||||
inputs.len() as c_uint,
|
||||
dictionary,
|
||||
cli.level,
|
||||
cli.bench_end_level.unwrap_or(cli.level),
|
||||
&cli.compression_params,
|
||||
cli.display_level,
|
||||
cli.bench_nb_seconds.unwrap_or(DEFAULT_BENCH_NB_SECONDS),
|
||||
cli.block_size.unwrap_or(0),
|
||||
// The C CLI benchmarks single-threaded unless -T was given.
|
||||
cli.workers.unwrap_or(1),
|
||||
)
|
||||
};
|
||||
if result < 0 {
|
||||
return Err("benchmark mode is not available in this build".to_owned());
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn run_cli(mut cli: Cli) -> Result<i32, String> {
|
||||
if let Some(program_name) = &cli.unsupported_program {
|
||||
return Err(format!(
|
||||
"{program_name} compatibility mode is not yet implemented by the Rust CLI frontend"
|
||||
));
|
||||
}
|
||||
if cli.operation == Operation::Bench {
|
||||
return run_bench(&cli);
|
||||
}
|
||||
let explicit_input_count = cli.inputs.len();
|
||||
filter_symlink_inputs(&mut cli);
|
||||
if explicit_input_count > 0 && cli.inputs.is_empty() {
|
||||
@@ -1347,6 +1451,7 @@ fn run_cli(mut cli: Cli) -> Result<i32, String> {
|
||||
#[cfg(not(feature = "decompression"))]
|
||||
unreachable!("unsupported decompression was rejected above")
|
||||
}
|
||||
Operation::Bench => unreachable!("benchmark mode was dispatched earlier"),
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1581,4 +1686,41 @@ mod tests {
|
||||
|
||||
assert!(error.contains("not yet implemented"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_mode_parses_level_duration_and_defaults() {
|
||||
let cli = parse(&["zstd", "-b1", "-i0", "input"]);
|
||||
|
||||
assert_eq!(cli.operation, Operation::Bench);
|
||||
assert_eq!(cli.level, 1);
|
||||
assert_eq!(cli.bench_nb_seconds, Some(0));
|
||||
assert_eq!(cli.bench_end_level, None);
|
||||
assert_eq!(
|
||||
cli.inputs
|
||||
.iter()
|
||||
.map(|input| input.as_bytes())
|
||||
.collect::<Vec<_>>(),
|
||||
vec![&b"input"[..]]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_range_aggregates_within_a_single_argument() {
|
||||
let cli = parse(&["zstd", "-b5e6i2", "input"]);
|
||||
|
||||
assert_eq!(cli.operation, Operation::Bench);
|
||||
assert_eq!(cli.level, 5);
|
||||
assert_eq!(cli.bench_end_level, Some(6));
|
||||
assert_eq!(cli.bench_nb_seconds, Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bench_duration_without_digits_defaults_to_zero() {
|
||||
let cli = parse(&["zstd", "-b", "-e", "-i"]);
|
||||
|
||||
assert_eq!(cli.operation, Operation::Bench);
|
||||
assert_eq!(cli.level, DEFAULT_CLEVEL);
|
||||
assert_eq!(cli.bench_end_level, Some(0));
|
||||
assert_eq!(cli.bench_nb_seconds, Some(0));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user