Tagged articles
memory debugging
19 articles · Page 1 of 1
Even when monitoring shows free memory, Linux can still kill processes due to various OOM paths such as cgroup limits, NUMA allocation failures, kernel high-order allocation issues, or systemd‑oomd, and this guide walks through a reproducible investigation and remediation process.
KubernetesLinuxOOM
0 likes · 29 min read

AddressSanitizer (ASan) is a fast runtime memory error detector for C/C++ that uses compiler instrumentation and shadow memory to catch heap, stack, and global out‑of‑bounds accesses, use‑after‑free, double‑free and leaks, with detailed reports and configurable options for debugging and CI.
C++addresssanitizermemory debugging
0 likes · 10 min read

This technical briefing curates 14 deep-dive articles covering AI agent evaluation methodologies, real-world task benchmarking, Google engineering lessons, Rust vs C assembly performance, MCP tool calling internals, structured logging design, minimalist agent architectures, Codex agent internals, historical developer replacement attempts, observability evolution, vLLM memory leak debugging, hotspot optimization pitfalls, and LLM non-determinism root causes.
AI agentsLLM internalsevaluation
0 likes · 9 min read

This guide explains why memory bugs are hard to locate in C/C++ programs, introduces GDB watchpoints as a way to monitor specific memory addresses, and walks through a complete example—including source code, compilation, breakpoint setting, watchpoint creation, and interpreting the hardware watchpoint output—to pinpoint the exact line that modifies a variable.
Debugginghardware-watchpointmemory debugging
0 likes · 6 min read

This guide walks Linux developers and operators through the fundamentals of kernel memory management, common memory bugs, and step‑by‑step configuration and usage of KASAN—including shadow memory, compile‑time instrumentation, kernel build options, and practical code examples—to quickly locate and fix out‑of‑bounds, use‑after‑free, and leak issues.
KASANLinuxc-programming
0 likes · 30 min read

The article introduces KASAN, a Kernel Address Sanitizer for Linux that uses shadow memory and redzones to accurately detect out‑of‑bounds accesses, use‑after‑free, and double‑free errors, explains its underlying mechanisms, shows how to enable it in the kernel, and provides extensive example code and log analysis.
KASANKernel Address SanitizerLinux kernel
0 likes · 34 min read

This article explains what memory out-of-bounds errors are, why they are dangerous in Linux C programs, and provides step‑by‑step debugging methods using logs, GDB, Valgrind, core dumps, mprotect, static analysis, and preventive coding practices.
LinuxOut-of-Boundsc-programming
0 likes · 24 min read

This article explains common memory errors, lists kernel and user‑space event sources for tracing memory activity, and demonstrates how to use BPFTrace, kprobes, and USDT probes to detect out‑of‑bounds accesses, use‑after‑free, memory leaks, OOM killer events, mmap/brk usage, shared memory operations, page faults, and reclaim processes on Linux.
OOM killerbpftracememory debugging
0 likes · 28 min read

This article introduces Valgrind, outlines its main debugging tools, provides step‑by‑step installation and usage instructions on Linux, demonstrates memory‑error detection with a sample C program, and explains how to cross‑compile Valgrind for ARM targets.
Cross-compilationDebugging Toolsmemory debugging
0 likes · 10 min read

The iQIYI backend team traced random OOM crashes in PyTorch Distributed Data Parallel on an A100 cluster to a malformed DDP message injected by a security scan, which forced a near‑terabyte allocation; using jemalloc for diagnostics, they mitigated the issue by adjusting scan policies and collaborating with PyTorch to harden the protocol.
OOMPyTorchdistributed training
0 likes · 9 min read

This article explains the principles behind HWAddressSanitizer (HWASAN), how it uses the AArch64 Top‑Byte‑Ignore hardware feature to provide lower‑overhead memory error detection than ASAN, and walks through practical examples, implementation details, and LLVM integration for C/C++ developers.
HWASANaarch64addresssanitizer
0 likes · 29 min read

This article describes a comprehensive crash governance framework for a fast‑growing mobile app, covering monitoring, root‑cause attribution, systematic remediation steps, and detailed case studies—including MIUI system bugs, 32‑bit address‑space limits, memory corruption, and WebView crashes—while outlining future challenges and automation strategies.
AndroidCrash ManagementHotfix
0 likes · 13 min read

This article explains the principles behind Google’s sanitizer tools, especially AddressSanitizer, covering symbol interposition, the interceptor mechanism, and how these techniques replace libc functions to reliably locate memory and thread errors in C++ applications on Linux.
C++Symbol Interpositionaddresssanitizer
0 likes · 18 min read

This guide explains why kernel debugging is challenging and walks through preparation steps, essential kernel configuration options, useful macros like BUG() and WARN(), logging with printk(), memory‑debugging utilities such as MEMWATCH, YAMD, Electric Fence and strace, handling OOPS messages, dynamic debugging, and setting up kdump/kexec for crash dumps.
BUG macroKDUMPkernel debugging
0 likes · 28 min read

This article explains the inner workings of KernelAddressSanitizer (KASAN) in the Linux kernel, covering how to enable it, the shadow‑memory mechanism, redzone handling for heap, global and stack allocations, and how to interpret the detailed KASAN bug reports generated at runtime.
KASANLinux kernelOut-of-Bounds
0 likes · 29 min read

KASAN, the Kernel Address Sanitizer, is a built‑in Linux kernel tool that uses shadow memory to mark each 8‑byte block’s accessibility, enabling detection of out‑of‑bounds and use‑after‑free errors while consuming about one‑eighth of RAM and requiring kernel configuration changes to activate.
KASANLinux kernelSecurity
0 likes · 8 min read

The article details a step‑by‑step forensic analysis of why a Spring Boot application migrated to the MDP framework consumed far more physical memory than its configured 4 GB heap, uncovering off‑heap allocations caused by native code, package‑scanning, and glibc memory‑pool behavior, and explains how limiting scan paths or upgrading Spring Boot resolves the issue.
JVMNative MemoryOff-heap Memory
0 likes · 12 min read

This guide explains how to use Linux performance analysis tools—including top, vmstat, perf, flame graphs, and differential flame graphs—to diagnose CPU, memory, I/O, and network bottlenecks, with step‑by‑step commands, methodology, and real‑world case studies.
CPU profilingFlame GraphI/O Monitoring
0 likes · 18 min read

This article explains why Obj‑C wild‑pointer crashes appear random, analyzes various memory‑state scenarios after object deallocation, and shows how to force deterministic crashes by filling freed memory with inaccessible patterns using Xcode's Enable Scribble and a custom free‑hook implementation.
Crash DetectionObj-Cfree hook
0 likes · 8 min read
