dev-stress 0.1.0

What it does

dev-stress measures how a workload behaves when scaled up: thousands of concurrent operations, millions of iterations, sustained pressure.

It detects:

• Throughput collapse under concurrency
• Lock contention (via thread-time variance)
• Latency cliff-falls
• Sustained-load instability

It does NOT do:

• Single-threaded micro-benchmarking (use dev-bench)
• Async-specific issue detection (use dev-async)
• Failure injection (use dev-chaos)

Quick start

[dependencies]
dev-stress = "0.1"

use dev_stress::{Workload, StressRun};

#[derive(Clone)]
struct MyWorkload;
impl Workload for MyWorkload {
    fn run_once(&self) {
        std::hint::black_box(40 + 2);
    }
}

let run = StressRun::new("hot_path")
    .iterations(100_000)
    .threads(8);

let result = run.execute(&MyWorkload);
println!("ops/sec: {}", result.ops_per_sec());
println!("thread CV: {}", result.thread_time_cv());

let check = result.into_check_result(None);

Thread-time CV

The coefficient of variation across thread elapsed times is the clearest signal that a workload is contention-bound:

• CV near 0: threads finished at nearly the same time. Healthy.
• CV > 0.2: significant variance. Some threads were waiting on locks or contended resources.
• CV > 0.5: severe contention. Investigate.

What's planned

• Latency percentile tracking (p50/p95/p99) per operation, not just per thread.
• Long-running soak tests with periodic checkpoint reports.
• Memory pressure tracking.
• CPU saturation detection.

License

Apache-2.0. See LICENSE.