Rust for Server Performance Analysis Course

Lesson 1 • Error Handling and Control Flow

Teaches Result, Option, and the ? operator for explicit error propagation. Connects reliable error handling to observable server behavior under load.

Lesson 2 • Types, Traits, and Generics

Introduces Rust's type system, trait-based polymorphism, and monomorphization. Shows how zero-cost abstractions are achieved at compile time.

Lesson 3 • Ownership, Borrowing, and Lifetimes

Covers Rust's core memory model: ownership transfer, shared vs. exclusive borrows, and lifetime annotations. Establishes the safety guarantees that underpin all subsequent performance work.

Lesson 1 • Threads and Shared-State Concurrency

Covers thread spawning, Arc, Mutex, and RwLock for safe shared state. Establishes the baseline concurrency model before introducing async abstractions.

Lesson 2 • Tokio Runtime Internals

Examines Tokio's work-stealing scheduler, task spawning, and I/O driver. Provides the runtime knowledge required to interpret profiling data from async servers.

Lesson 3 • Message Passing with Channels

Teaches mpsc and bounded channels as an alternative to shared state. Connects channel design choices to latency and throughput trade-offs in server pipelines.

Lesson 4 • Synchronization Patterns Under Load

Analyzes contention on locks and channels at high concurrency and introduces lock-free alternatives. Directly prepares students for identifying synchronization bottlenecks.

Lesson 1 • Stack vs. Heap Allocation

Contrasts stack and heap allocation costs and explains when each occurs in Rust. Grounds later profiling work in concrete allocation mechanics.

Lesson 2 • Collections and Allocation Patterns

Analyzes Vec, HashMap, and String growth strategies and their allocation implications. Teaches pre-allocation and pooling techniques to reduce GC-equivalent pauses.

Lesson 3 • Struct Layout and Padding

Teaches field ordering, alignment rules, and repr attributes that control struct layout. Shows how layout choices affect cache line utilization and SIMD readiness.

Lesson 1 • Benchmarking with Criterion

Covers statistical benchmarking using Criterion: setup, measurement, and regression detection. Establishes the baseline measurement discipline required before any optimization.

Lesson 2 • Metrics Collection and Dashboards

Covers counter, gauge, and histogram metrics using the metrics crate and Prometheus export. Enables continuous performance visibility in production-like environments.

Lesson 3 • CPU Profiling with perf and Flamegraphs

Teaches sampling-based CPU profiling using perf and flamegraph visualization. Connects hot function identification to targeted optimization decisions.

Lesson 4 • Heap Profiling and Leak Detection

Uses heaptrack and Valgrind Massif to track allocation frequency and peak memory. Identifies allocation hot spots that degrade server throughput under sustained load.

Lesson 1 • Syscall Overhead and Buffering

Quantifies the cost of read/write syscalls and demonstrates buffered I/O strategies. Establishes why minimizing syscall frequency is critical for high-throughput servers.

Lesson 2 • TLS Performance Overhead

Analyzes TLS handshake cost, session resumption, and cipher suite selection using rustls. Quantifies the performance impact of encryption and identifies mitigation strategies.

Lesson 3 • Async I/O with Tokio and io_uring

Compares epoll-based async I/O with io_uring submission queues for reduced syscall overhead. Shows how to select and configure the I/O backend for target workloads.

Lesson 4 • Zero-Copy Techniques

Teaches sendfile, splice, and Bytes-based buffer sharing to eliminate unnecessary data copies. Directly reduces CPU usage and memory bandwidth in file-serving and proxy workloads.

Lesson 1 • Cache Efficiency and Data Locality

Teaches cache hierarchy awareness, prefetching, and data structure layout for cache-friendly access. Demonstrates measurable throughput gains from improved spatial and temporal locality.

Lesson 2 • SIMD and Vectorization in Rust

Introduces portable SIMD via std::simd and target-specific intrinsics for data-parallel operations. Applies vectorization to parsing, hashing, and serialization hot paths.

Lesson 3 • Compiler Optimization Flags and LTO

Explains opt-level, codegen-units, and link-time optimization settings in Cargo profiles. Shows how each flag affects binary size, compile time, and runtime performance.

Lesson 4 • Inlining, Devirtualization, and PGO

Controls inlining with attributes, eliminates dynamic dispatch, and applies profile-guided optimization. Demonstrates how each technique reduces instruction count in tight server loops.

Lesson 1 • Load Testing and Capacity Planning

Uses wrk, drill, and Grafana k6 to drive load and identify saturation points. Translates load test results into capacity planning decisions and optimization priorities.

Lesson 2 • Axum Router and Extractor Performance

Profiles Axum's routing tree, extractor chain, and state injection overhead. Teaches patterns to minimize per-request allocations and extractor computation.

Lesson 3 • Hyper and HTTP/1.1 Pipeline Internals

Examines Hyper's connection lifecycle, request parsing, and response writing paths. Identifies framework-level overhead that can be reduced through configuration and custom middleware.

Lesson 4 • Serialization and Deserialization Tuning

Benchmarks serde_json, simd-json, and rkyv for request and response payloads. Selects the appropriate serialization strategy based on payload size and latency requirements.

Lesson 1 • Database Query and Connection Pool Tuning

Analyzes sqlx and diesel query execution, connection pool sizing, and prepared statement caching. Reduces database-induced latency spikes that dominate server response time.

Lesson 2 • Caching Strategies for Server Performance

Implements in-process LRU caches and distributed caches to reduce redundant computation and I/O. Quantifies cache hit rate impact on throughput and tail latency.

Lesson 3 • Performance Regression Testing in CI

Integrates Criterion benchmarks and load tests into CI pipelines with automated regression gates. Prevents performance degradation from reaching production through systematic gating.

Lesson 4 • Architectural Trade-offs and Optimization Strategy

Frames performance optimization as an economic decision using profiling data and business constraints. Teaches students to prioritize changes by impact, risk, and implementation cost.