Research areas: Windows & Linux platforms, C/C++ backend development, embedded systems and Linux kernel, etc.
This article systematically explains C++ reference‑count changes, the precise moments when ++/-- operators trigger in shared_ptr, move, copy, reset and destroy operations, and illustrates common mistakes with concrete code examples, helping developers and interviewees avoid subtle bugs and logic errors.
The article explains how frequent Linux system calls cause costly context switches, kernel checks, and cache/TLB invalidations, presents benchmark code that quantifies the overhead of getpid, open, read, and demonstrates batch I/O, caching, and algorithmic techniques to dramatically reduce those calls and boost high‑performance C++ network services.
The article walks developers through the root causes of high CPU consumption when using select/poll, explains why epoll solves these bottlenecks, and provides a complete, pure‑C implementation that covers socket setup, epoll creation, registration, event loops, level‑trigger vs edge‑trigger modes, and performance comparisons.
This article provides a step‑by‑step visual and textual walkthrough of the TCP/IP protocol family, covering its layered architecture, mapping to the OSI model, the evolution from hubs to switches, MAC and IP addressing, routing, TCP segment fields, the three‑way handshake and four‑way teardown, plus common interview questions and code examples.
This article explains how C++ implements polymorphism through virtual tables and vptrs, walks through single‑ and multiple‑inheritance examples, compares compile‑time and runtime polymorphism, and shows practical scenarios and guidelines for when to use or avoid polymorphic designs.
The article analyzes why placing STL containers such as std::map, std::string, or std::vector directly in Linux shared memory leads to segmentation faults, detailing memory continuity, cross‑process pointer invalidation, and lifecycle issues, and then presents safe alternatives like fixed‑size arrays, manual memory management, and Boost.Interprocess.
The article explains why memory leaks and segmentation faults are hard‑to‑detect hidden bugs in Linux C++ back‑end and embedded development, illustrates common causes with concrete code samples, and walks through Linux commands and tools such as top, ps, pmap, vmstat, Valgrind, AddressSanitizer, memleak and gdb to locate and fix these issues.
The article reveals that using C++ new or malloc is far from cost‑free, detailing how Linux virtual address space, system‑call overhead, memory‑header metadata, fragmentation, and page‑fault latency all contribute to hidden performance penalties, and it offers concrete techniques such as stack allocation, memory pools, restrained PImpl usage, and startup pre‑allocation to mitigate these costs.
The article explains why conventional read/write loops cause excessive user‑kernel switches and data copies that inflate CPU usage and limit throughput for large or high‑frequency file transfers, and it presents zero‑copy and asynchronous I/O techniques with complete C++ examples to eliminate these bottlenecks.
The article explains that the default C++ std::allocator suffers from five critical defects—strong type binding, compile‑time strategy lock‑in, lack of memory pools, uncontrolled lifecycles, and redundant nested‑container allocation—leading to performance loss, fragmentation and leaks, and shows how C++17 polymorphic memory resources (PMR) redesign eliminates each flaw with a layered, runtime‑switchable architecture and three built‑in pool strategies.
