BestHub
Sign in
Tagged articles

memory management

1093 articles · Page 4 of 11
Deepin Linux
Deepin Linux
Jul 7, 2025 · Information Security

How IOMMU Safeguards Systems: From DMA Attacks to Virtualization Security

This article explains how the Input/Output Memory Management Unit (IOMMU) protects computers from DMA‑based attacks, details its architecture, DMA and interrupt remapping mechanisms, implementations across Intel, AMD and ARM, and provides practical configuration and programming guidance for secure virtualization and cloud environments.

DMAIOMMUmemory management
0 likes · 21 min read
How IOMMU Safeguards Systems: From DMA Attacks to Virtualization Security
Ops Community
Ops Community
Jul 5, 2025 · Operations

Unlock 300% Linux Performance: Proven Kernel Tuning Secrets from 10 Years of Ops

Discover how deep understanding of Linux kernel architecture, process, memory, filesystem, and network subsystems combined with practical Bash scripts can boost system performance by up to 300%, offering step‑by‑step tuning, monitoring, and debugging techniques essential for senior operations engineers.

Bash ScriptingLinux kernelkernel debugging
0 likes · 18 min read
Unlock 300% Linux Performance: Proven Kernel Tuning Secrets from 10 Years of Ops
Deepin Linux
Deepin Linux
Jul 3, 2025 · Fundamentals

Mastering std::vector: From Basics to Interview‑Level Implementation

This article walks through the fundamentals of C++'s std::vector, covering its basic concepts, common use cases, detailed implementation of key operations like push_back, pop_back, and iterators, deep source‑code analysis, and practical interview strategies for hand‑coding the container.

C++Data Structuresinterview
0 likes · 18 min read
Mastering std::vector: From Basics to Interview‑Level Implementation
IT Services Circle
IT Services Circle
Jul 1, 2025 · Information Security

Why User Programs Can’t Directly Control Memory or Shut Down Your PC

Modern operating systems prevent user‑level programs from directly managing memory, executing privileged CPU instructions, or accessing hardware I/O, because such actions would break isolation, corrupt kernel data structures, and compromise system security, leading the OS to terminate the offending process.

Kernelmemory managementoperating system
0 likes · 7 min read
Why User Programs Can’t Directly Control Memory or Shut Down Your PC
Java Tech Enthusiast
Java Tech Enthusiast
Jun 28, 2025 · Backend Development

Mastering Java Interviews: HashMap, ConcurrentHashMap, JVM GC, and SQL Tricks

This article shares a real HSBC interview experience and provides in‑depth explanations of Java HashMap internals, ConcurrentHashMap locking mechanisms, differences between synchronized and ReentrantLock, JVM garbage‑collection nuances, memory‑overflow causes, and practical SQL queries for extracting top scores.

ConcurrentHashMapHashMapJVM
0 likes · 13 min read
Mastering Java Interviews: HashMap, ConcurrentHashMap, JVM GC, and SQL Tricks
Liangxu Linux
Liangxu Linux
Jun 18, 2025 · Fundamentals

Why Page Faults Kill Performance and How to Measure Them on Linux

The article explains what page faults are, why they become performance killers, and provides practical Linux tools and tuning steps—perf, vmstat, ftrace, swappiness, mlock, and swapoff—to quantify and mitigate both major and minor page faults.

ftracememory managementpage faults
0 likes · 7 min read
Why Page Faults Kill Performance and How to Measure Them on Linux
Liangxu Linux
Liangxu Linux
Jun 16, 2025 · Fundamentals

Where Does a C++ vector Live? Stack, Heap, or Global Memory Explained

This article clarifies whether a C++ vector object resides on the stack, heap, or in static storage, explains that its elements are almost always allocated on the heap, covers special cases like small‑vector optimization, and provides interview‑ready answers with sample code and memory‑location experiments.

C++Heapinterview
0 likes · 12 min read
Where Does a C++ vector Live? Stack, Heap, or Global Memory Explained
Deepin Linux
Deepin Linux
Jun 10, 2025 · Fundamentals

How Linux Memory Reclamation Works: Zones, Swap, and Compression Explained

This article explains Linux's memory reclamation mechanisms, covering the role of memory as the system's bloodstream, the three reclamation paths (fast, direct, kswapd), zone watermarks, page cache structures, reverse mapping, and how swap and compression are used to keep the system stable under memory pressure.

