Struct VerifyOptions 

pub struct VerifyOptions {
    pub parallelism: usize,
    pub throttle: Option<Duration>,
    pub rate_limiter: Option<Arc<RateLimiter>>,
}

Options for the block-checksum scrubber (verify_block_checksums_with / AbstractTree::verify_checksum_with).

Fields

parallelism: usize

Number of SSTs to scan concurrently. Clamped to >= 1 and to the table count. 1 (the default) scans sequentially in table order with no thread spawn. Per-SST scans are independent (each opens its own file through the table’s Fs handle), so they parallelize cleanly.

throttle: Option<Duration>

Minimum delay each worker waits after finishing one SST before taking the next, capping I/O pressure on a production box during a scrub. None (default) runs at full speed.

rate_limiter: Option<Arc<RateLimiter>>

The budget the scan reads under: every block and raw section is charged its on-disk bytes before it is read, through this one limiter for all parallelism workers. Shared, so a caller can retune it live or draw it from the same budget as compaction. None (default) reads at full speed. Only a std build waits on it.

The scan reports how long each charged read took, so a limiter with a LatencyBackoff backs the scan off while the device is slow to answer. The backoff lowers what the limiter grants to every holder: on a budget shared with compaction it slows compaction too, so a scan that should back off alone gets a limiter of its own.

Implementations

impl VerifyOptions

pub const fn parallelism(self, workers: usize) -> Self

Sets the number of SSTs to scan concurrently.

pub const fn throttle(self, delay: Duration) -> Self

Sets the per-worker inter-SST throttle delay.

pub fn rate_limiter(self, limiter: Arc<RateLimiter>) -> Self

Reads the scan under limiter (see Self::rate_limiter).

Examples

use lsm_tree::rate_limiter::RateLimiter;
use lsm_tree::verify::VerifyOptions;
use std::sync::Arc;

// One budget for the scrub and compaction, retuned live.
let budget = Arc::new(RateLimiter::new(64 << 20));
let opts = VerifyOptions::default().rate_limiter(Arc::clone(&budget));
budget.set_rate(16 << 20);
assert_eq!(opts.rate_limiter.map(|l| l.rate()), Some(16 << 20));

pub fn max_bytes_per_sec(self, bytes_per_sec: u64) -> Self

Reads the scan at no more than bytes_per_sec on-disk bytes per second, under a limiter of its own; 0 reads at full speed.

Trait Implementations

impl Clone for VerifyOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VerifyOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for VerifyOptions

fn default() -> Self

Returns the “default value” for a type.