Benchmarking kódu: přesné měření CPU a cache

# Benchmarking a profilování: přesné měření výkonu kódu

Optimalizace kódu bez objektivních dat vede k chybám. Přepsaná hash-funkce údajně pro zlepšení cache-lokalita zpomalila provádění o 15 %. Intuice klamá – jsou potřeba přesná měření času a událostí procesoru.

Framework pro benchmarking tento problém řeší: vícenásobné spuštění, statistická analýza, integrace s perf. To umožňuje odhalit skutečná úzká místa.

Vysoce přesné metody měření času

Standardní time() má rozlišení 1 sekundy – nepřijatelné pro mikrooptimalizace.

clock_gettime()

struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
run_test();
clock_gettime(CLOCK_MONOTONIC, &end);

long ns = (end.tv_sec - start.tv_sec) * 1000000000L +
          (end.tv_nsec - start.tv_nsec);

Výhody: nanosekundové rozlišení, odolnost vůči úpravám systémového času, přenositelnost POSIX.

Čítače taktů CPU (doporučeno)

RISC-V:

static inline uint64_t rdcycle(void) {
    uint64_t cycles;
    asm volatile ("rdcycle %0" : "=r" (cycles));
    return cycles;
}

x86_64:

static inline uint64_t rdtsc(void) {
    uint32_t lo, hi;
    asm volatile ("rdtsc" : "=a" (lo), "=d" (hi));
    return ((uint64_t)hi << 32) | lo;
}

ARM64:

static inline uint64_t rdcycle(void) {
    uint64_t val;
    asm volatile("mrs %0, pmccntr_el0" : "=r"(val));
    return val;
}

Rozlišení – 1 takt, bez overheadu systémových volání. Nevýhody: architekturově specifické, vliv na frekvence.

Statická analýza výsledků

Jeden průchod je zbytečný kvůli variacím cache, přerušením OS, větvením.

Základní statistika

#define ITERATIONS 1000
uint64_t times[ITERATIONS];
// ... vyplnění times ...

uint64_t min = times[0], max = times[0], sum = 0;
for (int i = 0; i < ITERATIONS; i++) {
    if (times[i] < min) min = times[i];
    if (times[i] > max) max = times[i];
    sum += times[i];
}
uint64_t mean = sum / ITERATIONS;

Rozšířená statistika

Mediána je odolná vůči výletům, standardní odchylka ukazuje stabilitu:

qsort(times, ITERATIONS, sizeof(uint64_t), compare_uint64);
uint64_t median = times[ITERATIONS / 2];

double variance = 0;
for (int i = 0; i < ITERATIONS; i++) {
    double diff = (double)times[i] - (double)mean;
    variance += diff * diff;
}
double stddev = sqrt(variance / ITERATIONS);

Klíčové metriky:

• Minimum: nejlepší případ (teplý cache)
• Mediána: typický výkon
• Stddev: variabilita
• Maximum: nejhorší případ

Framework pro benchmarking

Univerzální rozhraní pro opakované použití:

typedef struct {
    const char *name;
    void (*setup)(void);
    void (*run)(void);
    void (*teardown)(void);
} benchmark_t;

void benchmark_run(benchmark_t *bench, int iterations);

Implementace zahrnuje:

• Zahřívací průchod
• Vícenásobná měření
• Statický report

Příklad:

int array[1000];

void setup_array(void) {
    for (int i = 0; i < 1000; i++) {
        array[i] = i;
    }
}

void test_sequential_access(void) {
    volatile int sum = 0;
    for (int i = 0; i < 1000; i++) {
        sum += array[i];
    }
}

benchmark_t bench = {
    .name = "Sequential Array Access",
    .setup = setup_array,
    .run = test_sequential_access,
    .teardown = NULL
};

benchmark_run(&bench, 1000);

Analýza cache s perf

perf stat sleduje hardwarové čítače:

$ perf stat -e cache-references,cache-misses ./program
  1,234,567 cache-references
     12,345 cache-misses # 1.00% miss rate

Užitečné události:

• cache-references/misses: všechny úrovně
• L1-dcache-loads/misses: L1 data
• LLC-loads/misses: poslední úroveň

Porovnání struktur: pole – 1,2K missů, spojitý seznam – 45K missů (37x horší).

Integrace perf do frameworku

typedef struct {
    uint64_t cycles;
    uint64_t cache_references;
    uint64_t cache_misses;
    uint64_t l1_loads;
    uint64_t l1_misses;
} perf_counters_t;

Automatický sběr a agregace čítačů perf_event_open.

Typické problémy a řešení

Optimalizace kompilátoru

// Špatně: smyčka je odstraněna
int sum = 0;
for (...) sum += array[i];

// Dobře
volatile int sum = 0;

Chladný vs teplý cache

První průchod je pomalejší. Řešení: zahřátí + samostatná metrika.

Overhead měření

rdcycle() zabere ~10 taktů. Odečíst nebo dělat dlouhé testy.

Systémový šum

• Mnoho iterací
• Mediána místo průměru
• cpupower frequency-set -g performance
• taskset -c 0
• nice -n -20

Co je důležité

• Čítače CPU: rdtsc/rdcycle – zlatý standard přesnosti
• Statistika: mediána + stddev spolehlivější než průměr
• perf události: cache-misses odhalují problémy lokalita
• Zahřátí cache: povinné pro realistická měření
• Volatile: zabraňuje optimalizaci dead code

— Editorial Team