src/memory.rs - master - teterkin/vm_load_testing

src/memory.rs
78 строк3 KB
alexefan136
upload files
12 ноя 2025, 18:00
12 ноя 2025, 18:00eb766a0
// src/memory.rs

use std::time::Instant;
use sysinfo::{System, SystemExt};

#[derive(Debug, Clone)]
pub struct MemoryResult {
    pub total_ram_mib: u64,
    pub tested_size_mib: usize,
    pub write_bandwidth_gib_s: f64,
    pub read_bandwidth_gib_s: f64,
    pub latency_ns: f64,
    pub checksum: u64,
}

/// Выполняет бенчмарк оперативной памяти.
pub fn bench_memory() -> MemoryResult {
    // Собираем общий объём RAM
    let mut sys = System::new_all();
    sys.refresh_memory();
    let total_ram_mib = sys.total_memory() / 1024 / 1024;

    // Тестируем 256 MiB (адаптивно можно увеличить, но 256 — безопасно для всех ВМ)
    const TEST_SIZE_BYTES: usize = 256 * 1024 * 1024; // 256 MiB
    let tested_size_mib = TEST_SIZE_BYTES / 1024 / 1024;

    // Выделяем память
    let mut data = vec![0u8; TEST_SIZE_BYTES];

    // === Запись: bandwidth ===
    let start = Instant::now();
    for chunk in data.chunks_mut(64 * 1024) { // 64 KiB chunks for cache efficiency
        for b in chunk.iter_mut() {
            *b = rand::random();
        }
    }
    let write_time = start.elapsed().as_secs_f64();
    let write_gib_s = (TEST_SIZE_BYTES as f64 / (1024.0 * 1024.0 * 1024.0)) / write_time;

    // === Чтение: bandwidth + checksum ===
    let start = Instant::now();
    let mut checksum: u64 = 0;
    for &b in &data {
        checksum = checksum.wrapping_add(b as u64);
    }
    let read_time = start.elapsed().as_secs_f64();
    let read_gib_s = (TEST_SIZE_BYTES as f64 / (1024.0 * 1024.0 * 1024.0)) / read_time;

    // === Задержка (latency) через pointer-chasing ===
    let latency_ns = estimate_memory_latency();

    MemoryResult {
        total_ram_mib,
        tested_size_mib,
        write_bandwidth_gib_s: write_gib_s,
        read_bandwidth_gib_s: read_gib_s,
        latency_ns,
        checksum,
    }
}

/// Оценивает задержку доступа к памяти (в наносекундах) методом pointer-chasing.
fn estimate_memory_latency() -> f64 {
    const N: usize = 1_000_000;
    let mut indices: Vec<usize> = (0..N).collect();
    use rand::seq::SliceRandom;
    indices.shuffle(&mut rand::thread_rng());

    let mut ptr = 0;
    let start = Instant::now();
    for _ in 0..N {
        // Принудительное чтение по указателю — обходит speculative execution
        ptr = indices[ptr % N];
        std::hint::black_box(ptr); // предотвращает оптимизацию
    }
    let elapsed_ns = start.elapsed().as_nanos() as f64;
    elapsed_ns / N as f64
}