This article explains how to identify and resolve common causes of Java service slowdown—such as excessive Full GC, high CPU usage, intermittent latency, waiting threads, and deadlocks—by using tools like top, jstat, jstack, and MAT for systematic troubleshooting.
This article explains how Linux kernels 2.6 and 4.18 manage CPU P‑states and C‑states, covering BIOS control, cpupower usage, idle drivers, the menu governor, MONITOR/MWAIT effects, and performance comparisons between power‑saving and performance modes on Intel Xeon E5‑2630 v4.
The article explains how a complex Java regular‑expression used for URL validation triggers catastrophic backtracking, causing near‑100% CPU usage, and demonstrates how to analyze, reproduce, and fix the regex by reducing greedy patterns and adding missing characters.
This article chronicles the development, competition, and strategic shifts of the x86 and ARM processor ecosystems from their early days through recent innovations, highlighting key architectural decisions, market dynamics, and the evolving role of software abstraction layers in shaping the semiconductor landscape.
This article walks through the complete journey of a single Java statement—from high‑level source code, through compilation to bytecode, JVM interpretation and JIT compilation, down to CPU instruction fetching, decoding, execution, caching, memory hierarchy, threading, interrupts, and the underlying Linux process model.
This article explains the complete execution path of a single Java line—from the Von Neumann CPU components, instruction fetch‑decode‑execute pipeline, Java bytecode generation, JVM class loading and interpretation, memory layout and caching, to Linux process memory management, thread scheduling, synchronization mechanisms and timer implementation—providing a deep technical foundation for Java performance tuning.
This article explains the fundamental differences between CPUs and GPUs, outlines key GPU specifications such as CUDA cores, memory capacity, bandwidth, and floating‑point precision, and reviews NVIDIA's major GPU series and architectural evolution for high‑performance and AI workloads.
This guide walks you through essential Linux performance diagnostics—checking CPU details, boot‑time services, CPU load, free memory, and disk I/O—providing concrete commands, interpretation tips, and practical solutions to identify and resolve common slowdown causes.
This article explains the fundamental architectural differences between CPUs and GPUs, their design goals and performance characteristics, and compares OpenCL and CUDA, highlighting OpenCL’s cross‑platform flexibility versus CUDA’s NVIDIA‑specific optimization, while illustrating how each fits various parallel computing tasks.
This article explains how infinite loops, frequent Young GC, thread count, and thread states affect CPU utilization in Java, describes the relationship between CPU, processes, and threads, and shares practical troubleshooting steps and real‑world cases for diagnosing high CPU usage.
This article explains the hidden multithreading bugs in JDK 7 HashMap and JDK 8 ConcurrentHashMap that can cause 100% CPU usage, demonstrates how to reproduce them, and offers practical ways to avoid or resolve the issue.
This article explores why Java applications experience high CPU usage, examines common misconceptions about loops, GC, thread counts, and blocked states, explains how CPU usage is calculated, and provides practical troubleshooting steps with real‑world examples and monitoring tips.
When a data platform server spikes to 98% CPU despite low traffic, this guide walks you through using Linux tools and Java thread analysis to locate the offending process, identify the problematic code, and apply a targeted fix that drops CPU load dramatically.
To alleviate GPU scarcity, iQIYI’s cloud platform migrated deep‑learning inference to CPUs and applied system‑level (MKL‑DNN, OpenVINO), application‑level, and algorithm‑level optimizations—tuning threads, batch size, NUMA, pruning and quantization—delivering 1‑9× speedups across thousands of cores while preserving latency and accuracy.
This guide walks through diagnosing a server’s 98% CPU spike by locating the offending process, pinpointing the problematic Java thread, analyzing the root‑cause time‑utility method, and applying a code simplification that reduces load by over 30‑fold.
The article reviews the two main development routes for artificial intelligence chips—traditional architectures that enhance CPU, GPU, and FPGA performance and emerging neuromorphic designs like IBM TrueNorth—detailing their structures, advantages, limitations, and industry adoption.
The 52nd TOP500 list released in November 2018 shows US DOE machines dominating the top ten, highlights performance gains of Summit and Sierra, details the hardware of leading supercomputers worldwide, and analyzes country shares, manufacturers, accelerator usage, interconnect technologies, and energy‑efficiency rankings such as Green500 and HPCG.
This article details a step‑by‑step investigation of frequent full GC events and high CPU usage in a Java backend service, covering memory analysis with SGM, heap dumps, identification of large Base64 image strings, static encryption utilities, and remediation actions such as heap size increase and custom encryption handling.
This article walks through setting up a Vagrant‑based experiment that injects an intentional infinite loop into a simple Spring MVC service, then demonstrates step‑by‑step how to identify the offending process using top, examine JVM heap with jstat, and trace the problematic thread with jstack to resolve a CPU‑100% issue.
The article offers a comprehensive, historically grounded analysis of the x86 and ARM ecosystems, tracing their origins, competitive battles, technical innovations, market shifts, and future challenges while highlighting why software ecosystems, licensing models, and emerging technologies shape CPU dominance.
This article walks through a practical Linux performance investigation, showing how to use the top command to pinpoint high‑CPU processes, examine thread details, convert thread IDs, analyze thread dumps for lock contention, and interpret key top output fields for effective troubleshooting.
An Alibaba tech support engineer investigates a server whose CPU appeared fully utilized, discovers the misleading 'ni' metric, reproduces the issue with high‑nice loops, uncovers hidden mining processes via ld.so.preload, and explains how to detect and mitigate such stealthy CPU hogs.
After moving a Git server to a new data center, CPU sys time surged due to thousands of sshd processes contending on XFS read‑write locks while repeatedly reading a massive /var/log/btmp file caused by PAM postlogin, and the analysis shows how perf, strace and log rotation can resolve the issue.
The article explains how heterogeneous parallel computing—leveraging CPUs, GPUs, FPGAs and other specialized units—addresses the performance limits of traditional serial programming by distributing tasks across diverse hardware, detailing its concepts, architectures, development models, and relevance to AI and cloud workloads.
This guide explains the three main performance bottlenecks—CPU, network I/O, and disk I/O—on Linux servers, offers concrete optimization techniques for each, and introduces essential diagnostic tools such as top, free, vmstat, strace, tcpdump, and gprof to pinpoint and resolve issues.
This article introduces a self‑developed Android performance monitoring app, explains how to install, start, and view test results, and details the underlying data‑collection mechanisms for memory, battery, CPU, and FPS metrics, providing practical guidance for developers.
This article examines common memory leak and performance problems in C/C++ applications, categorizing causes such as pointer loss, improper memory release, excessive fragmentation, infinite allocation, and container misuse, and discusses diagnostic techniques, underlying allocation mechanisms, and mitigation strategies.
The article explains how CPUs, despite being usable for early cryptocurrency mining, are inefficient due to limited parallelism and general‑purpose design, while GPUs and ASICs provide massive parallel integer processing that makes them far more effective for modern proof‑of‑work algorithms.
This article translates hardware latency into human‑scale time, revealing how disks, networks, memory and other components appear painfully slow from a CPU’s viewpoint and why performance optimization is a complex, system‑wide challenge.
This article walks through a real‑world incident where a data platform’s CPU usage surged to 98%, detailing how to pinpoint the high‑load process, trace the offending Java thread, uncover a time‑utility method bottleneck, and apply a concise fix that reduced load by thirtyfold.
This article translates hardware latencies—from CPU cache and memory to disk and network—into human‑scale time equivalents, using vivid analogies and benchmark data to illustrate why storage and networking appear extremely slow from the processor's viewpoint.
This article introduces the fundamentals of x86 assembly language, explaining why low‑level code is needed, the history of assembly, CPU registers, the heap and stack memory models, and walks through a complete example with detailed explanations of each assembly instruction.
This article explores Hadoop YARN’s evolution, multi‑tenant design, queue and node‑label scheduling, real‑world resource allocation challenges, and data‑driven tools that automate diagnostics and visualizations to optimize CPU and memory usage across massive clusters.
This guide walks through a systematic troubleshooting workflow for a Linux gateway that spikes to 891% CPU, using top to locate the offending process, inspecting thread usage, capturing stack traces with gstack, dumping core files, tracing system calls with strace, and analyzing the core dump in gdb to pinpoint the poll() call causing the load.
This article explains how dynamic rate limiting can automatically compute throttling thresholds using system load metrics such as CPU usage, load average, and response time, and demonstrates its effectiveness through real‑world testing on a flight‑price service.
This article introduces four Python CPU profiling tools—cProfile, line_profiler, pprofile, and vprof—explaining their installation, usage on CPython and PyPy, interpreting their outputs, and visualizing results with graphviz, helping developers identify performance bottlenecks such as costly list.append calls.
The article explains why general‑purpose CPUs can no longer meet deep‑learning demands due to intrinsic scaling limits and memory‑bandwidth bottlenecks, and surveys how heterogeneous accelerators—GPUs, FPGAs, ASICs and emerging AI processors with high‑bandwidth memory—provide specialized, high‑parallelism, power‑efficient solutions for both cloud and edge workloads.
The article analyzes the limitations of general‑purpose CPUs for deep‑learning workloads, explains how semiconductor scaling and memory‑bandwidth constraints drive the shift toward specialized heterogeneous processors such as GPUs, FPGAs, and ASICs, and discusses the design trade‑offs of embedded versus cloud AI accelerators.
A customer’s Oracle 11g RAC experienced chronic high CPU usage; deep AWR analysis revealed that massive parse time was attributed to mutex waits and a hidden hard‑parse failure caused by a missing column, which triggered Bug 16175381 and forced process spin, ultimately resolved by correcting the faulty SQL.
This guide explains how to assess and improve server performance by understanding key metrics such as CPU utilization, memory management, and disk I/O, introducing fundamental concepts, analysis methodologies like 5W2H and load‑characteristic summarization, and recommending practical Linux tools such as uptime, vmstat, top, perf, and DTrace for comprehensive troubleshooting.
This article provides a comprehensive guide to server performance optimization, covering the fundamentals of CPU, memory, and I/O analysis, practical methodologies, essential tools, and real‑world case studies to help operations engineers identify bottlenecks and improve system stability.
A production MySQL incident showed sudden system CPU spikes and many running threads despite low query throughput, which was traced to the server's time_zone=system setting causing timestamp conversion to lock a global mutex, leading to excessive spin‑locks, context switches, and degraded performance that was resolved by changing the time_zone to a fixed offset.
This article explains the fundamentals of web animation performance, examines a complex canvas‑based weather animation case, introduces tools like Chrome's FPS meter and stats.js, and details browser rendering pipelines, CPU/GPU roles, and practical optimization techniques for smoother front‑end experiences.
This article explains three Android CPU performance testing techniques—using adb dumpsys cpuinfo, reading /proc/pid/stat, and employing the top command—detailing their procedures, advantages, limitations, and how to aggregate per‑process data for accurate app‑level metrics.
This article walks through the complete semiconductor manufacturing flow, from raw quartz to polished silicon wafers, photolithography, ion implantation, metal deposition, testing, die cutting, packaging, and final grading, revealing why CPUs are the most integrated, un‑replicable chips in modern technology.
This article provides a detailed tutorial on measuring and optimizing iOS app performance, covering startup and load times, memory and CPU usage, smoothness metrics, and practical code snippets using Apple Instruments and other tools to obtain reliable data across devices.
This article outlines practical Linux‑based optimization techniques for MySQL, covering CPU power‑saving modes, NUMA and vm.swappiness settings, as well as mount options and I/O scheduler tweaks to maximize database throughput and stability.
This article describes how adjusting the PHP‑FPM max_requests setting and modifying its source code can smooth CPU idle and memory usage fluctuations in a high‑traffic online service, improving resource stability and reliability.
This article provides a detailed chronological overview of the rivalry between Intel and AMD, covering their shared origins, early collaborations with IBM, legal battles, the rise of AMD’s Athlon and 64-bit processors, Intel’s Tick‑Tock strategy, and the evolving market dynamics that shaped modern CPU architecture.
This guide presents comprehensive Oracle database performance optimization techniques—including data structure design, application architecture, SQL tuning, memory and CPU adjustments, I/O balancing, and essential tools—providing actionable steps and example queries for DBAs to improve system responsiveness and efficiency.
Hardware acceleration in Android shifts intensive floating‑point UI work from the CPU to the GPU by building DisplayLists on the CPU and rasterizing them on the GPU, allowing parallel processing, selective redraw of unchanged elements, and significantly higher frame rates for animations and complex graphics.
This article explains common Android performance problems such as battery drain, slow startup, and lag, and provides step‑by‑step instructions for measuring memory and CPU usage using adb commands, Android Studio tools, and the ActivityManager.MemoryInfo API.
This article provides a detailed, step‑by‑step guide for iOS developers on measuring and optimizing app performance across CPU usage, GPU‑related stutter, network conditions, and energy consumption using built‑in Instruments, Activity Monitor, Network Link Conditioner, and Charles.
This article walks through a real‑world remote debugging session where a high‑CPU issue in a gateway service was reproduced, analyzed with top, gstack, gcore, strace and gdb, and traced to a buffer overflow causing an infinite loop, then fixed.
This article explains how to identify and resolve intermittent high CPU usage in Java/Tomcat services by analyzing thread stacks with jstack, examining GC behavior with Jstat, and using Jmap for memory inspection, providing step‑by‑step commands and practical tips for ops engineers.
This article introduces the Linux sar command, explains its syntax and common options, and demonstrates how to sample and interpret CPU, memory, I/O, process queue, and swap metrics to identify system bottlenecks during performance testing.
This article outlines comprehensive mobile performance testing practices for Baidu Video, covering background, key performance dimensions such as smoothness, crash, memory, power, CPU, and network, and detailing metric collection methods on Android and iOS using command‑line tools, Xcode Instruments, and third‑party utilities.
This article explains practical methods for measuring iOS app performance—including startup time, page load, memory, CPU and smoothness—by instrumenting code, using Apple Instruments tools, analyzing webview loading, and employing runtime techniques such as dynamic library hooking and script‑driven profiling.
This article provides a comprehensive overview of the Linux sar command, explaining its syntax, common options, example use‑cases for CPU, memory, I/O and process monitoring, and how to interpret the output fields to identify system bottlenecks.
This article explains which external and internal performance metrics matter for backend services, how to interpret them, common bottlenecks, and provides a step‑by‑step example using JMeter to measure throughput, latency, CPU, memory, load, network and disk I/O.
This guide walks through Linux Container (LXC) resource management, explaining how to control CPU, memory, and storage using cgroup commands, configuration files, and monitoring tools, with step‑by‑step examples and practical tips for efficient container operation.
This article provides a comprehensive visual overview of CPU architecture, instruction sets, operating system purposes, programming layers, privilege rings, execution modes, user interfaces, and the distinction between ABI and API, helping readers grasp core computing concepts in a structured manner.
Through a whimsical first‑person narrative, the article walks readers through a CPU’s start‑up sequence, BIOS interrupt handling, loading the boot sector, memory access patterns, the principle of locality, cache usage, and the introduction of pipelining to illustrate fundamental computer architecture concepts.
A MySQL replica was consuming an entire CPU core due to single‑process replication, and analysis of binlog and InnoDB status revealed heavy row locks on a table without a primary key, which was resolved by adding an auto‑increment ID, dropping CPU usage to 3% and eliminating replication lag.
This article analyzes why the browser engine's CPU usage does not converge to zero when a page becomes invisible or the app is backgrounded, presents a lightweight testing methodology, identifies dynamic‑element and Blink‑kernel bugs, and proposes concrete fixes that restore proper CPU convergence.
A detailed case study shows how a 1% precision difference discovered by query‑diff testing was traced to CPU instruction‑set discrepancies (AVX vs SSE), highlighting the impact of hardware‑level floating‑point optimizations on algorithmic results and providing practical debugging and mitigation guidelines.
This article details a query‑diff test that revealed a 1% floating‑point precision difference after a module upgrade, describes the systematic investigation of environment, compilation, and CPU instruction‑set variations (AVX vs SSE), and presents conclusions and recommendations for preventing similar issues.
This guide walks IT operations engineers through systematic Linux‑based techniques for pinpointing Java processes that consume excessive CPU or memory, using tools like top, ps, jstack and jmap, and provides concrete steps to analyze and remediate the underlying code.
This article explores the challenges of real‑time HTML and inline JS/CSS minification with html‑minifier in Node.js, including CPU‑spike bugs caused by malformed HTML, workarounds using the vm module with timeouts, performance optimizations, and future directions for faster, stable compression.
This article examines why modern web systems face exploding concurrent connections, explains how richer pages and browser limits increase load, and presents front‑end caching, request merging, Apache/Nginx memory and CPU optimizations, and practical guidelines for reducing server resource consumption.
This guide explains how to enable MySQL’s Query Profiler, retrieve summary and detailed profiling data, and analyze CPU and I/O usage to pinpoint performance bottlenecks in your queries, including commands to list profiles, view specific query details, and interpret the results for optimization.
This guide explains how to use the Linux vmstat command to monitor system performance, detailing its output fields such as process states, memory, swap, I/O, system interrupts, and CPU usage, and shows how to interpret each metric for effective troubleshooting.
Load average measures the average number of processes waiting for CPU over 1, 5, and 15 minutes, differing from CPU utilization; this article explains the concepts, ideal values, illustrative analogies, and practical steps to assess and reduce server CPU load for better performance.
This guide lists thirteen Linux commands and tools—including /proc/cpuinfo, cpufreq-info, cpuid, dmidecode, hardinfo, i7z, likwid, lscpu, lshw, lstopo, numactl, and x86info— that reveal comprehensive CPU hardware information such as vendor, model, frequencies, cores, caches, and topology.
The article explains how web front‑end optimization, including static site generation, relies on improving browser‑server performance by addressing CPU, storage, and especially network bottlenecks, and argues that front‑end engineers should view themselves as browser‑application experts rather than just HTML/CSS/JS coders.
This guide walks through identifying a Java process that spikes CPU usage, locating the offending thread with Linux tools, extracting its stack trace, pinpointing the problematic code in a socket utility class, and outlining the steps to resolve the infinite‑loop issue.
