BestHub
Sign in
Tagged articles
950 articles
Page 5 of 10
Open Source Linux
Open Source Linux
May 22, 2023 · Fundamentals

How Virtual Memory Works: From CPU Addressing to Linux Implementation

Virtual memory abstracts physical memory, giving each process a private, contiguous address space, and relies on CPU virtual addressing, MMU translation, page tables, TLB caching, multi-level paging, Linux’s memory mapping, dynamic allocation, and garbage collection to efficiently manage memory and protect processes.

Memory ManagementOperating SystemVirtual Memory
0 likes · 29 min read
How Virtual Memory Works: From CPU Addressing to Linux Implementation
Liangxu Linux
Liangxu Linux
May 16, 2023 · Fundamentals

How Virtual Memory Works: From CPU Addressing to Linux Implementation

This article explains the concepts and mechanisms of virtual memory, covering CPU virtual addressing, page tables, TLB caching, page faults, multi‑level page tables, Linux's memory‑mapping structures, and dynamic allocation strategies such as fragmentation and garbage collection.

Memory ManagementPagingTLB
0 likes · 27 min read
How Virtual Memory Works: From CPU Addressing to Linux Implementation
JD Cloud Developers
JD Cloud Developers
May 10, 2023 · Fundamentals

Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1

This article explores the evolution of Java garbage collectors—from the simple Serial and Parallel collectors to the concurrent CMS and region-based G1—detailing their algorithms, tuning parameters, strengths, weaknesses, and best‑practice recommendations for selecting the optimal collector based on workload and memory constraints.

Garbage CollectionJVMJava
0 likes · 14 min read
Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1
ByteDance Web Infra
ByteDance Web Infra
May 9, 2023 · Fundamentals

WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC

This article provides a comprehensive overview of the WebAssembly runtime, detailing its binary format, module loading and validation, execution engine designs, linear memory layout, garbage‑collection proposals, and the WebAssembly System Interface (WASI), while illustrating each concept with diagrams and code examples.

CompilationGarbage CollectionMemory Management
0 likes · 34 min read
WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC
Tencent Music Tech Team
Tencent Music Tech Team
May 9, 2023 · Mobile Development

Optimizing Animated Image Loading on iOS: Practices and Performance Comparison

The article explains how iOS’s lack of native GIF/WebP support leads to crashes when decoding all frames, and describes an optimized per‑frame loading component (QMAnimatedImageView) that uses CADisplayLink, NSCache, downsampling and memory‑limit tuning to dramatically reduce CPU, memory usage and jank while preserving smooth animation.

Animated ImagesMemory ManagementPerformance Optimization
0 likes · 22 min read
Optimizing Animated Image Loading on iOS: Practices and Performance Comparison
ByteFE
ByteFE
May 8, 2023 · Fundamentals

Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI

This article provides a comprehensive technical analysis of the WebAssembly runtime architecture, detailing the module loading and parsing process, stack-based execution engines, linear memory management strategies, and the evolving garbage collection proposals, while also introducing the WebAssembly System Interface (WASI) for cross-platform system interactions.

Bytecode ExecutionGarbage CollectionMemory Management
0 likes · 32 min read
Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI
Bin's Tech Cabin
Bin's Tech Cabin
May 4, 2023 · Fundamentals

How Linux’s Slab Allocator Manages Memory: Deep Dive into Fast and Slow Paths

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.

Memory ManagementNUMAlinux
0 likes · 41 min read
How Linux’s Slab Allocator Manages Memory: Deep Dive into Fast and Slow Paths
JD Cloud Developers
JD Cloud Developers
Apr 27, 2023 · Fundamentals

Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide

This article explains the JVM's runtime memory structure—including the method area, heap, stacks, and program counter—details object memory layout, garbage collection roots, marking algorithms, generational models, and various GC algorithms such as mark‑sweep, mark‑copy, and mark‑compact, providing a comprehensive overview.

GC AlgorithmsGarbage CollectionGenerational GC
0 likes · 16 min read
Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide
Liangxu Linux
Liangxu Linux
Apr 19, 2023 · Fundamentals

Understanding Linux System Architecture: Kernel, Memory, Processes, and More

This article provides a comprehensive Q&A guide covering Linux system components, kernel subsystems, memory addressing, process concepts, scheduling algorithms, interrupt handling, system calls, synchronization mechanisms, file system structure, and device driver classifications, offering clear explanations for each topic.

Memory Managementlinux
0 likes · 16 min read
Understanding Linux System Architecture: Kernel, Memory, Processes, and More
Bin's Tech Cabin
Bin's Tech Cabin
Apr 11, 2023 · Fundamentals

How Linux Kernel Builds Slab Caches: A Deep Dive into kmem_cache Creation