Swapmemory managementmemory reclamation
0 likes · 52 min read
How Linux Memory Reclamation Works: Zones, Swap, and Compression Explained
Deepin Linux
Deepin Linux
Jun 6, 2025 · Fundamentals

Unlocking Linux Memory Management: From malloc to Buddy Allocation

This comprehensive guide explores Linux's memory management ecosystem, detailing user‑space allocators like malloc, kernel‑space mechanisms such as kmalloc, vmalloc, and mmap, and core kernel algorithms including the Buddy system, CMA, slab allocator, and memory pools, while providing code examples and practical usage tips.

Buddy AlgorithmLinuxSlab Allocator
0 likes · 60 min read
Unlocking Linux Memory Management: From malloc to Buddy Allocation
21CTO
21CTO
Jun 5, 2025 · Backend Development

Why Apple Replaced Java with Swift for a High‑Performance Password Service

Apple’s engineering team reports that replacing a high‑traffic password‑monitoring service’s Java backend with Swift reduced memory usage by 90%, cut hardware utilization in half, and boosted throughput by 40%, while also shrinking code size dramatically.

Kubernetesmemory management
0 likes · 5 min read
Why Apple Replaced Java with Swift for a High‑Performance Password Service
php Courses
php Courses
May 30, 2025 · Fundamentals

Understanding Pointers and Memory Management in Go

This comprehensive Go tutorial explains what pointers are, their basic syntax, common uses such as avoiding copies and modifying external variables, memory management including stack vs. heap and escape analysis, and outlines common pitfalls and best practices for safe and efficient pointer usage.

Goescape analysismemory management
0 likes · 8 min read
Understanding Pointers and Memory Management in Go
Deepin Linux
Deepin Linux
May 28, 2025 · Fundamentals

Understanding glibc malloc: Overview, Mechanisms, and Optimization Techniques

This article explains the role of glibc malloc in dynamic memory allocation, describes its internal data structures and allocation/free algorithms, provides a C code example, and offers practical optimization tips and common pitfalls for safe and efficient memory management.

C Programmingdynamic allocationglibc
0 likes · 13 min read
Understanding glibc malloc: Overview, Mechanisms, and Optimization Techniques
Liangxu Linux
Liangxu Linux
May 25, 2025 · Fundamentals

Master Embedded Performance: Memory, Cache, Compiler, RTOS, Security, and Power Optimization

This guide presents practical, cross‑industry techniques for advancing embedded software engineers, covering deep memory‑management practices, cache and compiler tuning, real‑time analysis, RTOS kernel customization, security hardening, layered architecture design, and power‑saving strategies such as DVFS and tickless idle.

Performance OptimizationRTOSembedded systems
0 likes · 13 min read
Master Embedded Performance: Memory, Cache, Compiler, RTOS, Security, and Power Optimization
Cognitive Technology Team
Cognitive Technology Team
May 21, 2025 · Fundamentals

Understanding Linux Page Cache: Concepts, Workflow, and Optimization

This article explains the Linux Page Cache mechanism, covering its core concepts, read/write workflows, data consistency, optimization strategies, real-world use cases, advanced topics, common misconceptions, and practical tips for improving system performance and resource management.

I/O optimizationLinuxmemory management
0 likes · 8 min read
Understanding Linux Page Cache: Concepts, Workflow, and Optimization
Liangxu Linux
Liangxu Linux
May 20, 2025 · Fundamentals

Why Pointers Exist: A Storytelling Guide to Mastering C Pointers

This article explains the historical reasons behind the invention of pointers, walks through early memory manipulation, variable abstraction, the need for shared data, and demonstrates how pointers enable address passing, dynamic memory allocation, and complex data structures such as linked lists and trees, all with clear C code examples.

C++dynamic allocationmemory management
0 likes · 15 min read
Why Pointers Exist: A Storytelling Guide to Mastering C Pointers
Java Backend Technology
Java Backend Technology
May 15, 2025 · Backend Development

Why Netty Uses FastThreadLocal Over JDK ThreadLocal: Deep Dive & Code Analysis

This article explains why Netty introduces FastThreadLocal instead of relying on JDK ThreadLocal, detailing its background, core principles, source code structure—including InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal implementations—performance implications, resource reclamation mechanisms, and practical usage within Netty’s memory allocation.

