Tagged articles
memory profiling
35 articles · Page 1 of 1

TonyBaiSep 26, 2026 · Backend Development
A Go proposal (#79179) provisionally accepted to add a memory_space sample type to heap/alloc profiles, providing a full memory hierarchy from RSS down to live/dead heap, stacks, runtime, and non-Go memory, solving the long-standing gap where heap profiles show only about 50% of actual RSS.
GoRuntimeheap profile
0 likes · 12 min read

This article details three clustering rules — shortest reference chain, name-plus-reference chain, and property-plus-reference chain — for analyzing ArkTS memory snapshots, enabling developers to automatically group 100,000+ objects and identify leak sources by retained size and allocation site.
ArkTSHarmonyOSJSNativePointer
0 likes · 7 min read

This article details common causes of native memory leaks in HarmonyOS apps and provides a step-by-step workflow using DevEco Profiler's Allocation template to reproduce, identify, analyze, and fix leaks via Native Heap and call stack analysis, illustrated with a real-world case study.
Allocation TemplateC/C++ Memory ManagementCall Stack Analysis
0 likes · 12 min read

The article explains the seven sources of GPU memory usage during PyTorch training, shows how to measure them with built‑in profiling APIs and the memory‑viz tool, and evaluates three effective optimizations—gradient checkpointing, mixed‑precision training, and optimizer selection—detailing their memory savings and performance costs.
GPU memoryGradient CheckpointingPyTorch
0 likes · 8 min read

This guide explains how to determine the heap memory consumption of individual HTTP and RPC calls in a SpringBoot application by setting up a JMeter load test, enabling detailed GC logging, and analyzing the results to optimize JVM parameters and improve performance.
GCJMeterJava
0 likes · 9 min read

Traditional PHP memory profilers, designed for synchronous blocking execution, struggle in high‑concurrency async frameworks like Swoole or ReactPHP because execution contexts intermix, memory leaks become ambiguous, and profiling overhead distorts performance, requiring specialized tools, snapshot comparisons, and disciplined coding practices to effectively diagnose issues.
PHPSwooleasync
0 likes · 9 min read

This article shows how a senior architect measured the exact heap memory allocated by individual HTTP and RPC requests in a SpringBoot 2.5.4 application using JMeter load testing and detailed GC logs, revealing that a minimal HTTP call consumes about 34 KB while an RPC call can use up to 1 MB, and discusses the performance implications of payload size and logging.
GCJMeterJVM
0 likes · 11 min read

The article presents a Spring Boot experiment measuring per‑request heap memory usage for HTTP and RPC calls, details the JMeter test setup, analyzes GC logs, reports findings such as ~34KB per HTTP request and 0.5‑1MB per RPC request, offers optimization recommendations, and also includes promotional material for AI‑related products.
JVMSpring Bootbackend development
0 likes · 11 min read

This article details a SpringBoot experiment using JMeter to measure the heap memory allocated per HTTP request, analyzes GC logs, and discusses how request size and logging affect memory consumption, providing practical JVM tuning insights for backend developers.
JVMmemory profilingperformance testing
0 likes · 9 min read

This article describes an experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated per HTTP and RPC request, detailing the setup, GC logging configuration, results showing average memory consumption around 34 KB per request, and recommendations for logging and performance optimization.
GCJMeterJava
0 likes · 11 min read

The article explains a kernel‑space memory profiler that uses a compile‑time code‑tagging library and special linker sections to record allocation callers and byte counts with minimal CPU overhead, allowing the tool to be deployed in production.
LinuxLow Overheadalloc_tag
0 likes · 4 min read

This article details a practical experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated by individual HTTP and RPC requests, analyzes GC logs, and demonstrates how request size and logging affect memory consumption, providing insights for backend performance optimization.
GCJVMSpringBoot
0 likes · 11 min read

This article presents a systematic experiment that uses JMeter to generate HTTP requests against a SpringBoot 2.5.4 service, records detailed GC logs, and calculates that each HTTP call consumes roughly 34 KB of heap memory, while logging and payload size can significantly increase the allocation.
GCJVMSpringBoot
0 likes · 10 min read

This guide introduces Memray, a powerful Python memory analysis tool, explains how to install it, run command‑line profiling, integrate it into code with the Tracker API, interpret detailed reports, and apply advanced filtering and merging techniques while noting its runtime overhead.
Debuggingmemory profilingmemray
0 likes · 4 min read


ByteFEMay 29, 2024 · Frontend Development
This article details a comprehensive set of frontend performance optimization techniques—including startup speed, resource loading, CPU/GPU rendering, dynamic FPS, batch merging, Spine animation, and memory profiling—applied to the 2024 Douyin Laughing China Year interactive projects to improve FMP, reduce draw calls, and prevent overheating and crashes on mobile devices.
Spine optimizationbatch mergingdynamic FPS
0 likes · 16 min read

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.
CPU profilingFlame GraphGo
0 likes · 6 min read

This article explains how to use MySQL's performance_schema to monitor and analyze per‑connection memory consumption, provides SQL queries to list memory instruments, shows Python scripts for sampling and visualizing memory usage over time, and demonstrates practical usage with example commands and output.
Pythonmemory profilingperformance_schema
0 likes · 14 min read

This guide explains why frequent garbage collection and heap memory overflow occur in Java applications, demonstrates how to reproduce the issue with a sample program, and walks through various techniques—including jmap histograms, heap dumps, VisualVM analysis, and remote JMX monitoring—to diagnose and resolve out‑of‑memory errors.
Heap DumpJavaVisualVM
0 likes · 9 min read

This comprehensive guide explains how to diagnose Linux performance problems—from CPU, memory, disk I/O, and network bottlenecks to system load—using tools like top, vmstat, perf, iostat, netstat, and flame graphs, and demonstrates the methodology with a real‑world Nginx case study.
CPU analysisSystem Monitoringflame graphs
0 likes · 17 min read

This article presents ten practical Python code examples demonstrating various garbage collection mechanisms and memory‑analysis tools, including reference counting, cyclic references, object inspection, tracemalloc, memory_profiler, pympler, and objgraph, to help developers understand and optimize memory usage.
DebuggingPythongarbage collection
0 likes · 4 min read

During CI builds of front‑end projects, developers often encounter out‑of‑memory errors or silent process termination, but by measuring Node.js memory and CPU usage, adjusting the max‑old‑space‑size flag, employing profiling tools, and optimizing webpack plugins, they can identify and mitigate resource‑consumption bottlenecks.
CI buildNode.jsmax-old-space-size
0 likes · 13 min read

This article introduces a Unity‑based UI performance testing framework, covering essential Unity concepts, asset bundle loading, memory management, used vs reserved memory, framework architecture, data collection methods such as panel screenshots and opening latency, and visualization techniques for analyzing draw calls, memory trends, and performance regressions.
UI PerformanceUnitymemory profiling
0 likes · 10 min read

This article explains the iOS system architecture, how Mach and BSD layers handle exceptions, the mechanisms for collecting crashes with KSCrash, strategies for OOM detection and monitoring, and techniques for memory snapshotting and reference‑graph analysis to pinpoint memory bloat.
Crash HandlingKSCrashOOM
0 likes · 21 min read

The article details a step‑by‑step investigation of a SpringBoot application that repeatedly triggered high swap usage, describing how JVM parameters, native memory tracking, gperftools, strace, and custom memory allocators were used to pinpoint and resolve off‑heap memory leaks caused by the Inflater implementation and glibc memory pools.
JVMJavaNative Memory
0 likes · 12 min read

This article introduces the Python libraries memory_profiler and Pytorch‑Memory‑Utils, demonstrates how to measure line‑by‑line CPU memory consumption and GPU memory usage in notebooks and scripts, and explains the additional overhead introduced by PyTorch during model loading.
GPUPythonmemory profiling
0 likes · 7 min read

Bytehound is a Linux memory analysis tool that offers detailed memory usage curves, allocation tracking, stack traces, and a web GUI, with support for multiple architectures, export formats, and configurable environment variables for flexible profiling and debugging.
BytehoundLinuxPerformance Analysis
0 likes · 4 min read

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.
Database PerformanceLinuxMySQL
0 likes · 5 min read

MemTower is a Rust‑rewritten native memory profiler for Android that supports versions from 4.x onward, uses an LD_PRELOAD custom allocator to avoid recursive malloc loops, provides fast ELF‑based stack unwinding, multi‑dimensional leak analysis and flame‑graph visualisation, and cuts leak‑investigation time from days to minutes.
AndroidPerformance AnalysisRust
0 likes · 13 min read

This article explains how the Android dumpsys meminfo command retrieves process memory data, describes the three data sources (smaps parsing, IPC via binder/pipe, and memtrack.vendor_xxx.so), and shows how to map the raw fields to meaningful Java, native, graphics, and system memory categories for performance analysis.
AndroidNative HeapPerformance Analysis
0 likes · 11 min read

The article explains common Android Out‑Of‑Memory scenarios, traditional analysis methods, and introduces the Shooter offline memory analysis system that parses hprof snapshots, builds dominator trees, computes shallow and retained sizes, and visualizes reference chains to help developers locate memory leaks and OOM causes.
AndroidHeap AnalysisLeakCanary
0 likes · 17 min read

This article walks through generating load with Vegeta, using pprof and Go trace to pinpoint massive heap allocations caused by the chi compression middleware, and shows how upgrading the library and disabling the middleware reduced allocations by nearly a hundred‑fold while improving GC performance.
Compression MiddlewareVegetamemory profiling
0 likes · 8 min read

This article introduces Sieve, an internal Android memory‑analysis platform that parses Hprof heap dumps, builds dominator trees, computes retained sizes, and constructs reference paths to help developers locate OOM‑causing leaks and optimize memory usage.
AndroidHprofRetained Size
0 likes · 13 min read

This article introduces Sieve, an internal Android memory analysis platform that parses Hprof files, builds dominator trees, calculates retained sizes, and visualizes reference chains to help developers identify OOM causes, while discussing the limitations of existing tools and implementation details.
AndroidGC RootsHprof
0 likes · 14 min read


JD TechAug 21, 2018 · Mobile Development
This article introduces the Sieve Android memory analysis system, explains why existing tools like LeakCanary and MAT fall short, describes how heap dump files are parsed, GC Roots identified, dominator trees generated, retained sizes calculated, and reference chains constructed to help developers locate memory leaks and OOM causes.
AndroidHeap DumpRetained Size
0 likes · 14 min read

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.
AndroidCPUbattery
0 likes · 6 min read
