Performance Baselines

This document defines the performance targets and measurement methodologies for VeridianOS. All measurements are taken on reference hardware to ensure reproducibility.

Reference Hardware

Primary Test System

• CPU: AMD EPYC 7763 (64 cores, 128 threads)
• Memory: 256GB DDR4-3200 (8 channels)
• Storage: Samsung PM1733 NVMe (7GB/s)
• Network: Mellanox ConnectX-6 (100GbE)

Secondary Test Systems

• Intel: Xeon Platinum 8380 (40 cores)
• ARM: Ampere Altra Max (128 cores)
• RISC-V: SiFive Performance P650 (16 cores)

Core Kernel Performance

System Call Overhead

Context Switch Latency

Measured with two threads ping-ponging:

IPC Performance

Synchronous Messages

Throughput

Memory Management

Allocation Latency

Page Fault Handling

Scheduler Performance

Scheduling Latency

Load Balancing

I/O Performance

Disk I/O

Using io_uring with registered buffers:

Throughput

Network I/O

Using kernel bypass (DPDK):

Capability System

Operation Costs

Lookup Performance

With 10,000 capabilities in table:

Benchmark Configurations

Microbenchmarks

#![allow(unused)]
fn main() {
#[bench]
fn bench_syscall_null(b: &mut Bencher) {
    b.iter(|| {
        unsafe { syscall!(SYS_NULL) }
    });
}

#[bench]
fn bench_ipc_roundtrip(b: &mut Bencher) {
    let (send, recv) = create_channel();
    
    b.iter(|| {
        send.send(Message::default()).unwrap();
        recv.receive().unwrap();
    });
}
}

System Benchmarks

#![allow(unused)]
fn main() {
pub struct SystemBenchmark {
    threads: Vec<JoinHandle<()>>,
    metrics: Arc<Metrics>,
}

impl SystemBenchmark {
    pub fn run_mixed_workload(&self) -> BenchResult {
        // 40% CPU bound
        // 30% I/O bound  
        // 20% IPC heavy
        // 10% Memory intensive
        
        let start = Instant::now();
        // ... workload execution
        let duration = start.elapsed();
        
        BenchResult {
            duration,
            throughput: self.metrics.operations() / duration.as_secs_f64(),
            latency_p50: self.metrics.percentile(0.50),
            latency_p99: self.metrics.percentile(0.99),
        }
    }
}
}

Performance Monitoring

Built-in Metrics

#![allow(unused)]
fn main() {
pub fn collect_performance_counters() -> PerfCounters {
    PerfCounters {
        cycles: read_pmc(PMC_CYCLES),
        instructions: read_pmc(PMC_INSTRUCTIONS),
        cache_misses: read_pmc(PMC_CACHE_MISSES),
        branch_misses: read_pmc(PMC_BRANCH_MISSES),
        ipc: instructions as f64 / cycles as f64,
    }
}
}

Continuous Monitoring

#![allow(unused)]
fn main() {
pub struct PerformanceMonitor {
    samplers: Vec<Box<dyn Sampler>>,
    interval: Duration,
}

impl PerformanceMonitor {
    pub async fn run(&mut self) {
        let mut interval = tokio::time::interval(self.interval);
        
        loop {
            interval.tick().await;
            
            for sampler in &mut self.samplers {
                let sample = sampler.sample();
                self.record(sample);
                
                // Alert on regression
                if sample.degraded() {
                    self.alert(sample);
                }
            }
        }
    }
}
}

Optimization Guidelines

Hot Path Optimization

1. Minimize allocations: Use stack or pre-allocated buffers
2. Reduce indirection: Direct calls over virtual dispatch
3. Cache alignment: Align hot data to cache lines
4. Branch prediction: Organize likely/unlikely paths
5. SIMD usage: Vectorize where applicable

Example: Fast Path IPC

#![allow(unused)]
fn main() {
#[inline(always)]
pub fn fast_path_send(port: &Port, msg: &Message) -> Result<(), Error> {
    // Check if receiver is waiting (likely)
    if likely(port.has_waiter()) {
        // Direct transfer, no allocation
        let waiter = port.pop_waiter();
        
        // Copy to receiver's registers
        unsafe {
            copy_nonoverlapping(
                msg as *const _ as *const u64,
                waiter.regs_ptr(),
                8, // 64 bytes = 8 u64s
            );
        }
        
        waiter.wake();
        return Ok(());
    }
    
    // Slow path: queue message
    slow_path_send(port, msg)
}
}

Regression Testing

All performance-critical paths have regression tests:

[[bench]]
name = "syscall"
threshold = 50  # nanoseconds
tolerance = 10  # percent

[[bench]]
name = "ipc_latency"  
threshold = 1000  # nanoseconds
tolerance = 15    # percent

Automated CI runs these benchmarks and fails if regression detected.