FastThreadLocalNettyThreadLocal
0 likes · 11 min read
Why Netty Uses FastThreadLocal Over JDK ThreadLocal: Deep Dive & Code Analysis
Raymond Ops
Raymond Ops
May 2, 2025 · Operations

How to Configure Linux Swap Space for Better Performance

This guide explains what swap space is, why it’s essential for Linux systems, and provides step‑by‑step instructions for configuring swap files or partitions, viewing usage, and understanding its benefits for memory extension, performance optimization, and system stability.

LinuxSwapmemory management
0 likes · 5 min read
How to Configure Linux Swap Space for Better Performance
Deepin Linux
Deepin Linux
May 1, 2025 · Fundamentals

Understanding Memory and Process Interaction: Virtual Memory, Paging, and Allocation in Linux

This article explains how memory works as a temporary storage stage for processes, describes the fundamentals of physical and virtual memory, details paging, page tables, multi‑level paging, allocation mechanisms such as brk() and mmap(), and outlines Linux memory‑management techniques including caching, swapping, and OOM handling.

MMUOOMmalloc
0 likes · 33 min read
Understanding Memory and Process Interaction: Virtual Memory, Paging, and Allocation in Linux
Code Mala Tang
Code Mala Tang
Apr 23, 2025 · Fundamentals

Why Everything Is an Object in Python: Understanding Mutable vs Immutable

This article explains Python’s core principle that every value is an object, detailing how identity, type, and value define objects, and contrasts mutable and immutable types through practical code examples, illustrating their impact on memory management, variable assignment, function arguments, and common pitfalls.

ObjectsPythonfunction arguments
0 likes · 11 min read
Why Everything Is an Object in Python: Understanding Mutable vs Immutable
dbaplus Community
dbaplus Community
Apr 23, 2025 · Databases

Why Redis Used Memory Jumped to 78 GB and How to Diagnose It

A Redis instance suddenly reported 78.9 GB of used_memory against a 16 GB maxmemory limit, triggering massive key eviction; this article explains how INFO reports used_memory, what the metric actually measures, how Redis 7 changes memory accounting, the exact eviction conditions, and provides a Python script to pinpoint the memory‑hogs.

PythonRediseviction
0 likes · 17 min read
Why Redis Used Memory Jumped to 78 GB and How to Diagnose It
FunTester
FunTester
Apr 16, 2025 · Backend Development

Common Performance Optimization Pitfalls in Go and How to Avoid Them

This article examines frequent performance optimization mistakes in Go programming—such as misunderstanding CPU cache, false sharing, data alignment, stack vs heap allocation, and inadequate use of profiling tools—provides concrete code examples, and offers practical guidelines to improve efficiency while maintaining code quality.

GoOptimizationPerformance
0 likes · 10 min read
Common Performance Optimization Pitfalls in Go and How to Avoid Them
IT Services Circle
IT Services Circle
Apr 15, 2025 · Backend Development

Lazy Import in Python: Techniques for Reducing Startup Time and Memory Usage

This article explains how Python's eager import mechanism can cause startup delays in large projects and demonstrates various lazy import techniques—including function-level imports, custom LazyLoader classes, standard library LazyLoader, and context manager approaches—to improve startup performance and reduce memory usage, supported by benchmark data and best‑practice recommendations.

Backend DevelopmentImport MechanismPerformance Optimization
0 likes · 12 min read
Lazy Import in Python: Techniques for Reducing Startup Time and Memory Usage
Linux Kernel Journey
Linux Kernel Journey
Apr 7, 2025 · Fundamentals

Understanding Linux Kernel Page Faults: Causes and Handling Strategies

The article explains how Linux triggers a page fault when a process accesses a virtual memory page that is not resident in physical RAM, describes the underlying virtual memory and MMU concepts, the kernel data structures involved, the detailed fault‑handling flow, different fault types, and their performance impact.

LinuxMMUPage Fault
0 likes · 27 min read
Understanding Linux Kernel Page Faults: Causes and Handling Strategies
Java Tech Enthusiast
Java Tech Enthusiast
Mar 26, 2025 · Fundamentals

Understanding PageCache: The Secret Behind Faster File Access

PageCache is an operating‑system mechanism that uses physical memory to cache disk blocks, dynamically resizing with available RAM and employing LRU replacement and read‑ahead, turning slow storage accesses into fast memory reads, yielding up to twenty‑fold speed gains for tasks such as compilation, video editing, and database operations.

