This article provides a comprehensive guide to Linux performance analysis tools, covering vmstat, iostat, dstat, iotop, pidstat, top, htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and advanced tools like eBPF, bcc, and Flame Graphs, with usage examples and output interpretation.
This article explains how reading compiler-generated assembly helps C++ developers verify optimizations like SIMD vectorization, function inlining, and memory layout efficiency, using tools like perf and Compiler Explorer to replace guesswork with evidence-based performance tuning.
This article teaches Linux performance troubleshooting beyond top, covering vmstat, mpstat, pidstat, iostat, sar, perf, and bpftrace with real-world scenarios, key metrics, step-by-step diagnosis flows, and practical fixes for CPU, memory, disk, network, and context-switch issues.
This article walks through a systematic, three‑stage method—starting with a 60‑second global scan using uptime, top, vmstat and mpstat, then pinpointing the offending process and thread with pidstat, perf and strace, and finally classifying the root cause to apply the appropriate fix—so you can diagnose and resolve Linux CPU spikes without resorting to blind restarts.
This article compiles a comprehensive guide to Linux performance analysis utilities, covering basic commands like vmstat, iostat, dstat, top, htop, and advanced tools such as perf, eBPF, Flame Graphs, and sar, with usage examples, output explanations, and practical tips for system monitoring and tuning.
When a production service shows 100% CPU usage, this guide walks you through a rapid three‑minute workflow—identifying the affected scope, distinguishing user, system, iowait, steal and softirq metrics, and using Linux, systemd, Docker/Kubernetes and language‑specific tools to pinpoint the offending process, thread, or system call before taking corrective actions such as throttling, scaling, or rolling back.
When a Linux server’s CPU spikes to 100 %, this article walks through a systematic investigation—from defining what “CPU 100 %” really means, gathering timestamps and metrics, using tools like top, mpstat, vmstat, pidstat, sar, perf, and strace, to tracing processes, threads, containers, and Kubernetes, building an evidence chain, applying low‑risk fixes, and verifying the resolution.
When a thumbnail service experienced sudden latency spikes and OOM kills shortly after a new release, the author walks through a systematic investigation using free, smem, pmap, and perf to distinguish true memory leaks from page‑cache or shared‑page artifacts, pinpoint the native decoder buffer issue, and outline remediation steps.
This article presents a systematic, evidence‑driven process for locating and resolving high CPU usage on Linux servers, covering environment preparation, layered troubleshooting from whole‑machine to thread level, concrete command examples, real‑world case studies, best‑practice recommendations, and monitoring configurations.
This article presents a systematic, USE‑methodology‑based workflow for diagnosing Linux performance issues, covering CPU, memory, disk I/O and network bottlenecks with step‑by‑step commands, detailed examples, scripts, case studies, best‑practice recommendations and monitoring guidelines.
This article provides a comprehensive guide to essential Linux performance and observability commands—such as vmstat, iostat, dstat, iotop, pidstat, top/htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and sar—explaining their purpose, typical usage syntax, and how to interpret their output for effective system monitoring and tuning.
The article walks through six concrete, reproducible methods for diagnosing and improving Linux CPU performance—including using perf for profiling, binding processes to specific cores, adjusting scheduling priorities, setting the CPU governor, leveraging NUMA awareness, and fine‑tuning kernel scheduler parameters—while showing real command examples and measured impact.
This guide walks through a systematic, step‑by‑step process for identifying, analyzing, and resolving memory‑related incidents in a high‑traffic thumbnail generation service running in Kubernetes, covering everything from initial symptom checks with free and vmstat to deep dives using smem, pmap, smaps, perf, and post‑mortem verification.
This guide presents a systematic, four‑dimensional USE methodology for diagnosing Linux performance issues, walking through quick 60‑second overviews with top, vmstat, iostat and ss, then diving into detailed CPU, memory, disk I/O and network investigations using tools such as mpstat, perf, bpf, and flame graphs.
A detailed post‑mortem of a high‑priority fault on AMD servers shows how a split‑lock triggered by Python UDFs caused CPI spikes, CPU overload, and bus‑lock events, and explains the investigation steps, code analysis, reproduction tests, and mitigation measures taken to restore stability.
CPU caches bridge the speed gap between processors and memory, but cache misses can dramatically degrade performance, especially under high concurrency or big‑data workloads; this article explains cache architecture, common miss causes, diagnostic tools like perf and cachestat, and practical optimization techniques for Linux systems.
This article explains the technical principles behind Linux kernel tracing, covering static tracepoints and dynamic kprobes, demonstrating their use with ftrace and perf, and detailing the underlying macro implementations and low‑level mechanisms that make kernel source tracking possible.
This article explains how to locate and monitor kernel execution using IDE navigation, Linux tracing tools such as ftrace, perf, tracepoints, and kprobes, and dives into the underlying implementation details of static and dynamic tracing mechanisms.
Learn a step‑by‑step Linux CPU high‑usage diagnostic guide covering ten root causes, quick monitoring commands, deep analysis with top, ps, strace, perf, and flamegraphs, plus practical remediation and long‑term monitoring setup using sar and Prometheus to prevent future spikes.
This comprehensive guide explains Linux CPU performance fundamentals, key metrics like load average and utilization, common bottlenecks, and step‑by‑step usage of tools such as top, htop, vmstat, iostat, perf, and stress, followed by practical tuning techniques and real‑world case studies for developers and system administrators.
This article explains the fundamentals of NUMA architecture, why it matters for multithreaded Linux applications, and provides step‑by‑step practical guidance—including kernel internals, memory allocation policies, useful commands, and performance‑monitoring tools—to help developers optimize memory locality and boost overall program efficiency.
This guide introduces a comprehensive set of Linux performance monitoring utilities—including vmstat, iostat, dstat, iotop, pidstat, top, htop, mpstat, netstat, ps, strace, uptime, lsof, and perf—explaining their purpose, key options, and example commands for effective system analysis and optimization.
The article explains what page faults are, why they become performance killers, and provides practical Linux tools and tuning steps—perf, vmstat, ftrace, swappiness, mlock, and swapoff—to quantify and mitigate both major and minor page faults.
This article explains what page faults are, why frequent faults degrade performance, how to measure them with Linux tools like perf, vmstat, and ftrace, and provides practical solutions ranging from memory upgrades to kernel parameter tuning.
The article introduces Linux’s built‑in performance analysis tool perf, explains its event‑driven sampling, tracing and profiling capabilities, shows how to install it on various distributions, demonstrates common commands with real code examples, and discusses practical scenarios for locating and optimizing kernel and application performance issues.
This article explains the Linux kernel’s perf utility, covering its architecture, key features such as lightweight event sampling, tracing, profiling and debugging, step‑by‑step installation, common commands with real code examples, and how to use perf and flame graphs to locate and optimise performance bottlenecks.
This article explains Linux CPU cache architecture—from physical and logical cores, through L1/L2/L3 hierarchy and cache‑line basics, to write‑through/write‑back policies and coherence mechanisms—while demonstrating practical analysis with Valgrind and perf tools.
After upgrading an RDS MySQL instance from 5.6 to 8.0, the same ORDER BY query became dozens of times slower, and this article walks through step‑by‑step analysis, profiling, source‑code inspection, and the root cause behind the performance regression.
This article investigates two real‑world performance incidents—one caused by excessive disk I/O from a misconfigured Filebeat and another by kernel memory‑fragmentation bugs triggered by a trace feature—detailing observations, Linux diagnostic commands, analysis, and practical remediation steps.
This article introduces Linux perf, explains how to install it, demonstrates basic commands such as perf‑list, perf‑stat, perf‑top, perf‑record and perf‑report, and shows how to combine perf with flame‑graphs to locate CPU‑bound hotspots and other performance bottlenecks in applications and the kernel.
This article introduces a range of essential Linux performance analysis utilities—including vmstat, iostat, dstat, iotop, top/htop, mpstat, netstat, ps, strace, uptime, lsof, perf, and sar—explains their core options, shows example commands, and clarifies which metrics each tool reports to help engineers monitor and troubleshoot system behavior.
This article provides a comprehensive overview of Linux kernel debugging, covering core tools such as printk, ftrace, trace‑cmd, kprobe, systemtap, kgdb, kgtp, perf, as well as pseudo filesystems like procfs, sysfs, debugfs and relayfs, and introduces additional tracers including LTTng, eBPF, Ktap, dtrace4linux, OL DTrace and sysdig.
This comprehensive guide explores Linux kernel debugging essentials, covering pseudo filesystems like procfs, sysfs, debugfs, relayfs, and advanced tracing tools such as ftrace, kprobe, systemtap, perf, KGTP, and LTTng, with practical commands and reference links.
This comprehensive guide introduces Linux perf, explains its core components, walks through essential commands, demonstrates real‑world use cases such as CPU, memory, and I/O analysis, shows how to generate flame graphs, and provides advanced tips and troubleshooting for accurate performance profiling on Linux systems.
Linux perf is a powerful, flexible profiling tool that lets developers and system administrators monitor hardware and software events, analyze CPU, memory, and I/O performance, generate flame graphs, and troubleshoot bottlenecks across single processes, containers, and multi‑core systems, with extensive commands and advanced techniques.
This article explains the concepts and mechanisms behind Linux kernel tracing tools—including ftrace, perf, kprobes, uprobes, tracepoints, ftrace, perf events, and eBPF—showing how probes are injected, how trace data is collected, and which technology to choose for different debugging and performance scenarios.
Using a step‑by‑step example program, this article shows how to dramatically improve Linux pipe read/write performance—from an initial 3.5 GiB/s to 65 GiB/s—by applying zero‑copy techniques, ring buffers, paging insights, vmsplice/splice system calls, huge pages, and busy‑loop optimizations.
Using eBPF to bypass traditional bridge, netfilter, and routing steps, this article demonstrates how container network packet forwarding can be accelerated, reducing receive and transmit latency by around 40‑82%, with detailed perf‑ftrace analysis, code examples, and performance comparisons of three forwarding modes.
This article provides a comprehensive guide to Linux performance monitoring, covering essential tools such as vmstat, iostat, dstat, iotop, pidstat, top/htop, mpstat, netstat, ps, strace, perf and sar, with usage examples, command syntax, and explanations of the metrics they report.
This comprehensive guide explains Linux kernel performance profiling—both on‑CPU and off‑CPU—by stressing the need to target the critical 3 % of code, covering throughput, latency and power metrics, scalability laws, flame‑graph visualizations, perf and eBPF tools, lock‑contention analysis, and further reading recommendations.
The article explains how a MySQL 5.6 master‑slave setup experienced growing replication lag on an off‑site replica, how the issue was traced to page‑compression on a large table using show slave status, perf and pstack, and how disabling compression resolved the delay.
This article provides a comprehensive guide to game pressure testing, covering the full workflow from requirement communication and test planning to execution, performance analysis using tools like LuaProfiler, Perf, and VTune, and detailed result interpretation with case studies.
In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.
This article explains how to diagnose a sudden rise in MySQL file handle usage by reproducing the issue with large tables, using Linux perf to trace open system calls, analyzing hash join behavior, and querying performance_schema.file_instances to pinpoint the underlying cause.
This tutorial demonstrates how to reproduce a MySQL memory‑spike bug, monitor the process with Linux perf to capture mmap system calls, and analyze the resulting perf.out to identify which SQL statements trigger large memory allocations, while also discussing the method’s limitations.
This article explains Linux's sophisticated scheduling system for multi‑core, SMP, and NUMA architectures, describes global, clustered, partitioned, and arbitrary schedulers, details scheduling domains and load‑balancing mechanisms, and provides practical performance‑tuning techniques using tools like perf, flame graphs, and various kernel optimizations.
This article explains how Linux tracing tools such as kprobes, uprobes, tracepoints, eBPF, perf, ftrace, sysdig, SystemTap and LTTng fit together, describing their data sources, collection mechanisms and front‑ends, and offers guidance on choosing the right tool for low‑overhead debugging and performance analysis.
This guide introduces several Linux performance monitoring tools—nmon, perf, top, iostat, sar, dstat, and htop—explaining their functions, key metrics, and installation commands for use on a Huawei Kunpeng server. It also shows how to generate flame graphs with perf and highlights htop's interactive advantages.
This guide walks through dozens of Linux performance‑monitoring utilities—including top, perf, sar/ksar, mpstat, uptime, vmstat, pidstat, htop, atop, glances, nmon, pcp‑gui, collectl, and colplot—explaining what each tool measures, how to invoke it, key command‑line options, sample outputs, and where to find further documentation.
This article explains how to install perf and FlameGraph tools on Linux, capture profiling data from MySQL using various perf record options, convert the binary output to a readable script, and generate an SVG flame graph for visual performance analysis, including example commands and interpretation tips.
This article explains how Linux reports CPU usage with tools like top, the meaning of the fields in /proc/stat, how utilization percentages are calculated, the concepts of run queues, load average, context switching, multi‑core scheduling, and how to use perf and taskset for deeper performance analysis.
This article introduces practical CPU and memory subsystem performance tuning for Kunpeng processors, covering optimization concepts, key parameters, common monitoring tools such as top, perf and numactl, and detailed methods like NUMA binding, prefetch control, timer tuning, TLB page size adjustment, and thread concurrency optimization.
This article documents a multi‑stage investigation of intermittent GitLab Runner build timeouts and hangs, describing the background, VM configuration, successive diagnostic steps using strace, iotop, perf, and storage‑driver adjustments, and concludes with performance test results and lessons learned.
This article explains why the traditional %CPU metric can be deceptive, describes how CPU stalls and memory bottlenecks affect perceived utilization, and offers practical guidance on using IPC and performance counters to obtain a more accurate view of system performance.
This article introduces Linux’s built‑in Perf tool, explains its architecture and hardware counters, walks through practical examples—including basic commands, statistical summaries, real‑time monitoring, and detailed call‑graph analysis—while providing C code samples and visual illustrations to help developers pinpoint and optimize performance bottlenecks.
This article introduces three popular Linux performance profiling tools—Perf, gprof, and Valgrind—explaining their installation, basic command‑line usage, and how to visualize results with flame graphs, call graphs, or KCachegrind, while comparing their intrusiveness, startup methods, and output formats.
This article walks through diagnosing and fixing severe Windows I/O performance degradation in a virtualized cloud host by using perf, systemtap, QEMU tracing, and kernel tweaks, revealing that excessive ACPI timer and APIC accesses cause costly VM exits and how enabling the Hyper‑V timer restores expected IOPS.
This article explains how to detect whether inbound or outbound packets are being dropped on a Linux system, shows how to use netstat, dropwatch, and perf to pinpoint the cause, and provides step‑by‑step commands and example outputs for debugging packet loss.
The article details how to identify and resolve memory leaks and performance bottlenecks in high‑concurrency Nginx workloads using tools such as Valgrind, AddressSanitizer, perf and flame‑graphs, while also sharing practical tips and personal reflections on debugging under pressure.
This article explains how to leverage the Linux perf tool to profile Oracle database workloads, covering basic commands, probe-based tracing of Oracle internal functions, generating various flame graphs, and practical Q&A for integrating perf into performance monitoring workflows.
This article provides a comprehensive guide to Linux performance monitoring, covering essential tools such as vmstat, iostat, dstat, iotop, pidstat, top/htop, netstat, ps, strace, perf, and advanced tracing utilities, with usage examples and interpretation of their output.
This article provides a comprehensive guide to Linux performance analysis, covering background concepts, detailed explanations of tools such as vmstat, iostat, dstat, iotop, pidstat, top/htop, mpstat, netstat, ps, strace, lsof, perf, and sar, along with practical command examples and usage tips.
This article shares a detailed post‑mortem of debugging extremely rare core dumps and memory leaks in a high‑concurrency Nginx HTTPS implementation, covering root‑cause analysis, custom stress‑test frameworks, and the use of tools such as gdb, valgrind, AddressSanitizer, perf and flame graphs to locate and fix the issues.
