Tagged articles
NUMA
83 articles · Page 1 of 1
This article explains why Linux servers trigger OOM kills even when free memory appears available, covering global OOM, cgroup limits, Kubernetes OOMKilled, systemd-oomd, NUMA constraints, and application-level memory errors, with a step-by-step evidence-based troubleshooting methodology.
KubernetesLinux OOMNUMA
0 likes · 31 min read

The article analyzes why Elasticsearch underperforms on Chinese ARM-based CPUs — citing weak single-core performance, complex NUMA topologies, JDK selection pitfalls, version compatibility gaps, and unfair benchmarking — and evaluates Easysearch as a supported alternative with vendor-backed compatibility across major domestic chips and OSes.
ARMChinese chipsEasysearch
0 likes · 13 min read

This article details Linux kernel memory and CPU tuning techniques for high-concurrency systems, covering watermark scaling to avoid direct reclaim storms, dirty page writeback thresholds, swap and overcommit settings, transparent huge page pitfalls, NUMA zone reclaim, CPU governor and IRQ affinity, and Kubernetes CFS quota throttling solutions.
CPU schedulingKubernetes CFS quotaLinux kernel tuning
0 likes · 35 min read

This article presents a practical guide for performance stress testing in domestic microservice containerization, addressing three core challenges—lack of unified computing power conversion, non-linear multi-core scalability, and frequent base software iterations—through standardized baselines, quantitative modeling, multi-core optimization, and continuous governance frameworks.
ARM ArchitectureContainerizationNUMA
0 likes · 17 min read

An intermittent Redis timeout in a Kubernetes pod was traced not to Redis or the network but to uneven soft‑interrupt handling on a single CPU core, caused by irqbalance moving interrupts across NUMA nodes, and resolved by aligning NIC queues, adjusting irqbalance, and reserving CPUs.
KubernetesLinuxNUMA
0 likes · 11 min read

This article explains what interviewers expect when they ask about implementing a low‑latency C++ trading system, covering hardware‑level concepts such as cache hierarchy, false sharing, NUMA, kernel bypass, CPU pinning, lock‑free programming, memory‑order semantics, and modern C++ techniques that together achieve microsecond‑ or nanosecond‑scale determinism.
C++NUMAhigh-frequency trading
0 likes · 34 min read

This article explains the core principles of NUMA architecture, how it is deeply integrated into Linux kernel memory management, process scheduling, and system calls, and provides practical commands and real‑world examples to diagnose and optimize NUMA‑related performance issues.
Linux kernelNUMAProcess Scheduling
0 likes · 24 min read

The article walks through six concrete, reproducible methods for diagnosing and improving Linux CPU performance—including using perf for profiling, binding processes to specific cores, adjusting scheduling priorities, setting the CPU governor, leveraging NUMA awareness, and fine‑tuning kernel scheduler parameters—while showing real command examples and measured impact.
CPUNUMAnumactl
0 likes · 11 min read

This article systematically breaks down Linux's core memory mechanisms, identifies common performance bottlenecks, and demonstrates how to use tools like numastat, perf, and Valgrind together with kernel parameters such as swappiness and min_free_kbytes to achieve practical memory optimizations.
HugePagesLinuxMemory
0 likes · 55 min read

SLUB, the default Linux kernel memory allocator, reduces fragmentation and improves allocation speed for frequently created objects like task_struct and inode by using per‑CPU caches, object slabs, and NUMA‑aware node caches, with detailed structures, allocation/free paths, tuning parameters, and real‑world case studies.
Linux kernelNUMAPerformance Tuning
0 likes · 46 min read

This article explains the core principles of NUMA, its deep integration with the Linux kernel, practical memory‑node and scheduling mechanisms, real‑world database and virtualization use cases, and step‑by‑step commands for inspecting and tuning NUMA on modern servers.
Linux kernelNUMAmemory management
0 likes · 23 min read


TonyBaiMar 12, 2026 · Backend Development
A 128‑core, 256‑thread server should boost Go microservice performance, but the author explains how NUMA architecture, Go's scheduler affinity loss during GC pauses, and non‑NUMA‑aware memory allocation cause cache misses, remote memory penalties, and higher latency, preventing linear scaling.
ConcurrencyGoHigh‑core performance
0 likes · 9 min read