LinuxPageCachePerformance Optimization
0 likes · 6 min read
Understanding PageCache: The Secret Behind Faster File Access
Linux Kernel Journey
Linux Kernel Journey
Mar 26, 2025 · Fundamentals

Efficient Memory Management: Paging Mechanism in x86‑64 Architecture

This article explains how the x86‑64 paging mechanism maps virtual addresses to physical memory, detailing the required protection‑mode conditions, page‑table structures, control‑register settings, various paging modes (32‑bit, PAE, 4‑level, 5‑level), and provides concrete kernel code examples and address‑translation demonstrations.

4-level-pagingLinux kernelPAE
0 likes · 40 min read
Efficient Memory Management: Paging Mechanism in x86‑64 Architecture
Tencent Technical Engineering
Tencent Technical Engineering
Mar 24, 2025 · Fundamentals

Understanding V8 Garbage Collection: Scavenger and Mark‑and‑Sweep Algorithms

V8’s garbage collector splits memory into young and old generations, using a fast Scavenger minor‑GC that marks live objects, evacuates them via semi‑space copying, and updates pointers with write barriers, while a concurrent mark‑and‑sweep major‑GC employs three‑color marking, black allocation, sweeping and optional parallel compaction, with adaptive triggering based on heap usage.

JavaScriptMark-and-SweepPerformance
0 likes · 30 min read
Understanding V8 Garbage Collection: Scavenger and Mark‑and‑Sweep Algorithms
Deepin Linux
Deepin Linux
Mar 24, 2025 · Fundamentals

Understanding Page Fault Handling and Virtual Memory Management in the uCore Kernel

This article explains how Linux-like operating systems use virtual memory and the MMU to map virtual addresses to physical memory, describes the data structures (vma_struct and mm_struct) used by uCore, details the page‑fault handling flow, classifies fault types, and shows how these mechanisms affect system performance.

KernelPage FaultVirtual Memory
0 likes · 27 min read
Understanding Page Fault Handling and Virtual Memory Management in the uCore Kernel
Tencent Docs Tech Team
Tencent Docs Tech Team
Mar 24, 2025 · Fundamentals

How V8’s Scavenger and Mark‑Sweep Algorithms Optimize JavaScript Memory Management

This article explains V8’s generational heap layout, the Scavenger minor‑GC algorithm with its marking, evacuation and pointer‑updating steps, the parallel Scavenger enhancements, the major mark‑and‑sweep collector with optional compaction, and the various triggers that decide when each garbage‑collection phase runs.

JavaScriptMark‑SweepPerformance
0 likes · 30 min read
How V8’s Scavenger and Mark‑Sweep Algorithms Optimize JavaScript Memory Management
The Dominant Programmer
The Dominant Programmer
Mar 22, 2025 · Backend Development

Java Performance Optimization: From Basics to Mastery, Techniques to Make Your Code Fly

This article explains why Java performance matters, outlines fundamental principles, and provides concrete code, memory, concurrency, I/O, and database optimization techniques, along with profiling tools, common pitfalls, real‑world case studies, and emerging trends to help developers build faster, more stable applications.

JavaPerformance Optimizationconcurrency
0 likes · 8 min read
Java Performance Optimization: From Basics to Mastery, Techniques to Make Your Code Fly
The Dominant Programmer
The Dominant Programmer
Mar 22, 2025 · Databases

Common Redis Performance Issues and How to Make Your Cache Fly

This article examines the most frequent Redis performance bottlenecks—including high memory usage, network latency, misconfiguration, poor data‑structure choices, and suboptimal persistence—explains why they occur, and provides concrete optimization techniques, monitoring commands, real‑world case studies, and emerging trends to keep your cache fast and stable.

Data StructuresPerformance OptimizationPersistence
0 likes · 8 min read
Common Redis Performance Issues and How to Make Your Cache Fly
JD Cloud Developers
JD Cloud Developers
Mar 20, 2025 · Frontend Development

Why Does Your Browser Crash? Uncover V8’s Memory Management Secrets

This article explains how V8’s memory management and garbage‑collection mechanisms work, outlines common memory‑leak scenarios in JavaScript, and provides practical techniques and tools for detecting and optimizing memory usage to prevent browser crashes and improve performance.