This article walks through the Linux kernel's slab allocator, explaining how kmem_cache and kmem_cache_node structures are created, how slab objects are laid out in memory, how the required number of pages is calculated, and how the allocator is bootstrapped to avoid circular dependencies.

Linux kernelMemory Managementkernel-development
0 likes · 64 min read
How Linux Kernel Builds Slab Caches: A Deep Dive into kmem_cache Creation
Python Programming Learning Circle
Python Programming Learning Circle
Apr 10, 2023 · Fundamentals

Common Python Design Questions and Explanations

This article explains why Python uses indentation for block grouping, how floating‑point arithmetic works, why strings are immutable, the purpose of the explicit self parameter, the absence of assignment in expressions, and many other design decisions that shape Python's syntax and runtime behavior.

Data StructuresFAQMemory Management
0 likes · 27 min read
Common Python Design Questions and Explanations
Laravel Tech Community
Laravel Tech Community
Apr 5, 2023 · Backend Development

PHP Performance Optimization: String Handling, Statements, Functions, Variables, Arrays and Architecture

This article presents a comprehensive set of PHP performance‑optimization techniques, covering efficient string operations, statement usage, function design, variable handling, array manipulation and architectural choices such as compression, static pages and caching, all illustrated with concrete code examples.

BackendMemory Managementcoding practices
0 likes · 14 min read
PHP Performance Optimization: String Handling, Statements, Functions, Variables, Arrays and Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2023 · Backend Development

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

This article presents a comprehensive, step‑by‑step guide on estimating capacity, selecting and configuring garbage collectors, sizing heap, young and survivor spaces, tuning thread stacks, and adding diagnostic options for a Java service that must handle one million login requests per day on a server with 8 GB of memory.

CMSG1Garbage Collection
0 likes · 26 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
AI Cyberspace
AI Cyberspace
Mar 27, 2023 · Fundamentals

Understanding Linux Memory Allocation: Buddy, Slab, and Slub Explained

Linux’s memory allocation mechanisms—Buddy for main memory and Slab/Slub for CPU cache—aim to maximize memory utilization, minimize fragmentation, and boost allocation efficiency, with detailed explanations of their structures, operation steps, and how to inspect them via /proc interfaces.

Memory ManagementSLUBSlab Allocator
0 likes · 9 min read
Understanding Linux Memory Allocation: Buddy, Slab, and Slub Explained
Java Backend Technology
Java Backend Technology
Mar 24, 2023 · Backend Development

Optimizing JVM Settings for 1M Daily Logins on an 8GB Server

This article walks through a step‑by‑step approach to sizing JVM heap, young generation, GC selection, and related parameters for a platform handling one million login requests per day on a node with 8 GB memory, providing practical formulas, example configurations, and tuning tips.

Garbage CollectionJVMJava
0 likes · 24 min read
Optimizing JVM Settings for 1M Daily Logins on an 8GB Server
AI Cyberspace
AI Cyberspace
Mar 24, 2023 · Fundamentals

Unlock Faster Linux Performance with Huge Pages: Why and How

This article explains Linux huge pages, their performance benefits, implementation details, configuration steps, and the impact on memory reporting, including guidance on using and disabling Transparent Huge Pages for optimal system tuning.

Huge PagesMemory ManagementTLB
0 likes · 14 min read
Unlock Faster Linux Performance with Huge Pages: Why and How
58 Tech
58 Tech
Mar 21, 2023 · Mobile Development

Flutter Performance, Layout, and Memory Optimization Techniques

This article explains how to detect and resolve performance bottlenecks in Flutter apps by using compile modes, profiling tools, layout tree insights, widget build optimizations, const constructors, list view strategies, raster thread tuning, and memory‑saving practices such as oversized‑image detection and layer separation.

Memory ManagementMobile DevelopmentPerformance Optimization
0 likes · 14 min read
Flutter Performance, Layout, and Memory Optimization Techniques
Architect
Architect
Mar 18, 2023 · Backend Development

How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server

This article explains a step‑by‑step methodology for estimating capacity, selecting appropriate garbage collectors, sizing JVM memory regions, and tuning advanced parameters such as survivor ratio, tenuring threshold, and Metaspace to reliably support a login service that processes one million requests per day on a machine with 8 GB of RAM.

BackendGarbage CollectionJVM
0 likes · 25 min read
How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
JD Tech
JD Tech
Mar 16, 2023 · Fundamentals

A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC

This article explains the fundamentals of Java garbage collection, detailing classic algorithms such as reference counting, reachability analysis, mark‑sweep, copying, mark‑compact, and generational collectors, then introduces modern collectors like Serial, Parallel, CMS, G1, and the low‑latency ZGC, highlighting their mechanisms, advantages, and drawbacks.