The article explains how high‑frequency trading systems suffer tail‑latency spikes due to memory placement and NUMA effects, and provides a step‑by‑step guide to redesign thread, data, and cache layouts for deterministic low‑latency performance.
HFTMemory ArchitectureNUMA
0 likes · 10 min read

Netflix discovered that scaling hundreds of containers on modern CPUs hit severe lock‑contention due to mount‑related kernel locks, with performance varying across AWS instance types, NUMA designs, and hyper‑threading, leading them to redesign containerd mounting and choose hardware‑aware scheduling to restore efficient scaling.
AWSCPU architectureContainerd
0 likes · 16 min read


TonyBaiJan 31, 2026 · Backend Development
The article analyzes recent Go runtime meeting notes that reveal upcoming changes such as lightweight race detection via software or hardware, a new instant‑open Trace UI with on‑demand slicing, read/write Trace APIs, pprof modernization removing global variables, NUMA‑aware GC optimizations and sharded counters, all pointing to a more usable and high‑performance Go 1.27.
Execution TraceGoNUMA
0 likes · 8 min read

Most engineers blame slow CPUs for performance issues, but the true bottleneck is often data latency—from registers and caches to DRAM, NUMA nodes, disks, and networks—so understanding and minimizing data movement is key to reducing tail latency and improving system performance.
NUMASystemsdata locality
0 likes · 11 min read

The HBox scheduling platform tackles large‑scale AI cluster challenges by introducing a three‑pool resource model, priority‑based preemptive scheduling, network‑topology and NUMA‑aware dispatch, and GPU virtualization techniques like MIG and vGPU, dramatically improving GPU utilization, SLA guarantees, and overall cluster efficiency.
AI clustersGPU schedulingGPU virtualization
0 likes · 24 min read

This comprehensive guide walks you through Linux memory management fundamentals, from prerequisite environments and a quick checklist to step‑by‑step installation of monitoring tools, memory diagnostics, kernel parameter adjustments, THP and swap optimization, NUMA affinity tuning, validation, Prometheus alerts, security hardening, troubleshooting, rollback procedures, best‑practice recommendations, and ready‑to‑use scripts and configuration snippets.
LinuxNUMAPerformance Tuning
0 likes · 24 min read

This article explains why a newly purchased 128‑core AMD EPYC server may perform worse than a 32‑core machine, demonstrates how improper CPU affinity and NUMA configuration cause severe performance loss, and provides step‑by‑step practical methods—including system topology analysis, taskset, numactl, kernel scheduler tweaks, and container settings—to achieve up to 300% improvement.
CPU affinityNUMA
0 likes · 15 min read

This article explains the fundamentals of NUMA architecture, why it matters for multithreaded Linux applications, and provides step‑by‑step practical guidance—including kernel internals, memory allocation policies, useful commands, and performance‑monitoring tools—to help developers optimize memory locality and boost overall program efficiency.
LinuxMultithreadingNUMA
0 likes · 37 min read

This article explains the hardware basis of NUMA, how Linux reads ACPI SRAT/SLIT tables to discover CPU‑memory topology, the kernel functions that initialize NUMA structures, and how tools like numactl can be used to optimize application performance on multi‑node servers.
ACPILinux kernelMemory Architecture
0 likes · 14 min read

This article explains why heterogeneous servers cause CPU performance layering, describes how to detect the issue using metrics such as NUMA hit/miss rates, cache miss ratios and frequency states, and provides step‑by‑step remediation techniques—including NUMA binding, cache isolation, recompilation and frequency locking—to improve resource pooling efficiency in modern data centers.
CPU performanceNUMAcache optimization
0 likes · 24 min read

This article explains the hardware basis of NUMA, how Linux reads ACPI SRAT and SLIT tables to discover CPU‑memory topology, the kernel functions that initialize NUMA structures, and how the memblock allocator incorporates this information to enable performance‑optimizing tools like numactl.
ACPILinux kernelNUMA
0 likes · 13 min read