JavaScriptV8garbage collection
0 likes · 18 min read
Why Does Your Browser Crash? Uncover V8’s Memory Management Secrets
Lobster Programming
Lobster Programming
Mar 19, 2025 · Fundamentals

Handle vs Direct Pointer Access in the JVM: Which Is Faster?

An in‑depth look at how the JVM stores object references, comparing handle‑based access with direct pointer access, highlighting their performance trade‑offs, memory overhead, and impact on garbage collection to help developers choose the most suitable approach for their applications.

JVMJavadirect pointer
0 likes · 3 min read
Handle vs Direct Pointer Access in the JVM: Which Is Faster?
Architect's Must-Have
Architect's Must-Have
Mar 18, 2025 · Backend Development

Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal

This article explains the motivation behind Netty's FastThreadLocal, details its internal design using an indexed array to avoid hash collisions, analyzes the core source code of InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal, and discusses performance implications and reclamation strategies.

FastThreadLocalJavaNetty
0 likes · 10 min read
Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal
Top Architecture Tech Stack
Top Architecture Tech Stack
Mar 17, 2025 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Service Node

This article explains how to size and configure JVM options—including heap size, young generation, GC algorithm, thread stack, and metaspace—for a backend service that processes one million login requests per day on an 8 GB machine, providing step‑by‑step calculations, practical examples, and optimization tips.

JVMJavagarbage collection
0 likes · 24 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Service Node
Python Programming Learning Circle
Python Programming Learning Circle
Mar 13, 2025 · Fundamentals

Planned Enhancements and Performance Goals for Python 3.13

The upcoming Python 3.13 release, slated for October 2024, aims to boost interpreter performance by at least 50% through a Tier‑2 optimizer, subinterpreter support, and revamped memory management, building on groundwork completed in Python 3.12 such as low‑impact monitoring and improved bytecode compilation.

PerformanceTier-2 Optimizerinterpreter
0 likes · 5 min read
Planned Enhancements and Performance Goals for Python 3.13
Open Source Linux
Open Source Linux
Mar 12, 2025 · Fundamentals

How One Linux Kernel Patch Boosted Memory Allocation Speed by 40×

Recent testing of an Intel‑powered Linux kernel patch revealed that a single code change dramatically improved memory allocation throughput by nearly 40‑fold, highlighting the massive impact of fine‑tuned memory management optimizations and the importance of addressing THP and PMD alignment issues.

Linux kernelTHPmemory management
0 likes · 5 min read
How One Linux Kernel Patch Boosted Memory Allocation Speed by 40×
Liangxu Linux
Liangxu Linux
Mar 9, 2025 · Fundamentals

How One Line of Code Boosted Linux Kernel Memory Allocation by 40×

A single commit to the Linux kernel aligned transparent huge pages with PMD boundaries, delivering a near‑40‑fold increase in 1‑byte malloc throughput and illustrating how precise memory‑management tweaks can dramatically improve system performance.

Linux kernelPerformance OptimizationTHP
0 likes · 5 min read
How One Line of Code Boosted Linux Kernel Memory Allocation by 40×
Architect
Architect
Mar 6, 2025 · Artificial Intelligence

Analysis of the Manus Multi‑Agent AI System Architecture and Workflow

Manus is a general‑purpose AI agent that bridges thought and action through a multi‑agent architecture comprising planning, memory, and tool‑use modules, enabling autonomous task decomposition, execution, and result delivery across diverse scenarios such as travel planning, financial analysis, and education support.

AI AgentAutonomous Planningmemory management
0 likes · 15 min read
Analysis of the Manus Multi‑Agent AI System Architecture and Workflow
Tencent Technical Engineering
Tencent Technical Engineering
Feb 28, 2025 · Fundamentals

Understanding C/C++ Runtime Libraries: Concepts, Functions, Platform Implementations, and Common Issues

The article explains what the C/C++ runtime library is, how it implements essential services such as memory allocation, I/O and language features, compares it to Java, Python and JavaScript runtimes, details platform‑specific implementations (glibc, MSVC CRT, libc++, Bionic, etc.), and warns about common pitfalls like multiple CRT instances or version mismatches that can cause crashes.

C++Runtime Librarycross-platform
0 likes · 24 min read
Understanding C/C++ Runtime Libraries: Concepts, Functions, Platform Implementations, and Common Issues
Java Tech Enthusiast
Java Tech Enthusiast
Feb 28, 2025 · Fundamentals

