Free to read · Three levels

Linux performance tuning: measure, explain, and verify

A complete performance track that connects service goals to CPU, memory, storage, network, profiling, capacity, and reversible tuning evidence.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Learn to diagnose Linux performance through mechanisms and matched measurements. Eighteen developed lessons progress from baselines and resource interpretation to perf, PSI, cgroup policy, application correlation, NUMA, eBPF design, profiling, capacity planning, and controlled tuning.

This track builds on general Linux knowledge and focuses on performance reasoning rather than basic administration. Examples use synthetic values or prepared disposable labs; every block is non-runnable, and no lesson changes host kernel settings, services, firewalls, or generates load.

What you will learn

  • Define comparable baselines, useful throughput, latency distributions, and scope.
  • Diagnose CPU, scheduling, memory, I/O, network, and scoped-policy constraints.
  • Plan bounded profiling, tracing, and isolated capacity experiments.
  • Evaluate reversible changes while preserving correctness and recovery reserve.

Your learning path

Three levels

Basic: measurement and resource signals

Build comparable baselines and interpret latency, CPU, memory, storage, and network evidence.

  1. Build a trustworthy performance baseline
  2. Interpret latency, throughput, and queues
  3. Separate CPU utilization, load, and steal
  4. Read memory use without fearing cache
  5. Separate storage latency from utilization
  6. Measure the network path and application boundary
Explore this level

Intermediate: mechanism and scoped diagnosis

Connect perf, scheduling, pressure, writeback, managed budgets, and application waits.

  1. Use perf counters to test CPU hypotheses
  2. Find scheduling and synchronization delay
  3. Diagnose memory pressure and OOM boundaries
  4. Trace writeback and filesystem delay
  5. Read effective cgroup and systemd budgets
  6. Connect Linux evidence to application waits
Explore this level

Advanced: topology, observability, and controlled tuning

Reason about NUMA, eBPF, profiles, network scaling, capacity, and reversible experiments.

  1. Reason about NUMA locality and page size
  2. Design bounded eBPF observations
  3. Interpret call graphs and off-CPU time
  4. Trace network scaling through queues and CPUs
  5. Design capacity tests without misleading results
  6. Deliver reversible, evidence-based tuning
Explore this level

Who this is for

  • Developers and operators who already understand Linux processes, files, services, and command-line tools.
  • Engineers learning to justify performance and capacity decisions with evidence.

Before you start

  • General Linux shell, process, permission, storage, and networking foundations.
  • Basic arithmetic, rates, and application request/response concepts.

Related technical solutions

Separate high CPU, high load, and guest stealDiagnose a slow fictional report service by separating execution demand, blocked work, scoped budgets, and virtual-machine scheduling.Distinguish memory pressure, OOM, and useful cacheExplain a fictional service’s memory alarm using availability, reclaim, PSI, scope-specific events, and actual request impact.Distinguish high I/O latency from saturationTrace a slow synthetic report write across application waits, writeback, filesystem operations, and device queues before changing storage policy.