Research areas: Windows & Linux platforms, C/C++ backend development, embedded systems and Linux kernel, etc.
This article thoroughly explains Linux shared memory, covering its advantages over other IPC methods, the kernel data structures, virtual‑physical mapping, creation and destruction APIs, copy‑on‑write behavior, and provides complete example code for inter‑process communication.
This article explains the fundamentals of Linux CPU affinity, compares soft and hard binding, shows how to use taskset, sched_setaffinity, numactl and cgroup cpuset, and provides real‑world case studies for servers, game frameworks, Nginx and Hadoop clusters.
This article explains the purpose of Linux's separate signal stack, how it differs from the regular process stack, the mechanics of signal delivery, practical code examples for enabling and using it, and why it matters for stability, real‑time processing, multithreading, and performance optimization.
This article explains why interrupt stack overflows are dangerous in Linux, outlines their root causes, shows how to locate them using logs and debugging tools, and provides practical strategies to prevent and resolve the issue for stable kernel operation.
This article explains the role of the Linux user stack in multithreaded programs, covering its memory layout, how each thread gets a private stack, stack frame mechanics, growth and overflow handling, and practical examples of creating and debugging stacks with pthreads and gdb.
This practical guide walks you through Linux kernel stack backtracing, covering GDB installation, core dump analysis, handling corrupted stacks, and advanced tracing techniques using ftrace and eBPF, with step‑by‑step commands, code examples, and troubleshooting tips to pinpoint the root cause of crashes.
This article explains the fundamentals of Linux thread stack memory, identifies why default stack sizes can cause waste or overflow in high‑concurrency scenarios, and provides practical techniques—including stack‑size tuning, code refactoring, and memory‑mapping—to reduce memory usage and improve service stability.
This article explains how Linux thread stacks work, why improper stack size or unchecked recursion can cause crashes and memory leaks, and provides practical debugging tools, stack‑size tuning methods, and optimization techniques—including thread‑pool usage and real‑world case studies—to keep concurrent programs stable and efficient.
This comprehensive guide explains the Linux process stack architecture, stack frame layout, function call mechanics, dynamic growth limits, common pitfalls such as stack overflow and memory leaks, and demonstrates debugging techniques with gdb, pstack, and perf, plus a real‑world C++ example.
This guide walks readers through the fundamentals of the Linux kernel, explaining its core subsystems, source tree layout, process management, memory handling, file systems, networking, device drivers, debugging tools, and practical learning resources, while providing code examples and command‑line utilities for hands‑on exploration.