Garbage CollectionJVMMemory Management
0 likes · 27 min read
A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC
Soul Technical Team
Soul Technical Team
Mar 14, 2023 · Mobile Development

Memory Optimization and Leak Detection in Flutter iOS Apps: Image Component, PlatformView, IOSurface and Tooling

This article analyzes the high memory consumption of Flutter's Image widget, PlatformView leaks, and IOSurface residues on iOS, then presents concrete solutions such as external texture rendering, empty‑page redraw, engine reset, and a custom Expando‑based memory‑leak detector built with Dart VM Service.

ExpandoFlutterMemory Management
0 likes · 21 min read
Memory Optimization and Leak Detection in Flutter iOS Apps: Image Component, PlatformView, IOSurface and Tooling
Top Architect
Top Architect
Mar 8, 2023 · Backend Development

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

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap, young generation, GC algorithm, Metaspace, and safety‑point settings—for a high‑traffic login service that receives one million requests per day on a server with 8 GB of memory, providing both practical code examples and interview‑style explanations.

BackendGarbage CollectionJVM
0 likes · 25 min read
JVM Parameter Tuning for a Service Handling 10 Million Daily Login Requests on an 8 GB Node
Open Source Linux
Open Source Linux
Mar 7, 2023 · Fundamentals

How Virtual Memory Powers Modern Operating Systems: A Deep Dive

Virtual memory abstracts physical memory, providing each process with a private, contiguous address space, while the CPU, MMU, page tables, TLB, and paging mechanisms collaborate to translate virtual addresses, manage page faults, and optimize performance through locality, multi‑level tables, and memory‑mapped files.

Memory ManagementOperating SystemsPaging
0 likes · 31 min read
How Virtual Memory Powers Modern Operating Systems: A Deep Dive
Selected Java Interview Questions
Selected Java Interview Questions
Mar 5, 2023 · Backend Development

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

This article walks through a systematic approach to sizing and configuring JVM memory and garbage‑collector parameters for a service handling one million login requests per day on an 8 GB server, covering capacity planning, GC selection, heap region sizing, thread‑stack settings, dynamic age thresholds, large‑object handling, and diagnostic options such as heap dumps and GC logging.

Garbage CollectionJVMJava
0 likes · 23 min read
JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node
MaGe Linux Operations
MaGe Linux Operations
Mar 3, 2023 · Databases

How Redis Manages Memory Exhaustion: Expiration, Eviction, LRU & LFU

Redis uses key expiration commands, periodic scanning, and a combination of lazy and active deletion strategies, and when memory is full it applies one of eight eviction policies—including refined LRU and LFU algorithms with sampling and decay mechanisms—to decide which keys to discard.

Eviction PoliciesKey ExpirationLFU
0 likes · 13 min read
How Redis Manages Memory Exhaustion: Expiration, Eviction, LRU & LFU
AI Cyberspace
AI Cyberspace
Feb 28, 2023 · Fundamentals

Mastering C Pointers: From Value Semantics to Advanced Pointer Types

This article explains C's value semantics versus reference semantics, introduces pointers as the bridge between them, details pointer definitions, types, operators, and common pitfalls such as null, dangling, and wild pointers, and demonstrates pointer arithmetic with clear code examples.

CMemory Managementprogramming fundamentals
0 likes · 12 min read
Mastering C Pointers: From Value Semantics to Advanced Pointer Types
AI Cyberspace
AI Cyberspace
Feb 27, 2023 · Fundamentals

Master C Data Types: From Basics to Platform‑Specific Details

This article provides a comprehensive overview of C language data types, covering basic, derived, pointer, void, and derived types, their memory sizes, value ranges, signedness, platform‑dependent variations, and related keywords such as sizeof, size_t, and fixed‑width uintX_t types.

CData TypesMemory Management
0 likes · 11 min read
Master C Data Types: From Basics to Platform‑Specific Details
NiuNiu MaTe
NiuNiu MaTe
Feb 22, 2023 · Databases

Master Redis String Internals: Common Interview Questions & Answers

This article reviews essential Redis string concepts, covering typical interview questions, encoding types, the EMBSTR threshold, SDS structure, and memory allocation details to help readers solidify their understanding of Redis string implementation.

BackendMemory ManagementSDS
0 likes · 8 min read
Master Redis String Internals: Common Interview Questions & Answers
37 Interactive Technology Team
37 Interactive Technology Team
Feb 20, 2023 · Fundamentals

Fundamentals of the JVM: HotSpot, JIT, Memory Areas, Garbage Collection, and Class Loading

The article explains how the HotSpot JVM executes Java by interpreting bytecode, using client or server JIT compilers to translate hot methods into native code, describes the five runtime memory areas, outlines major garbage‑collection algorithms and tuning options, and details the class‑loading process and hierarchical classloader model.

