Scalability Analysis

In this lesson, you will learn how to identify performance bottlenecks by measuring resource consumption across different scale tiers.

Beyond Micro-benchmarks

While criterion or divan are excellent for identifying algorithmic inefficiencies in small functions, they rarely capture the behavior of a system at "production scale." Scalability analysis requires us to observe how resource consumption (CPU, memory, file descriptors, and network buffers) changes as we increase the input load or concurrent request volume.

The core challenge is identifying where the system stops scaling linearly. A system that uses 50MB of memory for 100 users but 2GB for 200 users is exhibiting non-linear growth—usually indicating a memory leak or an unoptimized data structure in your state persistence layer.

Measuring Across Scale Tiers

To conduct effective scalability analysis, you must perform "Stress-to-Failure" tests on different tiers (e.g., 1k, 10k, and 100k requests/sec). You need to capture system metrics alongside your telemetry. In Rust, you can integrate lightweight resource accounting using the sysinfo crate to monitor process-wide usage during these tests:

use sysinfo::{Pid, ProcessExt, System, SystemExt};

fn record_resource_usage(pid: Pid) {
    let mut sys = System::new_all();
    sys.refresh_process(pid);
    
    if let Some(process) = sys.process(pid) {
        println!("CPU usage: {}%", process.cpu_usage());
        println!("Memory usage: {} bytes", process.memory());
    }
}

Identifying the Bottleneck

As you increase the scale tier, keep an eye on your resource consumption patterns:

1. CPU-Bound: If CPU usage spikes significantly while throughput plateaus, you are likely hitting contention in your async runtime or synchronization primitives (like Mutex or RwLock).
2. Memory-Bound: If memory usage grows linearly with the number of open connections, check your backpressure design and lifecycle monitoring to ensure objects are being dropped correctly after processing.
3. IO-Bound: If resource usage remains low but throughput drops, your system is waiting on network or disk I/O, suggesting the need for more efficient tokio task distribution or batching.

By mapping these consumption levels against your scale tiers, you can isolate exactly which subsystem begins to degrade first.

Key Takeaway: Scalability analysis identifies bottlenecks by mapping how resource consumption grows as you push the system through increasing throughput tiers, allowing you to distinguish between efficient scaling and resource exhaustion.