At Netdev 0x19, ByteDance's STE team presented two technical talks: a NUMA‑aware MPTCP flow‑selection strategy that boosts Redis benchmark throughput by up to 30% and cuts tail latency by 6%, and a DPDK‑based user‑space MPTCP stack that halves latency and doubles throughput in data‑center tests.
DPDKLinux networkingMPTCP
0 likes · 8 min read

At Netdev 0x19, ByteDance's STE team presented two talks—one on a NUMA‑locality‑aware MPTCP flow‑selection strategy that can raise throughput by up to 30% and lower tail latency by 6%, and another on a DPDK‑based user‑space MPTCP stack that reduces latency by nearly 10% and more than doubles throughput—showcasing practical performance gains for data‑center networking.
DPDKMPTCPNUMA
0 likes · 8 min read

The article explains how Linux kernel scheduling uses a hierarchical topology—balancing load and preserving cache affinity—by mapping real‑world multi‑core hardware structures such as sockets, dies, clusters, and NUMA nodes to sched_domain and sched_group, and shows how to inspect and tune this layout with CONFIG_SCHED_DEBUG and QEMU simulation.
LinuxNUMAhardware topology
0 likes · 9 min read

The article explains how Linux builds sched_domain and sched_group hierarchies based on physical CPU topology—sockets, dies, clusters, and NUMA nodes—illustrating load‑balancing (BALANCE) versus affinity (AFFINE) with concrete examples, kernel code references, and QEMU‑based experiments.
CPU topologyNUMAkernel scheduling
0 likes · 9 min read

This article explains the fundamentals of NUMA architecture, how Linux detects and represents NUMA nodes, the memory zone hierarchy, allocation policies, and practical techniques such as using numactl and taskset to bind processes for optimal performance on multi‑socket servers.
Linux kernelNUMAmemory management
0 likes · 22 min read

Virtualization resource scheduling algorithms, especially in OpenStack, address fragmented CPU allocation and uneven node utilization by dynamically consolidating VMs, employing NUMA-aware placement, and using resource scoring to trigger migrations, ultimately improving utilization, reducing costs, and enhancing performance in cloud environments.
NUMAOpenStackcloud computing
0 likes · 12 min read

This article provides a comprehensive, step‑by‑step guide to tuning Kunpeng‑based servers, covering hardware characteristics, matrix‑multiplication benchmarks, NUMA‑aware scheduling, compiler and JDK optimizations, acceleration libraries, disk and NIC tuning, and a practical MariaDB performance‑tuning workflow.
CPU optimizationKunpengLinux
0 likes · 17 min read

Collaborating across TencentOS and database kernel teams, the article details how architecture upgrades—moving to TKE HouseKeeper, switching to AMD CPUs, and adding a portable 16 KB atomic‑write feature—combined with kernel optimizations like huge‑page support, NUMA‑aware qspinlocks, speculative page‑fault handling, and ORC unwinding to deliver up to 30 % mixed workload and over 100 % write‑only performance gains while reducing memory usage.
NUMAORC unwinderatomic write
0 likes · 16 min read

This article provides a comprehensive guide to optimizing Kunpeng‑based servers, covering hardware characteristics, matrix multiplication benchmarks, Von Neumann architecture insights, soft and hard acceleration, compiler and JDK tweaks, NUMA tuning, Nginx and OpenSSL acceleration, disk and network optimizations, application‑level tuning, and a step‑by‑step MariaDB performance‑tuning checklist.
CPU performanceKunpengLinux
0 likes · 16 min read

Koordinator v1.5.0, the 13th major release since its open‑source debut, introduces pod‑level NUMA alignment, Terway network QoS, core scheduling, and numerous performance and stability improvements, while also being accepted as a CNCF Sandbox project and outlining future roadmap plans.
Core SchedulingKubernetesNUMA
0 likes · 14 min read

This article consolidates DPDK 17.11 source‑code notes to explain the library’s memory‑management subsystem, covering hugepage concepts, shared configuration mapping, NUMA‑aware allocation, and the custom allocator that enables high‑throughput packet processing on Linux.
DMADPDKHugePages
0 likes · 40 min read