JITJVMJava
0 likes · 24 min read
Fundamentals of the JVM: HotSpot, JIT, Memory Areas, Garbage Collection, and Class Loading
Su San Talks Tech
Su San Talks Tech
Feb 8, 2023 · Backend Development

Boost Java Performance with Off‑Heap Caching: A Practical OHC Guide

This article explains why moving large local caches to off‑heap memory using the open‑source OHC library can reduce GC pressure, provides a step‑by‑step demo with custom serialization, compares it with a HashMap OOM example, and dives into the library's core allocation mechanisms and configuration options.

JavaMemory ManagementOHC
0 likes · 18 min read
Boost Java Performance with Off‑Heap Caching: A Practical OHC Guide
Architecture Digest
Architecture Digest
Feb 5, 2023 · Databases

Redis Memory Management and Optimization Practices

This article explains Redis's internal memory architecture, details the various memory components such as used_memory, object memory, client buffers, and fragmentation, and provides practical optimization techniques and real‑world case studies to reduce memory usage and improve performance.

Memory Managementdatabasesperformance
0 likes · 22 min read
Redis Memory Management and Optimization Practices
Baidu App Technology
Baidu App Technology
Feb 2, 2023 · Fundamentals

Inside iOS: How Mach Virtual Memory and Memory Pressure Work

This article explains the architecture of Mach virtual memory in iOS, details its page‑based management, describes the core data structures and kernel APIs, analyzes the Objective‑C alloc implementation, and walks through the memory‑pressure (Jetsam) mechanism that triggers low‑memory warnings.

MachMemory ManagementVirtual Memory
0 likes · 21 min read
Inside iOS: How Mach Virtual Memory and Memory Pressure Work
Tencent Database Technology
Tencent Database Technology
Jan 18, 2023 · Databases

In‑depth Analysis of MySQL InnoDB Buffer Pool Architecture and Performance Optimizations

This article provides a comprehensive technical walkthrough of MySQL‑8.0.22 InnoDB's buffer pool, detailing its physical and logical structures, page management algorithms, fast read/write optimizations, change buffer, adaptive hash index, and the complete page‑read call stack, complete with code excerpts and diagrams.

Database PerformanceInnoDBMemory Management
0 likes · 47 min read
In‑depth Analysis of MySQL InnoDB Buffer Pool Architecture and Performance Optimizations
Alibaba Terminal Technology
Alibaba Terminal Technology
Jan 16, 2023 · Mobile Development

How to Extend iOS App Virtual Address Space and Boost Memory Limits

This article explores iOS memory optimization by enabling the 'com.apple.developer.kernel.extended-virtual-addressing' entitlement to expand virtual address space and the 'com.apple.developer.kernel.increased-memory-limit' entitlement to raise memory caps, detailing implementation steps, kernel analysis, test results, and practical implications for app stability.

Memory ManagementVirtual Address Spaceentitlements
0 likes · 11 min read
How to Extend iOS App Virtual Address Space and Boost Memory Limits
Alibaba Cloud Native
Alibaba Cloud Native
Jan 14, 2023 · Cloud Native

Why Java Apps OOM in Kubernetes Even Below Xmx and How to Fix It

This article explains why Java applications running in Kubernetes can encounter Out‑Of‑Memory errors despite heap usage staying under the Xmx limit, by examining container resource limits, JVM memory models, cgroup behavior, and provides practical configuration recommendations to prevent OOM.

Cloud NativeJVMJava
0 likes · 16 min read
Why Java Apps OOM in Kubernetes Even Below Xmx and How to Fix It
Open Source Linux
Open Source Linux
Jan 12, 2023 · Fundamentals

Why Intel’s Linear Address Masking (LAM) Was Rejected from Linux 6.2

Intel’s Linear Address Masking (LAM) feature, which repurposes unused bits of 64‑bit virtual addresses for metadata, was proposed for Linux 6.2 but faced strong criticism from Linus Torvalds and was ultimately not merged, prompting Intel to rewrite the code for a future kernel release.

Intel LAMLinux kernelMemory Management
0 likes · 5 min read
Why Intel’s Linear Address Masking (LAM) Was Rejected from Linux 6.2
Sohu Tech Products
Sohu Tech Products
Jan 11, 2023 · Mobile Development

Deep Dive into Swift Array Implementation and Copy‑On‑Write Mechanics

This article provides a comprehensive, low‑level exploration of Swift's Array type, detailing its memory layout, the SIL generation process, buffer allocation, internal structures such as _ArrayBuffer and _ContiguousArrayStorage, and the copy‑on‑write behavior that governs mutation and reference counting.

