Профилирование и оптимизация

void handle_request(const Request& request) {
    parse(request);
    authorize(request);
    load_data(request);
    render_response(request);
}
// sampling profiler периодически снимает стек активного потока

void outer() {
    prepare();
    inner();
    finalize();
}
// inclusive outer включает inner, exclusive — только собственные участки outer

main
└─ serve_requests ███████████████████
   ├─ parse       ███
   └─ database    ██████████████
// ширина соответствует доле samples

auto started = std::chrono::steady_clock::now();
auto data = socket.read(); // поток большую часть времени заблокирован
auto elapsed = std::chrono::steady_clock::now() - started;

BenchmarkScenario scenario{
    .dataset = production_like_data(),
    .concurrency = 64,
    .duration = 60s
};
auto report = profile(service, scenario);

std::vector<Node> contiguous = load_nodes();
for (const Node& node : contiguous)
    sum += node.value;

std::list<Node> linked = load_list();
for (const Node& node : linked)
    sum += node.value;

struct Particle { float x, y, z, mass, temperature; };
std::vector<Particle> aos;

struct Particles {
    std::vector<float> x, y, z;
    std::vector<float> mass;
    std::vector<float> temperature;
} soa;
// горячий цикл использует только x, y и z

struct Counters {
    std::atomic<std::uint64_t> produced;
    std::atomic<std::uint64_t> consumed;
};
// соседние поля могут попадать в одну cache line и конкурировать между ядрами

for (const Item& item : items) {
    if (item.kind == unpredictable_kind())
        slow_path(item);
    else
        fast_path(item);
}

for (std::size_t i = 0; i < matrix.size(); ++i)
    sum += matrix[i];
// последовательные адреса используют уже загруженные cache lines

std::vector<Event> events;
events.reserve(expected_count);
for (auto&& source : sources)
    events.push_back(make_event(source));

auto direct = std::shared_ptr<Node>(new Node(args...));
auto combined = std::make_shared<Node>(args...);

// В типичной реализации combined размещает объект и control block
// в одном выделенном блоке.

std::vector<std::unique_ptr<Node>> build_tree(Input in) {
    std::vector<std::unique_ptr<Node>> nodes;
    for (auto token : in)
        nodes.push_back(std::make_unique<Node>(token));
    return nodes;
}
// allocation profiler покажет число, размер и места выделений

std::pmr::monotonic_buffer_resource arena(buffer, sizeof buffer);
std::pmr::vector<AstNode> nodes{&arena};
parse_into(nodes);
// все выделения освобождаются вместе с arena

struct ParticleValue {
    Position position;
    Velocity velocity;
};

struct ParticleShared {
    std::shared_ptr<State> state;
};

std::vector<ParticleValue> dense;
std::vector<ParticleShared> indirect;

static void benchmark(benchmark::State& state) {
    for (auto _ : state) {
        int sum = 0;
        for (int x : values) sum += x;
        // sum нигде не наблюдается
    }
}

for (int i = 0; i < warmup_iterations; ++i)
    run_once(dataset);

for (int i = 0; i < measured_iterations; ++i)
    samples.push_back(measure(dataset));

std::vector<double> samples;
for (int i = 0; i < 100; ++i)
    samples.push_back(measure(operation));
report(median(samples), percentile(samples, 0.95));