This guide explains what XHProf is, walks through installing it via PECL or source, configuring php.ini, verifying the installation, integrating it with a middleware class, and accessing the web UI to view detailed performance metrics and visualizations.
This guide walks through configuring Windows 11 with WSL2 and Ubuntu 22.04 for GPU‑accelerated CUDA development, installing NVIDIA drivers and CUDA libraries, setting up SSH and firewall rules, running a CUDA stress‑test program, and using Nsight Systems, Nsight Compute, and NVIDIA DCGM for performance profiling and monitoring.
This article walks through GPU performance analysis, starting with CUDA architecture fundamentals, demonstrating matrix multiplication optimization, explaining PTX assembly, and introducing the Neutrino framework for programmable GPU probes that enable fine‑grained, custom instrumentation and detailed timing measurements of kernel execution.
This guide explains why and how to use Go's pprof and trace tools to diagnose memory leaks, goroutine stalls, and CPU bottlenecks, providing step‑by‑step commands, example code, a cheat‑sheet of core commands, and a practical workflow for microservice tracing.
HUATUO, Didi's open‑source cloud‑native observability project, leverages BPF‑based low‑overhead kernel tracing, unified metric and event frameworks, automatic flame‑graph generation, and seamless integration with Prometheus, Grafana and Elasticsearch to provide panoramic, zero‑intrusive monitoring and continuous performance profiling for complex production environments.
This comprehensive guide explains how to use Go's built‑in pprof tool to profile CPU, memory, and goroutine behavior, covering integration methods, command‑line analysis, visualization techniques, and step‑by‑step solutions for common performance bottlenecks in production Go services.
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.
The article examines Java thread states—WAITING and TIMED_WAITING—through monitoring screenshots, explains their definitions, trigger conditions, and recovery mechanisms, analyzes real‑world code involving concurrent tasks, and presents flame‑graph based performance optimizations for backend services.
This article provides an in‑depth overview of Valgrind, explaining its architecture, the capabilities of its various tools such as Memcheck, Cachegrind, Callgrind, Helgrind and Massif, and offers step‑by‑step installation, configuration, and practical code examples for detecting memory errors, leaks, and performance bottlenecks in C/C++ programs.
This guide demonstrates how to use the C standard library functions time(), clock(), and the POSIX gettimeofday() to measure code execution duration, comparing their precision levels and showing sample code snippets that illustrate typical usage and output.
The article teaches Go developers how to generate and analyze CPU, heap, allocation, and goroutine profiles with pprof and full‑runtime traces, interpret SVG flame‑graphs, top lists, and source views, and apply concrete optimizations—such as buffering channels and using sync.Pool—to dramatically speed up a Mandelbrot generator.
Learn how to leverage the Arthas flamegraph tool to profile Java applications, interpret CPU usage visualizations, and apply practical optimization techniques illustrated through real-world case studies that reduced CPU consumption by up to 6% and improved system stability during high‑traffic events.
This guide explains how to use the Linux /usr/bin/time command to measure program execution time, memory usage, and other resource metrics, covering syntax, options, custom output formats, and the differences between the built‑in shell time and the external utility.
Conan is an automated profiling solution for Go microservices that embeds an SDK to continuously or adaptively sample CPU, memory and goroutine metrics, detects anomalies via user‑defined rules, uploads data to a Pyroscope server, and reports results through Feishu or Pyroscope, delivering sub‑5 % overhead and faster root‑cause analysis.
This guide introduces Java performance analysis fundamentals, covering profiling tools, key metrics such as CPU, memory, thread behavior, and practical methods to detect and resolve common issues like memory leaks, GC pauses, high CPU usage, I/O bottlenecks, and inefficient collection usage.
This article introduces core Python concepts—including dictionaries and sets as key‑value and unique collections, file and directory manipulation with the os module, regular expression handling, logging setup, unit testing with unittest, performance profiling via cProfile, and using popular third‑party libraries such as requests and BeautifulSoup.
This article explains how to profile WebAssembly code by inserting lightweight instrumentation hooks, optimizing the overhead with a tree‑based call‑stack, generating flame‑graph data, and demonstrates the whole workflow with a sample Fibonacci program compiled to WASM.
This article explains how to evaluate device overheating using metrics such as CPU/GPU usage and temperature, collect and visualize Trace data with SmartPerf or DevEco Studio, analyze high‑load threads and frequency scaling, and apply targeted code changes—disabling sensors, releasing Lottie resources, and simplifying components—to reduce heat and restore frame‑rate stability.
This comprehensive guide teaches Go developers how to generate CPU, memory, and goroutine profiles with pprof, interpret SVG, top, source, and peek visualizations, understand the runtime’s sampling and allocation internals, use the trace tool to analyze events, and apply these techniques to real‑world optimizations such as speeding up a Mandelbrot image generator.
This guide walks through Go's pprof tool, detailing each command‑line option, its purpose, and example usage so developers can comprehensively profile, visualise, and optimise Go applications for better performance and stability.
This guide explains how to use Go's built‑in pprof tool and the go tool pprof command to profile CPU and memory usage, generate analysis files, interpret interactive console output, create flame graphs, and apply practical optimizations for faster, more efficient Go applications.
This guide explains Go's addr2line tool, covering its core function of translating memory addresses to source file locations, typical debugging and performance‑analysis scenarios, command‑line usage with examples, and how it streamlines error tracing and profiling in Go applications.
The article explains how AArch64 stack unwinding works using both frame‑pointer based methods and DWARF .eh_frame/.debug_frame CFI data, detailing the calling convention, compiler effects, CIE/FDE structures, and their integration into Android’s simpleperf profiler for accurate back‑traces.
This article explains how to use Java Flight Recorder (JFR) and JProfiler for low‑overhead, production‑grade performance analysis, covering JFR advantages, process discovery, file generation commands, JProfiler features, memory and CPU profiling techniques, and includes practical code examples.
This article introduces three powerful PHP debugging and profiling tools—Xdebug, PHPDBG, and Blackfire—explaining their features, configuration steps, and providing concrete code examples to help developers efficiently locate and fix issues while improving performance.
During a load test of a Java 1.6 application on a CentOS server, memory usage climbed from 20% to 100% after an hour of 300‑concurrent requests, prompting a detailed investigation that identified off‑heap leaks caused by GZIP compression in a JimDB client and led to fixes such as upgrading the JDK and avoiding unnecessary compression.
This article explains how to use the open‑source Java diagnostic tool Arthas to attach to a running JVM, view real‑time metrics, and employ the trace command to pinpoint and analyze time‑consuming methods without inserting manual timing code.
This article provides a comprehensive guide to Linux Perf, covering its architecture, counting and sampling modes, event classifications, the full suite of Perf tools, and how to generate and interpret CPU and Off‑CPU flame graphs for deep performance analysis.
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 explores the evolution of continuous performance profiling, explains why traditional tracing falls short, and details a series of optimizations—including batch processing, object‑reference serialization, aggregation insertion, and multi‑chunk handling—to dramatically reduce memory usage and speed up Java Flight Recorder analysis using async‑profiler and flame graphs.
This article explains what web page memory leaks are, identifies common sources such as timers, event listeners, closures, and DOM references, and demonstrates step‑by‑step how to locate and resolve them using Chrome DevTools' Performance and Memory panels.
Learn how to install XHProf via PECL or source, configure php.ini, verify the installation, integrate the XhprofMiddleware into your PHP application, and interpret the detailed performance metrics and visual reports, including function call statistics and memory usage, with example commands and code snippets.
This article explains the background of continuous performance profiling, demonstrates two real‑world scenarios using ARMS Continuous Profiler to locate CPU and memory hotspots, describes the tool’s design and core components, and shows how the fixes improve application responsiveness and resource usage.
This article introduces four practical techniques for measuring Python code performance, including the built‑in time module, Jupyter’s %%time magic, line_profiler for per‑line timing, and memory_profiler for detailed memory consumption, complete with example code and interpretation of results.
This article introduces four practical methods for monitoring Python code performance—using the built‑in time module, the %%time IPython magic, line_profiler for per‑line timing, and memory_profiler for detailed memory usage—complete with code examples and interpretation of results.
The article explains how a sudden Go service memory‑usage alert was traced with go tool pprof to a massive allocation in the quantile.newStream function, uncovered a Prometheus metric‑label explosion caused by the START_POINT label, and resolved the leak by disabling that label, while also reviewing typical Go memory‑leak patterns.
This guide explains how to install and use Perfetto, Android’s next‑generation tracing tool, covering trace capture via command line or Traceur, UI navigation, key trace elements, and practical SQL queries for analyzing slices, counters, scheduling, thread states, and lock contention to optimize performance.
This article explains how to accurately measure the execution time of Objective‑C methods on iOS by implementing a custom objc_msgSend hook in ARM64 assembly, replacing the original implementation with fishhook, and visualizing the results using Chrome tracing, offering a low‑cost, non‑intrusive performance profiling solution.
This guide explains how to integrate the open‑source Pyroscope platform with Rainbond to continuously profile microservices, detect CPU bottlenecks and memory leaks, and visualize performance data through its UI and various view modes.
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.
This article explains how Android's built‑in Trace infrastructure can be leveraged on the device itself—by modifying native tag variables and hooking write calls—to run systrace without a PC, automatically instrument methods, and export data for Perfetto analysis.
This article presents a comprehensive overview of inference optimization methods—including model pruning, quantization, knowledge distillation, caching, instruction‑set acceleration, and operator fusion—and details a GPU‑centric parallel acceleration methodology with CUDA basics, performance‑analysis tools, theoretical limits, and practical case studies, all illustrated with real‑world examples from Tencent's intelligent dialogue products.
This article walks through why SQL queries become bottlenecks as data grows and presents a step‑by‑step guide—including slow‑query analysis, EXPLAIN interpretation, profiling, optimizer tracing, index tuning, and scenario‑specific tricks—to dramatically improve MySQL performance.
This article shares practical insights on balancing open‑source and self‑developed components in core platform projects, covering advantages, lifecycle stages, performance profiling, code‑base management, and engineering practices that help teams achieve sustainable growth and innovation.
This article explains the background, design, and usage of Alibaba Cloud Function Compute's Instance Exec capability, showing how developers can securely access live function instances via the console or SDK, and apply it to troubleshooting, performance profiling, and custom runtime optimization.
The article outlines a systematic SOP‑driven approach for diagnosing online service alarms and performance issues in Go, detailing a toolbox that includes pprof, trace, goroutine visualizers, perf and eBPF, and recommends application‑level optimizations, system tuning, and continuous profiling to accelerate root‑cause identification and reduce incident frequency.
This article introduces flame graphs, explains their visual characteristics and how they help identify performance bottlenecks in Java applications, and provides practical guidance on generating them using Perl scripts and shell commands to process jstack and perf outputs.
This article introduces SkyWalking, a Chinese open‑source APM framework, compares it with Spring Cloud Sleuth+Zipkin, explains server and client setup, storage configuration, log collection, performance profiling, and alerting, providing step‑by‑step instructions, code snippets, and screenshots to help developers implement comprehensive distributed tracing.
The React team has open‑sourced the Scheduling Profiler, a new tool that extends the classic Profiler by visualizing component scheduling, priority handling, transitions, and Suspense behavior, helping developers diagnose rendering delays and optimize performance in React 18 applications.
This article explains how to build a simple Python probe that measures function execution time by leveraging sys.meta_path import hooks and sitecustomize, providing step‑by‑step code examples, command‑line wrapper, and discussion of automatic module loading for profiling purposes.
The article provides a comprehensive English overview of SkyWalking UI, detailing its dashboard metrics, topology visualization, trace analysis, performance profiling workflow, and alarm management, illustrating how the tool monitors microservice and cloud‑native environments with metrics such as throughput, latency, Apdex, and JVM statistics.
This article explains how flame graphs visualize call‑stack frequency and duration, shows how to generate them from Java jstack dumps using Perl tools, and demonstrates how to interpret their widths and flat tops to pinpoint performance hot spots in production systems.
This article explains the concept, features, and practical usage of flame graphs—including how to generate them from Java thread dumps with Perl scripts—to help developers visualize call‑stack frequencies and quickly identify performance bottlenecks in backend services.
This article explains how the MNN deep‑learning framework leverages OpenCL to achieve high‑performance inference on mobile, PC and embedded GPUs by diversifying memory objects, aligning data, using local‑memory reductions, selecting optimal work‑group sizes, applying pre‑inference auto‑tuning, caching compiled programs, and providing practical GPU‑friendly model design guidelines.
This article explains Node.js’s asynchronous execution model, defines key concepts such as execution frames and continuation points, demonstrates event flow with code examples, and shows how the async_hooks API and AsyncLocalStorage can be used for tracing, debugging, and performance analysis of backend JavaScript applications.
This guide explains what strace is, how to use it for filtering system calls, profiling execution time, diagnosing configuration issues, and tracing network activity, providing concrete command examples and interpretation of output to help troubleshoot Linux processes efficiently.
This article explains the inner workings of Python's import system, demonstrates how to create a simple import‑hook probe using sys.meta_path and sitecustomize, and walks through building a command‑line agent that automatically measures function execution time in any module.
This article explains how to build a Java Agent that leverages bytecode instrumentation, class‑loader mechanisms, and AOP techniques to provide lightweight, configurable performance profiling and monitoring for Java services, covering requirements, technical foundations, implementation steps, and testing procedures.
After moving a project to Spring Boot, the system reported unusually high swap usage despite a 4 GB heap, prompting a detailed investigation using JVM native‑memory tracking, pmap, gperftools, strace, and GDB, which ultimately identified Spring Boot’s JAR scanning and glibc memory arenas as the root causes and led to a configuration fix and an upgrade to resolve the off‑heap memory leak.
A massive SAP cloud application suffered a 20‑second pause due to an accidental wait statement, revealing how careless code can cripple performance and illustrating practical, step‑by‑step guidelines for effective, measured code optimization.
The article explains how JVM CPU profilers work by using Java or native agents—via JVMTI, JMX, or the AsyncGetCallTrace hack—to sample or instrument stack traces, generate flame graphs, and employ the HotSpot Attach API for live, zero‑restart agent loading and diagnostics.
The article demonstrates how Go’s built‑in pprof tools can be used for live performance profiling, walking through two real‑world cases—one where a malformed JSON request caused massive object allocation and CPU spikes, and another where per‑call self‑referencing structs leaked memory—while offering practical tips on input validation, allocation reduction, and GC monitoring.
This article explains how to use TensorBoard and the Timeline tool to monitor TensorFlow GPU utilization, identify operation bottlenecks, and visualize execution times, including code examples and steps for exporting and merging profiling data for repeated runs.
This article explores the causes of UI stutter in Android apps, explains how frame rate and dropped frames affect perceived smoothness, and details practical profiling solutions—including TraceView, BlockCanary, ArgusAPM, and Matrix‑TraceCanary—along with implementation techniques for accurate lag detection and mitigation.
This article walks through diagnosing intermittent OpenAPI latency by using Alibaba's open‑source TProfiler Java agent to collect method‑level timing without modifying code, covering setup, command‑line usage, log analysis, and practical performance‑improvement recommendations.
This article walks through a real‑world performance problem where an OpenAPI service sometimes responds in milliseconds and other times takes seconds, explains why adding logging is impractical, and demonstrates how to use Alibaba's TProfiler Java agent to profile the call chain, collect method timings, and analyze the results without modifying any source code.
This article walks through diagnosing intermittent OpenAPI latency by reproducing the issue, visualizing the request flow, using Alibaba's TProfiler agent without code changes, configuring and running profiling commands, analyzing the generated logs, and summarizing actionable performance improvements.
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 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 guide walks Java developers through practical performance analysis using the Hprof agent and pidstat tool, demonstrates step‑by‑step command usage with real code examples, and presents a memory‑leak case study that explains GC overhead limits, dump analysis, and concrete remediation steps.
This article explains how IBM Research and Cloudinsight use Apache Spark to capture, analyze, and visualize microservice communication in real time, addressing challenges of observability, bottleneck detection, and latency attribution in large‑scale cloud environments.
This article walks through a real‑world investigation of intermittent core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack under extreme QPS, detailing debugging strategies, custom load‑testing tools, and performance‑profiling techniques that helped pinpoint and fix the root causes.
This guide explains practical techniques for diagnosing Node.js production issues, covering request‑latency analysis, CPU profiling with perf and FlameGraph, crash investigation via Core Dumps and mdb_v8, and memory‑leak detection using gcore and mdb_v8 diff tools.