Large folios in the Linux kernel combine multiple pages to reduce TLB misses, page faults, and reclamation cost while enabling more efficient compression; they are supported by filesystems like XFS and bcachefs, and recent patches add multi‑size THP, swap‑in/out handling, TAO allocation, NUMA balancing, and debug tools, with OPPO’s production deployment showing performance gains and motivating broader adoption and fragmentation mitigation.
NUMASwapTLB
0 likes · 17 min read

This guide walks through Linux virtualization management and performance tuning, covering tuned profiles for guests and hosts, kernel parameters, NUMA awareness, CPU pinning, memory limits, KSM configuration, qcow2 image creation, disk cache modes, I/O throttling, and monitoring commands to optimize KVM workloads.
KSMKVMLinux
0 likes · 21 min read

After migrating workloads to a new CPU platform, unexpected performance regressions can occur, but Baidu Cloud's Btune tool provides automated, multi‑dimensional analysis and actionable optimization suggestions that helped a test program improve its execution time by 36.8% through memory and NUMA tuning.
BenchmarkBtuneCPU
0 likes · 9 min read

Katalyst v0.4.0 introduces tidal colocation for mixed workloads, online resource overcommit, fine‑grained NUMA memory management, OOM priority enhancements, and topology‑aware scheduling, providing a comprehensive cost‑optimization solution for cloud‑native Kubernetes clusters.
KubernetesNUMAOOM Priority
0 likes · 12 min read

This article explains how Baidu Cloud’s Btune performance‑diagnostic tool helps identify CPU, memory and NUMA bottlenecks, provides automatic optimization suggestions, and demonstrates a real‑world test that improves a memory‑intensive program’s runtime by up to 36.8% after applying the recommended changes.
BtuneNUMAcloud computing
0 likes · 10 min read

This article explains DPDK's memory management architecture, covering the hierarchical memory layout, hugepage discovery and mapping, shared configuration structures, NUMA‑aware allocation, custom malloc‑heap implementation, memzone and mempool creation, and the mbuf buffer model, with detailed code examples.
HugePagesNUMAShared Memory
0 likes · 41 min read

This guide explains the performance limitations of Neutron OVS networking, introduces SR‑IOV as a high‑performance I/O virtualization solution, and provides step‑by‑step configuration for enabling SR‑IOV agents, mapping physical networks, creating VLAN and flat networks, handling NUMA affinity, security groups, and bonding, with detailed command examples and XML snippets.
NUMANeutronOVS
0 likes · 27 min read

This article dissects the Linux kernel’s slab allocator, explaining its complete architecture, the fast‑path allocation from per‑CPU caches, the slow‑path mechanisms involving partial lists, NUMA node caches, and fallback to the buddy system, while detailing object initialization and freelist construction.
LinuxNUMAmemory management
0 likes · 41 min read

This article explains NUMA architecture, its multithreaded performance overheads such as remote memory access, cache synchronization, context and mode switches, interrupt handling, TLB misses, and memory copies, and then presents optimization techniques like NUMA and CPU affinity, IRQ tuning, and large‑page usage.
CPU affinityLinuxMultithreading
0 likes · 20 min read

This article explains common Linux memory‑related performance bottlenecks—such as memory reclamation, page‑cache pressure, huge‑page usage, and cross‑NUMA access—and provides practical tuning methods to improve latency and throughput on servers and applications.
NUMAhuge pages
0 likes · 16 min read

This article walks through Linux kernel physical memory allocation, explaining the hierarchy of allocation interfaces, the role of gfp_mask and ALLOC flags, the fast and slow allocation paths, memory watermarks, NUMA zone handling, and the complex fallback mechanisms including compaction, direct reclaim, and OOM, all illustrated with code snippets and diagrams.
LinuxNUMAallocation
0 likes · 68 min read