Does Adding More RAM Speed Up a Computer?

Adding more RAM only speeds up a computer when the existing memory is insufficient, because RAM supplies data to the CPU and serves as cache; with ample RAM the CPU remains the bottleneck, so extra memory mainly enables more simultaneous programs rather than increasing raw processing speed.

PerformanceRAMVirtual Memory
0 likes · 6 min read
Does Adding More RAM Speed Up a Computer?
Python Programming Learning Circle
Python Programming Learning Circle
Feb 26, 2025 · Fundamentals

Practical Python Performance Optimization Techniques

This article presents several practical Python performance optimization methods—including __slots__ memory reduction, list comprehensions, lru_cache caching, generators for memory efficiency, and local variable usage—each explained with code examples, benchmark results, and guidance on when to apply them.

Code ProfilingPerformance Optimizationbest practices
0 likes · 13 min read
Practical Python Performance Optimization Techniques
Python Programming Learning Circle
Python Programming Learning Circle
Feb 24, 2025 · Fundamentals

Practical Python Performance Optimization Techniques

This article presents several practical Python performance‑optimization methods—including __slots__ for memory reduction, list comprehensions for faster loops, the lru_cache decorator for result caching, generators for low‑memory data processing, and local‑variable usage—to help developers write faster, more efficient code.

Code ProfilingPerformance Optimizationbest practices
0 likes · 13 min read
Practical Python Performance Optimization Techniques
Cognitive Technology Team
Cognitive Technology Team
Feb 20, 2025 · Backend Development

Understanding the Java Memory Model and Diagnosing OutOfMemoryError

This article explains the Java memory model, outlines common OutOfMemoryError types, and provides a step‑by‑step guide for diagnosing, fixing, and preventing memory‑related issues in large‑scale Java applications, including heap, metaspace, and stack analysis, JVM flag tuning, and best‑practice recommendations for resource handling and monitoring.

Backend DevelopmentJVMJava
0 likes · 8 min read
Understanding the Java Memory Model and Diagnosing OutOfMemoryError
Radish, Keep Going!
Radish, Keep Going!
Feb 20, 2025 · Backend Development

Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It

This article explains that Go plans to deprecate runtime.SetFinalizer in favor of the newer runtime.AddCleanup, demonstrates how to use SetFinalizer for resource cleanup before garbage collection, highlights common pitfalls such as extended lifetimes and memory leaks, and shows real‑world examples from the standard library and go‑cache.

AddCleanupGoSetFinalizer
0 likes · 6 min read
Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It
Refining Core Development Skills
Refining Core Development Skills
Feb 19, 2025 · Operations

Linux Kernel Memory Detection via E820 Mechanism

This article explains how the Linux kernel detects physical memory during boot by leveraging the E820 mechanism, where firmware reports memory ranges via interrupt 15H, enabling the kernel to map usable memory addresses for subsequent allocation.

E820Linux kernelOperating Systems
0 likes · 8 min read
Linux Kernel Memory Detection via E820 Mechanism
ITPUB
ITPUB
Feb 14, 2025 · Databases

Why Did Redis Crash at 100% Memory? Deep Dive into Buffer Overflows and Mitigation

An incident where massive key traffic pushed Redis memory usage to 100% revealed that buffer memory, not the dataset itself, exhausted the instance, leading to timeouts and crashes; the analysis explains the root causes, shows detailed INFO MEMORY output, and provides practical mitigation guidelines.

Key DesignPerformanceRedis
0 likes · 25 min read
Why Did Redis Crash at 100% Memory? Deep Dive into Buffer Overflows and Mitigation
Ma Wei Says
Ma Wei Says
Feb 10, 2025 · Databases

How Redis Handles Expired Keys: Periodic vs Lazy Deletion Strategies

This article explains Redis's two expiration mechanisms—periodic scanning with configurable frequency and lazy deletion on client access—detailing their configurations, execution steps, performance trade‑offs, and replication pitfalls to help developers manage memory efficiently.

Lazy DeletionRedisdatabases
0 likes · 5 min read
How Redis Handles Expired Keys: Periodic vs Lazy Deletion Strategies
Architect's Guide
Architect's Guide
Jan 30, 2025 · Backend Development

JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server