ArrayCopy-on-WriteLow-Level Debugging
0 likes · 18 min read
Deep Dive into Swift Array Implementation and Copy‑On‑Write Mechanics
Bin's Tech Cabin
Bin's Tech Cabin
Dec 28, 2022 · Fundamentals

How Linux Allocates Physical Memory: Inside the Kernel’s Buddy Allocator

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.

Memory ManagementNUMAallocation
0 likes · 68 min read
How Linux Allocates Physical Memory: Inside the Kernel’s Buddy Allocator
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 23, 2022 · Fundamentals

Four JVM Garbage Collection Algorithms Explained

This article introduces the four main JVM garbage collection algorithms—Mark‑Sweep, Copying, Mark‑Compact, and Generational collection—explaining their mechanisms, suitable scenarios, advantages, and drawbacks, and summarizing how they are applied to young and old generations in modern Java virtual machines.

CopyingGarbage CollectionGenerational GC
0 likes · 7 min read
Four JVM Garbage Collection Algorithms Explained
High Availability Architecture
High Availability Architecture
Dec 23, 2022 · Fundamentals

Understanding Linux C++ Memory Management: Theory and Classification

This article explains the fundamentals of Linux memory management for C++ backend services, covering memory size categories, lifetime classifications, allocation mechanisms such as kmalloc, vmalloc, brk, mmap, virtual‑to‑physical mapping, lazy allocation, and the performance considerations that guide efficient memory usage.

Memory ManagementOperating Systemlinux
0 likes · 11 min read
Understanding Linux C++ Memory Management: Theory and Classification
php Courses
php Courses
Dec 20, 2022 · Databases

Redis Memory Not Releasing Issue and Analysis of 20 Million Expiring Keys

This article describes a Redis 5.0 memory leak scenario where 20 million keys with expiration caused memory not to be released, details the investigation steps, findings about the activeExpireCycle, and concludes that memory will eventually be freed, followed by a promotional announcement for a PHP online live class.

Memory ManagementPHPdatabases
0 likes · 3 min read
Redis Memory Not Releasing Issue and Analysis of 20 Million Expiring Keys
Baidu Geek Talk
Baidu Geek Talk
Dec 16, 2022 · Fundamentals

Exploring ptmalloc: Memory Management in Linux C++ Programs

The article explains how glibc’s default ptmalloc allocator structures memory into main and non‑main arenas, uses chunk‑based bins (fast, unsorted, small, large) for allocation and deallocation, details its locking and OS‑interaction mechanisms, and evaluates its design trade‑offs versus modern allocators.

CFreeMemory Management
0 likes · 12 min read
Exploring ptmalloc: Memory Management in Linux C++ Programs
Liangxu Linux
Liangxu Linux
Nov 29, 2022 · Fundamentals

Master C Pointers: From Basics to Multi‑Level and Array Techniques

This guide explains C pointers, covering their definition, basic syntax, pointer arithmetic, multi‑level pointers, the relationship between pointers and multi‑dimensional arrays, and the distinction between array pointers and pointer arrays, supplemented with clear code examples and visual analogies.

ArraysCMemory Management
0 likes · 12 min read
Master C Pointers: From Basics to Multi‑Level and Array Techniques
Baidu Geek Talk
Baidu Geek Talk
Nov 21, 2022 · Mobile Development

How Baidu App Prevents OOM Crashes with Real‑Time Memory Monitoring and Prediction

This article details Baidu's multi‑step memory‑control solution for its iOS app, covering background challenges, real‑time memory monitoring, page‑level memory prediction, water‑level determination, frequency control, proactive degradation, and code examples that together reduce OOM incidents on low‑end devices.

Memory ManagementMobile DevelopmentOOM prevention
0 likes · 17 min read
How Baidu App Prevents OOM Crashes with Real‑Time Memory Monitoring and Prediction
Bin's Tech Cabin
Bin's Tech Cabin
Nov 21, 2022 · Fundamentals

Inside Linux Physical Memory Management: From FLATMEM to NUMA, Watermarks, and Page Structures

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.

Memory ManagementNUMAlinux
0 likes · 99 min read
Inside Linux Physical Memory Management: From FLATMEM to NUMA, Watermarks, and Page Structures
Liangxu Linux
Liangxu Linux
Nov 20, 2022 · Fundamentals

Does Adding More RAM Really Speed Up Your PC? Explained

Adding more RAM can improve performance only when memory is a bottleneck; if your system already has sufficient memory, extra RAM won’t make the CPU run faster, though it does allow more programs to run simultaneously, while insufficient memory can severely slow down tasks.

CPUMemory ManagementOperating System
0 likes · 7 min read
Does Adding More RAM Really Speed Up Your PC? Explained
Top Architect
Top Architect
Nov 17, 2022 · Fundamentals