This article provides an in‑depth, step‑by‑step explanation of how the Linux kernel organizes and manages physical memory, covering memory models (FLATMEM, DISCONTIGMEM, SPARSEMEM), NUMA vs. UMA architectures, zone partitioning, watermarks, reserved pages, hot‑cold page handling, and the detailed struct page layout used for both anonymous and file‑backed pages.
LinuxNUMAmemory management
0 likes · 99 min read

This article provides a comprehensive technical overview of DPDK, covering its architecture, core libraries, platform modules, polling and CPU‑affinity techniques, huge‑page memory management, NUMA considerations, OS tuning steps, and integration with OVS for high‑performance packet processing.
CPU affinityDPDKHugePages
0 likes · 18 min read

This article explains how hardware architecture, Linux OS version, kernel configuration, OVS integration, memory management, NUMA awareness, and CPU micro‑architecture affect DPDK application performance and provides concrete tuning steps such as CPU isolation, service disabling, huge‑page setup, and optimized memory allocation.
CPU optimizationDPDKLinux
0 likes · 11 min read

This article explains the three main commercial server architectures—SMP, NUMA, and MPP—detailing their structures, performance characteristics, scalability limits, and suitability for OLTP versus data‑warehouse workloads, while also covering practical considerations such as virtualization and real‑world examples.
MPPNUMAParallel Processing
0 likes · 16 min read

This article explains Linux virtual memory, the page‑fault allocation process, the two memory‑reclaim paths (kswapd and direct reclaim), OOM killer scoring, swappiness tuning, NUMA‑aware reclamation, and practical steps to protect critical processes from being killed.
LinuxNUMAOOM killer
0 likes · 19 min read

This article explains Linux virtual memory concepts, the process of memory allocation, page fault handling, background and direct memory reclamation methods, LRU-based page types, NUMA considerations, tuning parameters like swappiness and min_free_kbytes, and strategies to prevent OOM killer termination.
LinuxNUMAOOM killer
0 likes · 18 min read

Evaluating the Cloud Music online estimation system on NUMA‑based servers revealed that CPU pinning across both memory nodes dramatically boosts throughput on high‑end 96‑core machines—up to 75% for complex models—while low‑end servers gain only modestly, confirming NUMA‑aware scheduling’s critical role for CPU‑intensive inference workloads.
CPU architectureNUMAonline inference
0 likes · 8 min read

This article explains why container workloads suffer from CPU throttling and NUMA‑related performance loss in cloud‑native environments, examines Kubelet's CPU allocation policies, demonstrates the impact of CPU bursts and topology‑aware scheduling, and shows how Alibaba Cloud ACK mitigates these issues with concrete data.
Alibaba Cloud ACKCPU BurstCPU throttling
0 likes · 11 min read

The article analyzes the instability of shared‑type virtual machines, introduces enterprise‑level instances with fixed CPU scheduling and NUMA topology, details the applied technologies such as CPU pinning, PCI‑Passthrough and multi‑queue NICs, and presents extensive sysbench and STREAM benchmark results that demonstrate superior isolation, stability and performance of enterprise instances over shared ones.
CPU pinningNUMAcloud computing
0 likes · 12 min read

This article explains NUMA architecture with hyper‑threading, details CPU cache hierarchies and access latencies, and provides Linux tools and practical optimization techniques to improve cache‑hit rates and minimize cross‑NUMA memory delays.
CPU cacheHyper-ThreadingLinux
0 likes · 9 min read

This guide explains NUMA memory hierarchy, shows how to install and use the numactl command, interprets hardware and NUMA statistics, and presents memory allocation strategies to improve performance on multi‑node Linux systems.
LinuxNUMAnumactl
0 likes · 9 min read

This article outlines the main server hardware architectures—SMP, UMA, and NUMA—explains shared-storage models, details multi-core cache structures from private L1 to shared L3, compares access latencies, and discusses inter-core communication mechanisms and cache coherency protocols.
CacheMemoryNUMA
0 likes · 14 min read

This article explains the Linux kernel scheduler's core concepts, walks through the initialization code of the 5.4 kernel (including run queues, scheduling classes, domains, and groups), and details how multi‑core and NUMA topologies are handled to achieve balanced CPU usage.
CFSLinuxNUMA
0 likes · 23 min read