This article walks through a systematic, eight‑step approach to sizing and configuring JVM memory parameters—including heap, young generation, stack, object age thresholds, and garbage‑collector selection—so that a service handling one million daily logins on an 8 GB machine can achieve stable performance and predictable GC behavior.

JVMJavagarbage collection
0 likes · 24 min read
JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server
FunTester
FunTester
Jan 26, 2025 · Backend Development

Boost Go Performance: Master Stack Allocation and Cut Heap Usage

This article explains how Go developers can reduce heap allocations and improve runtime efficiency by understanding stack vs. heap, avoiding pointer and interface misuse, pre‑allocating slices, leveraging escape analysis, and reusing objects with sync.Pool.

GoPerformance OptimizationStack Allocation
0 likes · 8 min read
Boost Go Performance: Master Stack Allocation and Cut Heap Usage
Test Development Learning Exchange
Test Development Learning Exchange
Jan 21, 2025 · Big Data

Boost Python Performance: 10 Proven Strategies for Big Data Processing

Learn how to dramatically improve Python's speed and reduce memory usage when handling massive datasets by applying ten practical techniques—including optimal data structures, chunked file reading, generators, powerful libraries, parallel processing, memory-mapped files, databases, streaming frameworks, cloud services, and algorithmic optimizations.

OptimizationPerformancePython
0 likes · 7 min read
Boost Python Performance: 10 Proven Strategies for Big Data Processing
Liangxu Linux
Liangxu Linux
Jan 20, 2025 · Fundamentals

Stack vs Heap Memory: Deep Dive into Allocation, Usage, and Performance

This article explains the fundamental differences between stack and heap memory, covering their structures, allocation strategies, performance characteristics, language-specific examples in Java, C++, and Python, and provides guidance on when to use each type for efficient programming.

C++HeapJava
0 likes · 16 min read
Stack vs Heap Memory: Deep Dive into Allocation, Usage, and Performance
php Courses
php Courses
Jan 14, 2025 · Backend Development

Reading Large Files in PHP Using fread: Line‑by‑Line Processing

This article explains how to efficiently read large files in PHP line by line with the fread function, provides a complete code example, and discusses additional techniques such as buffering, fseek positioning, and adjusting memory limits to avoid memory overflow.

BackendLarge Filesfile-handling
0 likes · 4 min read
Reading Large Files in PHP Using fread: Line‑by‑Line Processing
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 13, 2025 · Databases

Using Multithreading in Redis: I/O Threads, Background Tasks, and Memory Allocator

The article explains how Redis, a high‑performance key‑value store, can leverage multithreading for I/O operations, background tasks like UNLINK, and jemalloc memory‑management threads, providing configuration examples and Python code to improve performance in high‑concurrency scenarios while noting the associated CPU cost.

Background TasksI/O ThreadsPython
0 likes · 6 min read
Using Multithreading in Redis: I/O Threads, Background Tasks, and Memory Allocator
Liangxu Linux
Liangxu Linux
Jan 6, 2025 · Fundamentals

Master Deep vs Shallow Copy in C++ and Follow the Rule of Three/Five

This article explains the concepts of shallow and deep copying in C++, demonstrates their pitfalls such as shared memory and double deletion, and shows how to implement proper copy constructors, assignment operators, and move semantics following the Rule of Three/Five to ensure safe and efficient resource management.

C++Deep CopyRule of Three
0 likes · 16 min read
Master Deep vs Shallow Copy in C++ and Follow the Rule of Three/Five
Raymond Ops
Raymond Ops
Dec 31, 2024 · Operations

Why Go’s GC Skips Scanning Pointer‑Free Objects and How It Boosts Performance

This article explains the Go runtime’s garbage‑collector optimization that skips scanning objects without pointers, describes how the noscan flag is set during memory allocation, shows the code paths that enforce the skip, benchmarks the performance gain, and offers practical tips for applying the technique in real‑world Go programs.

GoPerformance Optimizationgarbage collection
0 likes · 20 min read
Why Go’s GC Skips Scanning Pointer‑Free Objects and How It Boosts Performance
Deepin Linux
Deepin Linux
Dec 30, 2024 · Fundamentals

Understanding NUMA Node Detection and Memory Management in the Linux Kernel

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 kernelNUMAPerformance Optimization
0 likes · 22 min read
Understanding NUMA Node Detection and Memory Management in the Linux Kernel
Test Development Learning Exchange
Test Development Learning Exchange
Dec 29, 2024 · Fundamentals