Understanding Java String Object Creation and Memory Allocation

This article explains how Java handles string literals and new String objects, detailing the creation of objects in the constant pool and heap, the resulting memory layout, and the outcomes of reference comparisons, while also providing code examples and additional resources.

Constant PoolJavaMemory Management
0 likes · 5 min read
Understanding Java String Object Creation and Memory Allocation
Programmer DD
Programmer DD
Nov 10, 2022 · Backend Development

How to Choose the Right Java Base Image, JDK/JRE, and Optimize Container Settings

This guide walks through selecting Alpine or Debian base images, deciding between JDK and JRE, picking Oracle or OpenJDK, choosing the appropriate JVM, handling graceful shutdown signals, configuring memory limits across JDK versions, managing DNS cache, and leveraging GraalVM native compilation for Java containers.

DNSDockerJVM
0 likes · 22 min read
How to Choose the Right Java Base Image, JDK/JRE, and Optimize Container Settings
Dada Group Technology
Dada Group Technology
Oct 28, 2022 · Mobile Development

iOS Memory Management, OOM Causes, and Leak Monitoring Strategies

This article explains iOS memory architecture, the reasons behind Out‑of‑Memory (OOM) crashes, common sources of memory pressure, and practical approaches—including MLeaksFinder and FBRetainCycleDetector—to monitor, detect, and mitigate memory leaks and abnormal memory growth in iOS applications.

Memory ManagementMobile DevelopmentOOM
0 likes · 17 min read
iOS Memory Management, OOM Causes, and Leak Monitoring Strategies
dbaplus Community
dbaplus Community
Oct 26, 2022 · Databases

Mastering Redis Expiration and Eviction: LRU vs LFU Explained

This article explains how Redis handles key expiration, the three expiration deletion strategies, the eight memory‑eviction policies configurable via maxmemory, and the inner workings of Redis's LRU and LFU algorithms, including sampling, lru_clock, and counter decay mechanisms.

Eviction PoliciesLFULRU
0 likes · 13 min read
Mastering Redis Expiration and Eviction: LRU vs LFU Explained
Tuanzi Tech Team
Tuanzi Tech Team
Oct 26, 2022 · Backend Development

Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips

Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.

Garbage CollectionJVMJava
0 likes · 20 min read
Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips
phodal
phodal
Oct 24, 2022 · Industry Insights

Unlocking Ultra-Fast Systems: Key Patterns Behind Low‑Latency Architecture

This article provides a comprehensive overview of low‑latency architecture, covering network hardware, system‑level programming strategies, language choices, memory management techniques, event‑driven designs, high‑performance data structures, and visualization approaches for building ultra‑fast computing systems.

Event-Driven ArchitectureHigh‑performance computingJava performance
0 likes · 10 min read
Unlocking Ultra-Fast Systems: Key Patterns Behind Low‑Latency Architecture
Bin's Tech Cabin
Bin's Tech Cabin
Oct 24, 2022 · Fundamentals

Unlocking Linux Kernel Memory Management: From Virtual Addresses to Physical Memory

This comprehensive guide explores Linux kernel memory management, explaining virtual and physical address concepts, the layout of process and kernel virtual memory spaces on 32‑ and 64‑bit systems, the role of mm_struct and vm_area_struct, and how ELF binaries are mapped into memory, while also detailing DRAM organization and CPU memory access.

Memory ManagementVirtual Memorylinux
0 likes · 82 min read
Unlocking Linux Kernel Memory Management: From Virtual Addresses to Physical Memory
Top Architect
Top Architect
Sep 27, 2022 · Databases

Configuring Redis Memory Size and Eviction Policies (LRU and LFU)

Redis caches can fill up, requiring memory eviction; this guide explains how to set Redis maxmemory (e.g., 5GB), choose appropriate eviction policies such as allkeys-lru or allkeys-lfu, and details the underlying LRU and LFU algorithms and their configuration commands.

LFULRUMemory Management
0 likes · 7 min read
Configuring Redis Memory Size and Eviction Policies (LRU and LFU)
Selected Java Interview Questions
Selected Java Interview Questions
Sep 23, 2022 · Backend Development

Diagnosing and Resolving a Native Memory Leak in Spring Boot Applications

This article details the investigation of an unexpected native memory consumption issue in a Spring Boot service, describing how JVM and system‑level tools were used to pinpoint the leak caused by the Spring Boot loader's Inflater usage and how configuring MCC scan paths or upgrading Spring Boot eliminated the problem.

JVMMemory ManagementNative Memory Leak
0 likes · 12 min read
Diagnosing and Resolving a Native Memory Leak in Spring Boot Applications
Aikesheng Open Source Community
Aikesheng Open Source Community
Sep 21, 2022 · Operations