This article explains Linux's sophisticated scheduling system for multi‑core, SMP, and NUMA architectures, describes global, clustered, partitioned, and arbitrary schedulers, details scheduling domains and load‑balancing mechanisms, and provides practical performance‑tuning techniques using tools like perf, flame graphs, and various kernel optimizations.
BFSCFSCPU optimization
0 likes · 31 min read

This article explains how Linux manages physical address space using SMP and NUMA architectures, describes the node, zone, and page data structures, details page allocation via the buddy system and slab allocator, and outlines user‑ and kernel‑mode page‑fault handling, swapping, and address translation mechanisms.
LinuxNUMAmemory management
0 likes · 17 min read

This article explains NUMA architecture, how its memory allocation policies can cause swap‑related performance issues for MySQL, provides step‑by‑step methods to disable NUMA at BIOS, kernel or MySQL levels, and discusses the innodb_numa_interleave parameter and best‑practice recommendations.
LinuxMySQLNUMA
0 likes · 7 min read

This article examines Ceph’s architecture, identifies performance bottlenecks on Huawei’s Kunpeng ARM platform, and presents practical tuning methods—including NUMA placement, cache tagging, vector acceleration, thread scaling, and monitoring tools—to improve storage efficiency, reduce latency, and lower power consumption.
ARMCephKunpeng
0 likes · 17 min read


ITPUBJan 25, 2021 · Fundamentals
This article explains how Linux 3.10 organizes memory using NUMA nodes, zones, the buddy system, and the SLAB allocator, providing commands, code examples, and visual diagrams to illustrate each layer of the kernel's efficient memory management.
LinuxNUMAbuddy system
0 likes · 11 min read

This article explains the Linux kernel memory management hierarchy—including NUMA nodes, memory zones, the buddy system for free pages, and the SLAB allocator—providing command‑line examples, code snippets, and visual diagrams to illustrate how the kernel efficiently allocates and reclaims memory.
LinuxNUMAbuddy system
0 likes · 11 min read


ITPUBDec 16, 2020 · Databases
This article investigates how large a single Redis instance can be on a 64 GB server, explains the NUMA memory‑allocation trap, and documents experiments that compare unbound versus CPU‑memory‑affinity‑bound deployments, revealing when swap and OOM occur.
LinuxNUMAmemory management
0 likes · 11 min read

This article explains the core principles of DPDK memory management, covering standard huge pages, NUMA node binding, direct memory access, IOMMU and IOVA addressing, custom allocators, and memory pools, and how these mechanisms together enable high‑performance packet processing on Linux systems.
DMADPDKIOMMU
0 likes · 14 min read

This article provides a comprehensive overview of server hardware fundamentals, covering server form factors, motherboard architecture, selection criteria, major vendors, CPU concepts and performance, NUMA, memory specifications, disk throughput and IOPS, as well as network card types and bonding modes.
CPUNUMANetwork Card
0 likes · 13 min read


ITPUBMay 10, 2020 · Databases
This case study details the migration of Weimeng's MySQL databases to Tencent Cloud CDB, describing the testing methodology, performance bottlenecks discovered (NUMA, network parameters, low‑concurrency issues, and version bugs), the step‑by‑step optimizations applied, and the resulting QPS improvements across various workloads.
Database MigrationMySQLNUMA
0 likes · 20 min read

This article explores the physical structure of RAM, compares random and sequential memory I/O performance, examines real‑world bandwidth versus advertised specs, delves into NUMA latency differences, and shows practical optimization techniques for PHP7 and Redis based on deep hardware and kernel knowledge.
IO performanceLinux kernelMemory
0 likes · 8 min read

This article documents a hands‑on experiment that allocates a 50 GB Redis instance on a 64 GB dual‑node machine, explores NUMA behavior, demonstrates how memory affinity can trigger swap, and concludes with practical recommendations for Redis memory sizing and NUMA binding.
LinuxNUMARedis
0 likes · 9 min read

This article presents a detailed case study of intermittent container timeout problems in a Kubernetes environment, examining kernel upgrades, NUMA configurations, CPU affinity bindings, kubelet behavior, cadvisor overhead, and hardware faults, and outlines the investigative steps and solutions applied.
CPU affinityHardware FaultKubernetes
0 likes · 8 min read

