Performance

#include <stdio.h>
#include <time.h>

static double elapsed_seconds(struct timespec start, struct timespec end)
{
    return (double)(end.tv_sec - start.tv_sec)
         + (double)(end.tv_nsec - start.tv_nsec) / 1e9;
}

// volatile on the accumulator stops the optimizer deleting the whole loop as
// dead code -- the classic way a benchmark comes out at "0 nanoseconds".
static double workload(size_t iterations)
{
    volatile double sink = 0.0;

    for (size_t i = 1; i <= iterations; ++i) {
        sink += 1.0 / (double)i;
    }
    return sink;
}

int main(void)
{
    const size_t iterations = 5000000;
    const int repetitions = 5;

    // Warm up: first-run effects (page faults, cold caches, CPU frequency ramp)
    // routinely dominate a single measurement.
    (void)workload(iterations / 10);

    double best = 1e30;
    for (int r = 0; r < repetitions; ++r) {
        struct timespec start, end;

        if (timespec_get(&start, TIME_UTC) != TIME_UTC) {
            return 1;
        }
        (void)workload(iterations);
        if (timespec_get(&end, TIME_UTC) != TIME_UTC) {
            return 1;
        }

        double seconds = elapsed_seconds(start, end);
        if (seconds < best) {
            best = seconds;
        }
    }

    printf("best of %d: %.4f s (%.1f ns/iteration)\n",
           repetitions, best, best * 1e9 / (double)iterations);
    return 0;
}

# A release build worth copying:
$ clang -std=c23 -O2 -march=native -flto -DNDEBUG -Wall -Wextra -o app *.c

# A development build worth copying:
$ clang -std=c23 -Og -g -Wall -Wextra -Werror -fsanitize=address,undefined -o app *.c

#include <stddef.h>

// static inline in a header: the default choice. Every TU gets a private copy;
// unused copies are discarded, and the optimizer can specialize each call site.
static inline size_t round_up_to_multiple(size_t value, size_t multiple)
{
    return multiple == 0 ? value : ((value + multiple - 1) / multiple) * multiple;
}

// The compiler inlines plenty of functions never marked inline, and ignores the
// hint when the body is large or the call is cold. Force it only with a measurement:
[[gnu::always_inline]] static inline int fast_min(int a, int b)
{
    return a < b ? a : b;
}

// ...and the opposite, to keep a cold path out of the hot function's i-cache:
[[gnu::noinline]] static void report_failure(const char *message)
{
    (void)message;
}

int main(void)
{
    return (int)round_up_to_multiple(17, 8) + fast_min(1, 2) - 25;
}

#include <stddef.h>

// Without restrict, the compiler must assume out may alias a or b, so it reloads
// a[i] and b[i] after every write to out[i] -- and cannot vectorize.
void add_vectors_maybe_aliasing(size_t n, float *out, const float *a, const float *b)
{
    for (size_t i = 0; i < n; ++i) {
        out[i] = a[i] + b[i];
    }
}

// With restrict, the loads and stores are independent: the loop vectorizes.
void add_vectors(size_t n, float *restrict out,
                 const float *restrict a, const float *restrict b)
{
    for (size_t i = 0; i < n; ++i) {
        out[i] = a[i] + b[i];
    }
}

#include <stdio.h>

// [[unsequenced]]: no side effects, no dependence on any state, and the result
// depends only on the arguments -- the strongest promise (like GCC's "const").
[[unsequenced]] static int triple(int x)
{
    return x * 3;
}

// [[reproducible]]: no side effects observable by the caller, and equal arguments
// give equal results within one program run -- may read memory (like GCC's "pure").
[[reproducible]] static size_t length_of(const char *text)
{
    size_t n = 0;
    while (text[n] != '\0') {
        ++n;
    }
    return n;
}

int main(void)
{
    // The compiler may now evaluate triple(7) once and length_of(s) once,
    // hoisting either out of a loop.
    int total = 0;
    const char *s = "hello";

    for (int i = 0; i < 3; ++i) {
        total += triple(7) + (int)length_of(s);
    }

    printf("%d\n", total);
    return 0;
}

#include <stdio.h>

#define ROWS 512
#define COLS 512

static double grid[ROWS][COLS];

// Row-major traversal: consecutive iterations touch consecutive bytes, so each
// cache line is used fully. This is the fast one.
static double sum_rows_first(void)
{
    double total = 0.0;
    for (size_t r = 0; r < ROWS; ++r) {
        for (size_t c = 0; c < COLS; ++c) {
            total += grid[r][c];
        }
    }
    return total;
}

// Column-major traversal of a row-major array: every access is a new cache line.
// Same operation count, several times slower on any real machine.
static double sum_columns_first(void)
{
    double total = 0.0;
    for (size_t c = 0; c < COLS; ++c) {
        for (size_t r = 0; r < ROWS; ++r) {
            total += grid[r][c];
        }
    }
    return total;
}

int main(void)
{
    printf("%g %g\n", sum_rows_first(), sum_columns_first());
    return 0;
}

# Where the time goes (Linux). The first tool to reach for.
$ perf stat ./app                       # cycles, instructions, cache misses, IPC
$ perf record -g ./app && perf report   # per-function, with call graphs
$ perf annotate                         # per-instruction, next to the source

# Repeat a whole-program measurement properly:
$ perf stat -r 10 ./app
$ hyperfine './app --input big.dat'

# Instrumented profiling (needs -pg at build time):
$ gcc -std=c23 -O2 -pg -o app app.c && ./app && gprof ./app gmon.out | head -40

# Cache and branch simulation, no special build required:
$ valgrind --tool=cachegrind ./app
$ valgrind --tool=callgrind ./app && callgrind_annotate callgrind.out.*

# What the compiler actually generated:
$ clang -std=c23 -O2 -S -o - app.c | less        # assembly
$ objdump -d --demangle app | less               # disassembly of the binary

# Why a loop did (or did not) vectorize:
$ clang -std=c23 -O2 -Rpass=loop-vectorize -Rpass-missed=loop-vectorize -c app.c
$ gcc -std=c23 -O2 -fopt-info-vec-missed -c app.c

#include <stdio.h>

// The compiler may assume p is non-null: it has already been dereferenced, and
// dereferencing null would be UB. The later check can therefore be deleted.
static int surprising(int *p)
{
    int value = *p;             // if p were null, this is UB

    if (p == nullptr) {         // ...so the optimizer may remove this entirely
        return -1;
    }
    return value;
}

// Signed overflow is UB, so the compiler may assume i + 1 > i always holds,
// and treat this loop as infinite-or-terminating on the count alone.
static int count_up(int start, int limit)
{
    int steps = 0;
    for (int i = start; i < limit; ++i) {
        ++steps;
    }
    return steps;
}

int main(void)
{
    int value = 42;
    printf("%d %d\n", surprising(&value), count_up(0, 10));
    return 0;
}