Understanding MemAvailable and min_free_kbytes in Linux: Why free -m Shows Different Values and How to Adjust for OceanBase Installation

The article explains why the free command reports more memory than the available column, describes how the kernel calculates MemAvailable using min_free_kbytes and watermarks, and provides practical guidance on tuning min_free_kbytes to meet OceanBase's memory requirements.

MemAvailableMemory ManagementOceanBase
0 likes · 6 min read
Understanding MemAvailable and min_free_kbytes in Linux: Why free -m Shows Different Values and How to Adjust for OceanBase Installation
Tencent Cloud Developer
Tencent Cloud Developer
Sep 14, 2022 · Backend Development

Understanding Go Stack Memory Management

The article explains how Go’s runtime manages goroutine stacks—starting with a 2 KB initial size, evolving from segmented to continuous stacks, detailing allocation via stackpool and stackLarge, expansion with runtime.newstack, shrinkage by the garbage collector, and the internal structures that coordinate these processes.

GoMemory ManagementRuntime
0 likes · 15 min read
Understanding Go Stack Memory Management
Architects' Tech Alliance
Architects' Tech Alliance
Aug 22, 2022 · Fundamentals

DPDK Performance Tuning: Influencing Factors and Optimization Techniques

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 optimizationDPDKMemory Management
0 likes · 11 min read
DPDK Performance Tuning: Influencing Factors and Optimization Techniques
ELab Team
ELab Team
Aug 4, 2022 · Fundamentals

Understanding V8’s Memory Management and Garbage Collection Strategies

This article explains how the V8 JavaScript engine manages memory through stack and heap allocation, describes its generational garbage‑collection architecture—including New Space, Old Space, and various GC algorithms—and offers practical optimization techniques to reduce pause times and improve performance.

Garbage CollectionJavaScriptMemory Management
0 likes · 21 min read
Understanding V8’s Memory Management and Garbage Collection Strategies
Python Programming Learning Circle
Python Programming Learning Circle
Aug 3, 2022 · Fundamentals

Why Python Has No Pointers and How to Simulate Them

This article explains why native pointers do not exist in Python, describes the underlying object model, immutable versus mutable objects, the distinction between variables and names, and demonstrates several practical ways to emulate pointer behavior using mutable containers, custom classes, and the ctypes module.

Memory ManagementMutable TypesPython
0 likes · 18 min read
Why Python Has No Pointers and How to Simulate Them
Programmer DD
Programmer DD
Jul 26, 2022 · Fundamentals

Java GC Evolution: From JDK 8 to JDK 18 and Performance Gains

Since JDK 8, HotSpot’s garbage collectors have undergone extensive refinements—introducing G1 as default, adding ZGC and Shenandoah, and optimizing Parallel GC—resulting in notable gains in throughput, reduced pause latency, and lower auxiliary memory usage, as demonstrated by SPECjbb2015 benchmarks across JDK 8 to JDK 18.

Garbage CollectionHotSpotJDK
0 likes · 21 min read
Java GC Evolution: From JDK 8 to JDK 18 and Performance Gains
ByteFE
ByteFE
Jul 25, 2022 · Mobile Development

MemoryThrashing: A Solution for Live Streaming Memory OOM Issues

MemoryThrashing is a self-developed tool designed to detect and analyze memory thrashing issues in live streaming applications, addressing the challenges of OOM problems by providing efficient memory growth monitoring and analysis capabilities.

Memory ManagementMemory analysisMobile Development
0 likes · 10 min read
MemoryThrashing: A Solution for Live Streaming Memory OOM Issues
Top Architect
Top Architect
Jul 14, 2022 · Databases

Understanding Redis Memory Model and Its Applications

This article explains Redis's memory model, covering memory statistics, internal structures such as redisObject, SDS, and various object types, their encoding schemes, memory allocation, fragmentation, and provides practical examples for estimating memory usage, optimizing consumption, and monitoring fragmentation in high‑performance applications.

Memory ManagementPerformance Optimizationdatabase
0 likes · 30 min read
Understanding Redis Memory Model and Its Applications
Tencent Cloud Developer
Tencent Cloud Developer
Jul 12, 2022 · Fundamentals

Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)

Based on Google’s TCMalloc, Go’s automatic memory system organizes memory into pages and spans, uses per‑processor mcache and shared mcentral for size‑class allocation, and employs a concurrent tri‑color mark‑sweep garbage collector triggered by heap usage or large allocations, illustrating the full allocation‑to‑reclamation pipeline.

Garbage CollectionGoMemory Management
0 likes · 21 min read
Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)
Architects' Tech Alliance
Architects' Tech Alliance
Jul 1, 2022 · Fundamentals