Understanding Python's del Statement and Garbage Collection

This article explains how Python's del statement removes variable references, how the interpreter's garbage collection mechanisms reclaim memory—including reference counting and cyclic‑reference detection—and provides multiple code examples demonstrating proper resource cleanup in automated testing scenarios.

code-examplesdelgarbage collection
0 likes · 7 min read
Understanding Python's del Statement and Garbage Collection
Deepin Linux
Deepin Linux
Dec 26, 2024 · Fundamentals

Understanding C++ Smart Pointers: Types, Mechanisms, and Best Practices

This article explains how C++ smart pointers—unique_ptr, shared_ptr, weak_ptr and the deprecated auto_ptr—use RAII and reference‑counting to automate memory management, avoid leaks and dangling pointers, and provide guidelines, performance analysis, and practical usage tips for modern C++ development.

C++RAIImemory management
0 likes · 36 min read
Understanding C++ Smart Pointers: Types, Mechanisms, and Best Practices
Efficient Ops
Efficient Ops
Dec 24, 2024 · Databases

Why Is My Redis Slowing Down? 10 Common Causes and How to Fix Them

Redis can appear slow for many reasons—including baseline latency differences, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, CPU binding, swap usage, memory fragmentation, and AOF configuration—so this guide explains each cause, how to diagnose it, and practical optimization steps.

Redisdatabase optimizationlatency
0 likes · 34 min read
Why Is My Redis Slowing Down? 10 Common Causes and How to Fix Them
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 23, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.

JVMJavagarbage collection
0 likes · 25 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Lobster Programming
Lobster Programming
Dec 20, 2024 · Fundamentals

Unlocking Java’s Constant Pools: Class, Runtime, and String Explained

This article explains Java’s constant pools, detailing the class constant pool stored in .class files, its transformation into the runtime constant pool during JVM loading, and the specialized string constant pool that optimizes memory usage, including recent changes moving it to heap memory.

Constant PoolJVMJava
0 likes · 3 min read
Unlocking Java’s Constant Pools: Class, Runtime, and String Explained
IT Services Circle
IT Services Circle
Dec 18, 2024 · Databases

Understanding Redis Maxmemory and Eviction Policies

This article explains how Redis limits memory with the maxmemory setting, how to view and modify it, details the available eviction strategies—including the newer LFU policies—and offers guidance on choosing a policy, monitoring usage, and scaling with Redis Cluster.

Redis Clustercachingeviction policy
0 likes · 7 min read
Understanding Redis Maxmemory and Eviction Policies
Ops Development & AI Practice
Ops Development & AI Practice
Nov 26, 2024 · Operations

How Linux’s OOM Killer Works and How to Protect Critical Processes

Linux’s OOM Killer activates when memory is exhausted, scoring processes based on usage, priority, and kernel settings, then terminating the highest‑scoring one; the article explains its background, scoring algorithm, influencing parameters, and practical steps such as adjusting oom_score_adj, optimizing memory use, and using cgroups to safeguard essential services.

LinuxOOM Killercgroups
0 likes · 5 min read
How Linux’s OOM Killer Works and How to Protect Critical Processes
Programmer1970
Programmer1970
Nov 25, 2024 · Backend Development

Deep Dive into Elasticsearch Memory Architecture and Optimization

The article explains Elasticsearch's on‑heap and off‑heap memory design, details each memory pool and its management via LRU, describes Lucene's role in off‑heap storage, and provides practical tips for configuring JVM heap size, cache strategies, and monitoring to achieve stable, high‑performance search.

ElasticsearchJVMLucene
0 likes · 8 min read
Deep Dive into Elasticsearch Memory Architecture and Optimization
Liangxu Linux
Liangxu Linux
Nov 24, 2024 · Fundamentals

What Is an Operating System? Core Functions, Features, and Architecture Explained

This article provides a comprehensive overview of operating systems, explaining their essence as software, detailing core functions such as process and memory management, device and file system handling, security, user interfaces, and describing key characteristics like concurrency, sharing, asynchrony, virtualization, as well as common OS classifications and architectural designs.

OS fundamentalsProcess Managementconcurrency
0 likes · 15 min read
What Is an Operating System? Core Functions, Features, and Architecture Explained
Top Architect
Top Architect
Nov 22, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.

JVMJavagarbage collection
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node