This guide explains how to improve network subsystem performance on Kunpeng processors by using tools such as ethtool and strace, adjusting PCIe payload size, binding NIC interrupts to NUMA‑local cores, tweaking interrupt coalescing, enabling TSO, and replacing select with epoll for high‑concurrency workloads.
EpollKunpengNUMA
0 likes · 12 min read

The article explains how modern servers with multiple CPUs and memory modules connect via legacy Front Side Bus and modern NUMA architectures, demonstrates Linux commands to inspect memory topology, and presents benchmark results showing latency differences between intra‑node and inter‑node memory accesses.
CPULinuxMemory
0 likes · 7 min read

This article introduces practical CPU and memory subsystem performance tuning for Kunpeng processors, covering optimization concepts, key parameters, common monitoring tools such as top, perf and numactl, and detailed methods like NUMA binding, prefetch control, timer tuning, TLB page size adjustment, and thread concurrency optimization.
CPU TuningKunpengMemory Optimization
0 likes · 15 min read

This article introduces the Kunpeng processor’s NUMA architecture, contrasts it with traditional SMP designs, and presents a practical five‑step methodology for performance optimization, helping developers on Kunpeng platforms achieve better scalability and efficiency through targeted memory‑access tuning.
KunpengNUMAPerformance Tuning
0 likes · 5 min read

During a client’s upgrade test, a database’s compressed tables exhibited severe slowdown under concurrent full‑table scans, which we traced to CPU cache line false sharing in the decompression code; using Linux perf tools we identified the hotspot, aligned memory, and restored performance.
CPU cacheDatabase PerformanceLinux perf
0 likes · 13 min read

ZGC is a scalable, low‑latency Java garbage collector designed to keep pause times under 10 ms regardless of heap size, supporting up to 4 TB, and leveraging concurrent, region‑based, compacting, NUMA‑aware techniques, colored pointers, and load barriers, with detailed compilation and tuning guidance.
JDKJavaNUMA
0 likes · 8 min read

This article introduces graph computing, compares it with graph databases, surveys notable graph processing systems, and details the architecture, NUMA‑aware design, execution model, push/pull dual mode, and load‑balancing strategies of the JoyGraph framework while outlining its future development directions.
JoyGraphNUMAbig data
0 likes · 9 min read

The article investigates massive packet loss in Meituan‑Dianping's Redis service despite 10 Gbps NIC upgrades, traces the issue to kernel receive‑buffer drops and single‑CPU interrupt handling, and presents a step‑by‑step optimization using backlog tuning, CPU and Redis affinity, and NUMA‑aware placement to eliminate drops and improve latency.
LinuxNUMAPerformance Tuning
0 likes · 30 min read

This article explains the concepts of MPI, OpenMPI, and OpenMP, compares three major server architectures—SMP, NUMA, and MPP—and discusses their performance characteristics, scalability limits, and typical application scenarios in high‑performance computing.
HPCMPIMPP
0 likes · 13 min read

The article investigates why massive Redis deployments experience network packet loss despite using 10 Gbps NICs, explains how Linux kernel counters such as net.if.in.dropped are derived from /proc/net/dev, walks through the driver‑to‑kernel processing path, and proposes CPU‑affinity, interrupt‑affinity and NUMA‑aware tuning to eliminate the drops.
CPU affinityLinux kernelNUMA
0 likes · 28 min read

This article explains the origins and mechanics of Huge Pages, why they are not a universal solution, how they can degrade performance on NUMA architectures, and provides practical testing methods and mitigation strategies for developers and system administrators.
NUMATLBhuge pages
0 likes · 12 min read

The article analyzes the challenges of scaling network devices to handle ten‑million concurrent connections (C10M) and describes Alibaba's AGW solution, which uses lock‑free data planes, hugepages, NUMA‑aware memory placement, and user‑space NIC drivers to achieve high‑performance four‑layer load balancing.
C10MNUMAhugepage
0 likes · 9 min read