Understanding Operating System Evolution, Boundaries, and Memory Management

This article explains how operating systems acquire execution rights from BIOS, traces their historical evolution from mainframes to modern platforms, examines their core functions and business value, and delves into memory management techniques such as real‑mode, protected‑mode, virtual memory, paging, and page‑fault handling.

Boot ProcessMemory ManagementOperating System
0 likes · 19 min read
Understanding Operating System Evolution, Boundaries, and Memory Management
TAL Education Technology
TAL Education Technology
Jul 1, 2022 · Fundamentals

Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture

This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.

Garbage CollectionHeapJVM
0 likes · 30 min read
Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture
Java Backend Technology
Java Backend Technology
Jul 1, 2022 · Big Data

How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading

This article explains how to generate a 10 GB file of age data, read it efficiently on a machine with limited memory, and use both single‑threaded and multithreaded Java techniques—including a producer‑consumer model and divide‑and‑conquer—to identify the age that appears most frequently, while analyzing performance, memory usage, and CPU utilization.

Big DataFile ProcessingJava
0 likes · 13 min read
How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading
Sohu Tech Products
Sohu Tech Products
Jun 30, 2022 · Mobile Development

Understanding the Implementation of weak Pointers in the Objective‑C Runtime

This article explains how Objective‑C implements weak pointers using a hash‑based weak table, SideTables, ExplicitInit, and various low‑level C++ template functions such as storeWeak, weak_register_no_lock, and weak_clear_no_lock to ensure automatic nil‑assignment and safe deallocation.

C++ templatesMemory ManagementObjective‑C
0 likes · 19 min read
Understanding the Implementation of weak Pointers in the Objective‑C Runtime
Senior Brother's Insights
Senior Brother's Insights
Jun 26, 2022 · Backend Development

How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management

This article explains ZGC’s evolution from an experimental feature in JDK 11 to a production‑ready collector in JDK 15, detailing its sub‑10 ms pause guarantee, memory‑mapping architecture, colored pointers, region layout, read barriers, and the multi‑phase concurrent collection process that together deliver low‑latency, high‑throughput garbage collection for Java applications.

Colored PointersConcurrent GCGarbage Collection
0 likes · 16 min read
How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management
Top Architect
Top Architect
Jun 24, 2022 · Fundamentals

Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter

This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.

Garbage CollectionHeapJVM
0 likes · 13 min read
Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter
Liangxu Linux
Liangxu Linux
Jun 22, 2022 · Fundamentals

Understanding Linux Memory Management: From Process Allocation to OOM and Cache

This article provides a comprehensive walkthrough of Linux kernel memory management, covering process address space layout, memory allocation mechanisms, OOM selection criteria, where allocated memory resides, and both manual and automatic memory reclamation techniques, complete with code examples and diagrams.

CacheMemory ManagementOOM
0 likes · 20 min read
Understanding Linux Memory Management: From Process Allocation to OOM and Cache
Zuoyebang Tech Team
Zuoyebang Tech Team
Jun 9, 2022 · Frontend Development

Re‑engineering a Live‑Streaming Frontend to Cut Black‑Screen Errors & Boost Performance

Facing fragmented devices, high memory usage, and unreliable signaling, the Zuoyebang live‑streaming frontend was redesigned with container‑based isolation, a modular SDK, and state‑synchronization mechanisms, resulting in timely memory reclamation, reduced CPU load, and dramatically lower black‑screen incidents.

Container ArchitectureMemory ManagementPerformance Optimization
0 likes · 13 min read
Re‑engineering a Live‑Streaming Frontend to Cut Black‑Screen Errors & Boost Performance
Open Source Linux
Open Source Linux
Jun 6, 2022 · Fundamentals

Unlock 50,000 Words of C/C++ Mastery: Key Concepts, Code & Tips

This comprehensive C/C++ knowledge base covers everything from basic syntax, const, static, and this pointers to advanced topics like inline functions, virtual methods, smart pointers, STL containers, data structures, algorithms, operating system concepts, networking layers, and common interview problems, complete with code examples and diagrams.

AlgorithmsCData Structures
0 likes · 66 min read
Unlock 50,000 Words of C/C++ Mastery: Key Concepts, Code & Tips
TAL Education Technology
TAL Education Technology
Jun 2, 2022 · Game Development

Unity Memory Management and Performance Optimization Guide

This article provides a comprehensive introduction to Unity memory concepts—including physical, virtual, native, and managed memory—and offers practical optimization techniques for native and managed resources, graphics rendering, and tooling to improve game performance on both desktop and mobile platforms.

Game DevelopmentManaged MemoryMemory Management
0 likes · 23 min read
Unity Memory Management and Performance Optimization Guide