BestHub
Sign in
Tagged articles

memory management

1093 articles · Page 5 of 11
Java Architecture Stack
Java Architecture Stack
Nov 18, 2024 · Fundamentals

Inside Go’s Runtime: How mcache and mheap Manage Memory

This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.

Goconcurrencygarbage collection
0 likes · 12 min read
Inside Go’s Runtime: How mcache and mheap Manage Memory
Architect
Architect
Nov 14, 2024 · Backend Development

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

This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.

BackendJVMJava
0 likes · 24 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
Lobster Programming
Lobster Programming
Nov 12, 2024 · Databases

Why Deploying MySQL in Docker Can Be Problematic: Scaling & Memory Pitfalls

This article explains why using Docker to host MySQL is generally discouraged, highlighting challenges in database scaling due to container‑exclusive storage, difficulties sharing data files, and memory contention among containers, while also outlining possible synchronization solutions and scenarios where containerized MySQL may still be viable.

DockerMySQLcontainerization
0 likes · 4 min read
Why Deploying MySQL in Docker Can Be Problematic: Scaling & Memory Pitfalls
Linux Kernel Journey
Linux Kernel Journey
Nov 3, 2024 · Fundamentals

Linux Kernel Source Walkthrough: The Five Core Subsystems

This article explains the Linux kernel architecture, breaks it into three layers and five key subsystems—process scheduling, memory management, virtual file system, network interface, and inter‑process communication—detailing their responsibilities, inter‑dependencies, and providing concrete code examples and diagrams.

IPCKernelLinux
0 likes · 29 min read
Linux Kernel Source Walkthrough: The Five Core Subsystems
Liangxu Linux
Liangxu Linux
Nov 2, 2024 · Fundamentals

When Does Shallow Copy Break? Mastering Deep vs Shallow Copy in C++

This article explains the difference between shallow and deep copying in C++, shows why the default copy constructor can cause double‑deletion when a class holds pointers, and demonstrates how to implement a proper deep‑copy constructor with clear code examples.

C++Deep CopyShallow Copy
0 likes · 5 min read
When Does Shallow Copy Break? Mastering Deep vs Shallow Copy in C++
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 1, 2024 · Fundamentals

Highlights of the 19th China Linux Kernel Developers Conference (CLK 2024)

The 19th China Linux Kernel Developers Conference in Wuhan on October 26, 2024 attracted over 80,000 online viewers and nearly 400 developers, showcased five technical sub‑forums—from memory and storage I/O to virtualization and scheduling—featured AI‑focused kernel talks, announced a new open‑source innovation institute, and made all materials publicly available on GitHub.

AILinux kernelRISC-V
0 likes · 9 min read
Highlights of the 19th China Linux Kernel Developers Conference (CLK 2024)
Java Architecture Stack
Java Architecture Stack
Oct 30, 2024 · Operations

Why ZGC Is Revolutionizing Java Memory Management for Low‑Latency Apps

This article explains ZGC’s ultra‑low pause times, massive heap support, colored pointers, concurrent compaction, and generational optimizations, then shows how these features benefit real‑time analytics, high‑performance servers, and online transaction systems, and provides step‑by‑step instructions for enabling and tuning ZGC in Java.

Garbage CollectorJavaZGC
0 likes · 9 min read
Why ZGC Is Revolutionizing Java Memory Management for Low‑Latency Apps
DaTaobao Tech
DaTaobao Tech
Oct 28, 2024 · Fundamentals

Garbage Collection Algorithms and Reference Counting in QuickJS

QuickJS manages memory using reference counting for each object combined with a cycle‑collector that periodically scans roots, decrements child references, and frees objects whose counts drop to zero, while also supporting traditional reachability‑based garbage‑collection techniques such as mark‑sweep, copying, and generational collection.

C++JavaScriptQuickJS
0 likes · 9 min read
Garbage Collection Algorithms and Reference Counting in QuickJS
Cognitive Technology Team
Cognitive Technology Team
Oct 23, 2024 · Fundamentals

Overview of Garbage Collection Algorithms and JVM Garbage Collectors

This article provides a comprehensive overview of garbage collection techniques, covering reference counting, reachability analysis, generational management, copy, mark‑sweep, and mark‑compact algorithms, and explains the JVM's serial, parallel, CMS, and G1 collectors along with their operational characteristics and trade‑offs.

Copy AlgorithmG1Generational GC
0 likes · 9 min read
Overview of Garbage Collection Algorithms and JVM Garbage Collectors
Linux Kernel Journey
Linux Kernel Journey
Oct 17, 2024 · Fundamentals

Inside Linux Memory Compaction: A Source‑Code Walkthrough of Memory Management

The article explains how Linux manages memory page watermarks, when the allocator falls back to kswapd, and the exact conditions that trigger direct compaction via __alloc_pages_direct_compact, then walks through the core compaction functions—try_to_compact_pages, compact_zone_order, compact_zone, and the page‑migration helpers—illustrated with flow diagrams and real kernel code.

C++KernelLinux
0 likes · 37 min read
Inside Linux Memory Compaction: A Source‑Code Walkthrough of Memory Management
Code Mala Tang
Code Mala Tang
Sep 30, 2024 · Backend Development

Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks

This article explains how Node.js manages memory, details V8's garbage‑collection mechanisms, shows how to monitor heap usage, demonstrates techniques for increasing allocation limits, and provides practical code samples and third‑party tools for detecting and fixing memory leaks in production environments.

Memory LeaksNode.jsgarbage collection
0 likes · 20 min read
Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks
Java Tech Enthusiast
Java Tech Enthusiast
Sep 29, 2024 · Fundamentals

What Is an Operating System? Core Functions, Architecture & Key Concepts

Operating systems are foundational software that manage hardware resources, provide core services like process and memory management, device and file handling, security, and user interfaces, while embodying key properties such as concurrency, sharing, asynchrony, and virtualization, and exist in various architectures from monolithic to microkernels.

Process Managementconcurrencykernel architecture
0 likes · 14 min read
What Is an Operating System? Core Functions, Architecture & Key Concepts
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 27, 2024 · Backend Development

Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example

This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.

Backend DevelopmentJVMJava
0 likes · 7 min read
Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example
Sohu Tech Products
Sohu Tech Products
Sep 25, 2024 · Mobile Development

Crash Convergence and Resilience Mechanisms in Android Applications

The team maintains an ‘opt’ branch for daily‑collected crash fixes, classifies unrecoverable system, device, SDK and framework errors, and employs a Handler‑based whitelist that catches and swallows known crashes while logging others, complemented by null‑safety, concurrency, database and OOM monitoring to keep Android app crash rates manageable.

AndroidExceptionMobile Development
0 likes · 18 min read
Crash Convergence and Resilience Mechanisms in Android Applications
Linux Kernel Journey
Linux Kernel Journey
Sep 14, 2024 · Fundamentals

Understanding Linux Page Reclaim: LRU, Second‑Chance, and Direct Reclaim Walkthrough

This article explains Linux's page reclamation mechanisms, covering the LRU list algorithm, the second‑chance method with PG_active and PG_referenced flags, and the direct reclaim path triggered by alloc_page, including the role of kswapd, waiting queues, and key kernel functions such as lru_cache_add, mark_page_accessed, try_to_free_pages, and throttle_direct_reclaim.

LRULinuxdirect reclaim
0 likes · 12 min read
Understanding Linux Page Reclaim: LRU, Second‑Chance, and Direct Reclaim Walkthrough
Deepin Linux
Deepin Linux
Sep 10, 2024 · Fundamentals

Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts

This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.

C++CompilationDMA
0 likes · 121 min read
Comprehensive Embedded Software Interview Guide: Memory Management, IPC, DMA, Kernel Allocation, and Core Concepts
Test Development Learning Exchange
Test Development Learning Exchange
Sep 8, 2024 · Fundamentals

Common Built-in Functions in Python: Type Conversion, Math Operations, Control Flow, Sequence Operations, I/O, and More

This article provides a comprehensive overview of Python's built-in functions, covering type conversion, mathematical operations, control flow utilities, sequence manipulation, input/output handling, common utilities, functional programming tools, memory management, and type checking with clear code examples.

Functional ProgrammingPythonmemory management
0 likes · 8 min read
Common Built-in Functions in Python: Type Conversion, Math Operations, Control Flow, Sequence Operations, I/O, and More
Top Architect
Top Architect
Aug 30, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Troubleshooting Steps

The article details how a production Spring Boot system consumed excessive memory due to default JVM heap settings, explains the underlying JVM defaults, demonstrates diagnostic commands, and provides practical recommendations for configuring JVM parameters and monitoring memory usage to prevent similar issues.

Backend DevelopmentJVMJava
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Troubleshooting Steps
Satori Komeiji's Programming Classroom
Satori Komeiji's Programming Classroom
Aug 29, 2024 · Fundamentals

How Python Dictionaries Resize: The Full Expansion Process

The article explains Python's dict resizing mechanism, detailing when the hash table grows (when used entries reach two‑thirds of capacity), how the new size is chosen as the smallest power‑of‑two ≥ ma_used × 3, and the exact steps the interpreter takes to reallocate and rebuild the underlying key and entry arrays.

Pythoncombined-tabledict
0 likes · 12 min read
How Python Dictionaries Resize: The Full Expansion Process
php Courses
php Courses
Aug 29, 2024 · Backend Development

10 Advanced PHP Techniques to Boost Performance and Efficiency

This article introduces ten lesser‑known PHP tricks—including memory management, Composer dependency handling, the built‑in web server, anonymous classes, try‑catch error handling, generators, traits, built‑in functions, PDO, and namespaces—to help developers write more efficient, maintainable, and secure code.

BackendComposerPDO
0 likes · 9 min read
10 Advanced PHP Techniques to Boost Performance and Efficiency
Linux Kernel Journey
Linux Kernel Journey
Aug 25, 2024 · Fundamentals

Analyzing Linux Memory Management Locks and Key Optimization Cases

The article examines the role of various locks in Linux kernel memory management, explains their APIs and sleeping constraints, presents detailed case studies of lock‑related performance patches—including per‑memcg LRU, mmap_lock IO‑fault path, SPF, PVL, fault‑around, unmap, and rmap lockless optimizations—and summarizes common strategies for reducing lock contention and improving scalability.

KernelLinuxPerformance Optimization
0 likes · 28 min read
Analyzing Linux Memory Management Locks and Key Optimization Cases
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 9, 2024 · Fundamentals

Linux Kernel Memory Management Locks and Optimization Case Studies

The article examines Linux kernel 6.9 memory-management locks—PG_locked, lru_lock, mmap_lock, anon_vma rwsem, mapping i_mmap_rwsem, and shrinker_rwsem—explaining their roles and presenting eight community-driven optimizations such as per-memcg lru_lock, per-VMA locks, speculative faults, and lock-less shrinker techniques to improve concurrency and performance.

LRU LockLinux kernelPage Fault
0 likes · 24 min read
Linux Kernel Memory Management Locks and Optimization Case Studies
DataFunSummit
DataFunSummit
Aug 5, 2024 · Big Data

Velox Memory Management and Execution Engine Overview

This article presents a comprehensive overview of Meta's open‑source Velox query execution engine, detailing its architecture, vectorized execution model, memory‑pool hierarchy, arbitrator and allocator designs, spilling techniques, and future development plans for large‑scale data processing.

SpillingVectorized EngineVelox
0 likes · 24 min read
Velox Memory Management and Execution Engine Overview
Refining Core Development Skills
Refining Core Development Skills
Aug 5, 2024 · Fundamentals

Deep Dive into Linux Processes and Memory: A Comprehensive Guide

This article introduces a new book 'Deep Understanding of Linux Processes and Memory' that systematically explains CPU, memory, and process scheduling principles, covering hardware fundamentals, virtual memory, Golang coroutines, container resource management, and performance optimization techniques.

CPU architectureLinuxPerformance Optimization
0 likes · 5 min read
Deep Dive into Linux Processes and Memory: A Comprehensive Guide
JD Retail Technology
JD Retail Technology
Aug 2, 2024 · Operations

JVM Memory Model, Garbage Collection, and Optimization Guide

This article explains the JVM memory architecture, object lifecycle, young and old generation garbage‑collection mechanisms, tuning goals such as low latency, high throughput and large heap, and provides practical advice on monitoring, common memory‑related problems, and choosing appropriate collectors for different application scenarios.

JVMJavagarbage collection
0 likes · 17 min read
JVM Memory Model, Garbage Collection, and Optimization Guide
Liangxu Linux
Liangxu Linux
Jul 27, 2024 · Fundamentals

Does malloc Allocate Memory? Exploring Virtual Memory, brk, and Page Faults

This article explains why calling malloc in C only reserves virtual address space, how the kernel maps it to physical memory on demand, and the roles of the brk pointer, memory layout, and page‑fault handling, illustrated with a 1 GB allocation example and detailed diagrams.

C ProgrammingPage FaultVirtual Memory
0 likes · 7 min read
Does malloc Allocate Memory? Exploring Virtual Memory, brk, and Page Faults
Linux Code Review Hub
Linux Code Review Hub
Jul 25, 2024 · Fundamentals

How openEuler 24.03 LTS’s Dynamic Composite Page Boosts Memory Performance

The openEuler 24.03 LTS release introduces a dynamic composite page (large folio) that retains 4 KB base‑page compatibility while enabling 64 KB page performance gains, reducing TLB misses and memory overhead, and delivering double‑digit benchmark improvements for big‑data, Kafka, MySQL, I/O and memory‑allocation workloads.

Linux kernelPerformancearm64
0 likes · 11 min read
How openEuler 24.03 LTS’s Dynamic Composite Page Boosts Memory Performance
Radish, Keep Going!
Radish, Keep Going!
Jul 25, 2024 · Backend Development

How to Slash Go GC Overhead on Large Heaps: Techniques and Code

This article examines why Go's garbage collector can become a CPU bottleneck with large heaps, demonstrates the performance impact with benchmark programs, and presents practical strategies—such as using pointer‑free allocations, mmap‑backed memory, and string interning—to dramatically reduce GC pause times.

GoLarge heapPerformance
0 likes · 13 min read
How to Slash Go GC Overhead on Large Heaps: Techniques and Code
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Jul 20, 2024 · Artificial Intelligence

Beyond RAG: How Mem0 Gives Large Language Models Super Memory for Personalized AI Apps

Mem0 is an open‑source memory‑management middleware for large language models that provides dynamic, context‑aware, and adaptive memory, outperforming traditional Retrieval‑Augmented Generation (RAG) and enabling personalized AI assistants, travel planners, and support agents with concrete Python APIs and examples.

AI AgentsLLMMem0
0 likes · 9 min read
Beyond RAG: How Mem0 Gives Large Language Models Super Memory for Personalized AI Apps
Deepin Linux
Deepin Linux
Jul 17, 2024 · Fundamentals

Understanding Page Fault Handling and Virtual Memory Management in uCore OS

This article explains the principles of virtual memory, the data structures and functions used in uCore to manage page faults, and how the operating system handles demand paging, page swapping, and invalid accesses through detailed code examples and workflow descriptions.

KernelPage FaultVirtual Memory
0 likes · 23 min read
Understanding Page Fault Handling and Virtual Memory Management in uCore OS
JavaEdge
JavaEdge
Jul 8, 2024 · Backend Development

Master Java Metaspace: Tuning Metadata GC Threshold and JVM Flags

This article explains Java Metaspace and metadata GC thresholds, compares PermGen with Metaspace, and provides detailed JVM flag configurations—including size settings and compressed pointer options—to help developers optimize memory usage and garbage‑collection performance.

JavaMetaspacegarbage collection
0 likes · 8 min read
Master Java Metaspace: Tuning Metadata GC Threshold and JVM Flags
Java Tech Enthusiast
Java Tech Enthusiast
Jun 29, 2024 · Fundamentals

Understanding Memory Allocation in C

The article explains C’s memory allocation, detailing how functions like malloc obtain heap space, the role of system calls such as brk, the distinction between stack and heap, address layout, fragmentation challenges, and practical implications for efficient dynamic memory management.

C ProgrammingHeapmalloc
0 likes · 5 min read
Understanding Memory Allocation in C
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 26, 2024 · Fundamentals

Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors

This article provides a comprehensive overview of Java's G1 and ZGC garbage collectors, explaining their memory layout, internal structures such as regions, card tables, and RSet, detailing Young and Mixed GC processes, three‑color marking, SATB, incremental updates, and the low‑pause design of ZGC.

G1JVMZGC
0 likes · 30 min read
Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors
php Courses
php Courses
Jun 14, 2024 · Backend Development

Understanding PHP Generators: Efficient Data Iteration and Memory Optimization

This article explains the concept, operation, and advantages of PHP generators, demonstrating how they provide memory‑efficient, lazy‑evaluated iteration for large data sets and streams, and includes practical code examples and best‑practice tips for backend developers.

Backend DevelopmentPHPgenerators
0 likes · 9 min read
Understanding PHP Generators: Efficient Data Iteration and Memory Optimization
DataFunSummit
DataFunSummit
Jun 10, 2024 · Artificial Intelligence

Xiaomi Agent Technology: Architecture, Prompt Management, and Evaluation

This article presents Xiaomi's work on LLM‑based Agent technology, covering its perception‑thinking‑action pipeline, technical framework, prompt management, executor and API platform, workflow, optimization strategies, evaluation metrics, and future directions for AI assistants.

AI assistantAgentLLM
0 likes · 17 min read
Xiaomi Agent Technology: Architecture, Prompt Management, and Evaluation
Python Programming Learning Circle
Python Programming Learning Circle
May 14, 2024 · Fundamentals

Python Frequently Asked Questions: Indentation, Float Precision, Immutability, and Core Language Design

This article answers twenty‑seven common Python questions covering why indentation is used for block grouping, the reasons behind surprising floating‑point results, the immutability of strings, the explicit use of self, the absence of assignment in expressions, and many other design choices that shape Python’s core behavior.

FAQLanguage DesignPython
0 likes · 28 min read
Python Frequently Asked Questions: Indentation, Float Precision, Immutability, and Core Language Design
Huolala Tech
Huolala Tech
May 14, 2024 · Mobile Development

How We Reduced Android OOM Crashes by 99%: Mobile Memory Optimization Secrets

Over the past six months we tackled severe Android memory issues—high OOM crash rates, memory leaks, and large object usage—by implementing systematic profiling, targeted page optimizations, Java and native leak detection tools, and robust monitoring mechanisms, ultimately reducing OOM crashes from 0.8‰ to 0.01‰ and improving app stability.

AndroidOOMleak detection
0 likes · 26 min read
How We Reduced Android OOM Crashes by 99%: Mobile Memory Optimization Secrets
Liangxu Linux
Liangxu Linux
May 9, 2024 · Fundamentals

How mem_malloc Eliminates Fragmentation in MCU RAM – A Complete Guide

This article introduces the open‑source mem_malloc module for microcontrollers, explains its fragmentation‑free allocation algorithm, shows how to integrate and compile it on an IOT development board, and provides detailed test code and results illustrating efficient RAM usage.

C Programmingfragmentationmalloc alternative
0 likes · 8 min read
How mem_malloc Eliminates Fragmentation in MCU RAM – A Complete Guide
FunTester
FunTester
May 8, 2024 · Fundamentals

How Garbage Collection Impacts Performance and How to Optimize It

This article explains the fundamentals of garbage collection, compares manual and automatic memory management, outlines common GC algorithms, and provides practical guidance on performance analysis, tool selection, and optimization techniques to improve application responsiveness and resource utilization.

GC algorithmsPerformance OptimizationResource Utilization
0 likes · 22 min read
How Garbage Collection Impacts Performance and How to Optimize It
MaGe Linux Operations
MaGe Linux Operations
May 4, 2024 · Databases

Unlocking Redis Memory: How Its Internal Model Impacts Performance

This article explains Redis's memory model—including memory statistics, allocation, internal data structures, object types, and encoding—while showing practical examples for estimating usage, optimizing consumption, and troubleshooting fragmentation in high‑concurrency environments.

Data StructuresOptimizationRedis
0 likes · 34 min read
Unlocking Redis Memory: How Its Internal Model Impacts Performance
Ops Development & AI Practice
Ops Development & AI Practice
May 3, 2024 · Backend Development

Boost Go Performance with the Experimental arena Package: Design, Usage, and Benchmarks

This article explores Go's experimental arena library, detailing its design principles, core features such as fast allocation and memory reuse, suitable use cases like object pools and game development, provides a practical code example, and discusses performance benefits and limitations for high‑concurrency applications.

ArenaGoPerformance
0 likes · 5 min read
Boost Go Performance with the Experimental arena Package: Design, Usage, and Benchmarks
Open Source Linux
Open Source Linux
Apr 29, 2024 · Fundamentals

Unlocking DPDK Memory Management: How Hugepages Boost Performance

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
Unlocking DPDK Memory Management: How Hugepages Boost Performance
Ops Development & AI Practice
Ops Development & AI Practice
Apr 15, 2024 · Backend Development

Boost Go Performance with sync.Pool: Practical Guide and UML Modeling

This article explains how Go's sync.Pool can reduce memory allocations and garbage‑collection overhead in high‑performance applications, provides step‑by‑step usage examples, demonstrates a byte‑buffer pool, shows performance benefits, and visualizes the mechanism with UML class and sequence diagrams.

GoPerformance Optimizationmemory management
0 likes · 7 min read
Boost Go Performance with sync.Pool: Practical Guide and UML Modeling
High Availability Architecture
High Availability Architecture
Apr 11, 2024 · Backend Development

Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components

This article provides a comprehensive overview of Netty's core layers, protocol support, transport services, logical architecture, various I/O models, packet framing techniques, custom protocol design, write‑and‑flush behavior, off‑heap memory management, and high‑performance data structures such as FastThreadLocal and HashedTimerWheel.

High PerformanceJavaNetty
0 likes · 26 min read
Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components
Yum! Tech Team
Yum! Tech Team
Apr 9, 2024 · Backend Development

Optimizing High‑Concurrency Menu Services with Go sync.Pool Object Pool

This article explains the principles of object pools, details the internal implementation of Go's sync.Pool, and demonstrates through benchmarks how using an object pool can dramatically reduce memory allocation and latency for high‑traffic menu services in a restaurant ordering application.

GoPerformancebenchmark
0 likes · 13 min read
Optimizing High‑Concurrency Menu Services with Go sync.Pool Object Pool
Sanyou's Java Diary
Sanyou's Java Diary
Apr 8, 2024 · Fundamentals

What Are the 7 Core Garbage Collection Algorithms and When to Use Them?

This article explains why garbage collection (GC) is essential, defines key GC terminology, compares performance metrics, and provides a detailed overview of seven common GC algorithms—including mark‑sweep, reference counting, copying, mark‑compact, conservative, generational, and incremental GC—along with their advantages, disadvantages, and typical improvements.

GC algorithmsmemory managementsoftware fundamentals
0 likes · 47 min read
What Are the 7 Core Garbage Collection Algorithms and When to Use Them?
Tencent Cloud Developer
Tencent Cloud Developer
Apr 3, 2024 · Fundamentals

Seven Common GC Algorithms: Principles, Comparisons, and Optimizations

The article surveys seven common garbage‑collection algorithms—Mark‑Sweep, Reference Counting, Copying, Mark‑Compact, Conservative, Generational, and Incremental/Tri‑color—explaining their principles, strengths, weaknesses, evaluation criteria such as throughput and pause time, and practical optimizations, emphasizing that the best choice depends on specific application needs.

GC algorithmsGenerational GCMark‑Sweep
0 likes · 42 min read
Seven Common GC Algorithms: Principles, Comparisons, and Optimizations
Liangxu Linux
Liangxu Linux
Mar 30, 2024 · Fundamentals

Essential Linux Kernel Q&A: Architecture, Memory Management, and Process Basics

This comprehensive Q&A explains Linux system composition, kernel placement, core subsystems, address translation, paging structures, process concepts, scheduling algorithms, interrupt handling, system calls, synchronization, deadlock avoidance, and the virtual file system, providing a solid foundation for operating‑system fundamentals.

File SystemKernelLinux
0 likes · 19 min read
Essential Linux Kernel Q&A: Architecture, Memory Management, and Process Basics
Java Captain
Java Captain
Mar 25, 2024 · Fundamentals

Understanding the Underlying Implementation of Java String Immutability

This article explains why Java's String class is immutable, detailing the benefits such as thread safety, cached hash codes, and string pooling, and describes the internal mechanisms—including a private final char array, creation of new objects on concatenation, and the intern method—that enforce this immutability.

ImmutabilityJavaPerformance
0 likes · 5 min read
Understanding the Underlying Implementation of Java String Immutability
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 21, 2024 · Fundamentals

Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning

This article provides a comprehensive guide to JVM internals, covering runtime data areas, heap segmentation, object allocation, reference types, class loading phases, garbage collection algorithms, collector choices across JDK versions, performance tuning commands, and practical troubleshooting techniques for production Java applications.

JVMgarbage collectionmemory management
0 likes · 38 min read
Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning
vivo Internet Technology
vivo Internet Technology
Mar 19, 2024 · Backend Development

Java 8 Memory Management and Garbage Collection Analysis

The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.

GC algorithmsHeap AnalysisJVM
0 likes · 29 min read
Java 8 Memory Management and Garbage Collection Analysis
Su San Talks Tech
Su San Talks Tech
Mar 18, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

This article explores six typical OutOfMemoryError situations in Java—including heap, stack, direct memory, GC overhead, and metaspace issues—explains their root causes, provides reproducible code examples, and offers practical tips to avoid or mitigate each problem.

JVMJavaOutOfMemoryError
0 likes · 8 min read
6 Common Java OOM Scenarios and How to Prevent Them
Architect
Architect
Mar 15, 2024 · Databases

How to Diagnose and Optimize Redis Memory Usage: Real‑World Cases

This article dissects Redis's memory architecture, explains each memory component, walks through object encoding rules, buffer handling, fragmentation, and child‑process memory, then presents two production incidents with step‑by‑step analysis and concrete optimization actions to prevent future memory alarms.

Performance OptimizationRediscase study
0 likes · 27 min read
How to Diagnose and Optimize Redis Memory Usage: Real‑World Cases
IT Services Circle
IT Services Circle
Mar 8, 2024 · Fundamentals

Interview Q&A: C Language Basics, Algorithms, Memory Management, and System Programming

This article provides concise explanations and code examples for common interview questions covering C global variable defaults, binary representations, finding top‑k elements, double‑pointer and binary search techniques, OOP concepts in C, differences between C++ class and struct, UDP packet limits, TCP read() return values, memory leaks in infinite loops, and resource cleanup on process exit.

C++Operating SystemsProgramming Interview
0 likes · 18 min read
Interview Q&A: C Language Basics, Algorithms, Memory Management, and System Programming
MaGe Linux Operations
MaGe Linux Operations
Feb 29, 2024 · Backend Development

Mastering JVM Heap Settings in Docker: Best Parameters Across JDK Versions

This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.

DockerJVMJava
0 likes · 11 min read
Mastering JVM Heap Settings in Docker: Best Parameters Across JDK Versions
php Courses
php Courses
Feb 26, 2024 · Backend Development

PHP Memory Management Functions: memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and memory_limit

This article explains PHP's key memory management functions—including memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and the memory_limit setting—providing usage syntax, examples, and guidance on optimizing script performance and preventing memory‑related issues.

Backend DevelopmentPHPPerformance Optimization
0 likes · 4 min read
PHP Memory Management Functions: memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and memory_limit
DeWu Technology
DeWu Technology
Feb 5, 2024 · Fundamentals

Understanding Dart VM Garbage Collection and Memory Management

The article explains Dart VM’s generational garbage collection, detailing object allocation, the young‑generation Scavenge copying collector, old‑generation Mark‑Sweep and Mark‑Compact algorithms, safepoints, write‑barrier mechanics, debugging a write‑protect crash, and the importance of logging for memory‑management analysis.

DartGC algorithmsVM
0 likes · 33 min read
Understanding Dart VM Garbage Collection and Memory Management
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Feb 2, 2024 · Fundamentals

Linux Shared Memory (shmem) Deep Dive: Architecture, Implementation, and Practice

Linux’s shmem subsystem provides hybrid anonymous/file‑backed pages that enable diverse shared‑memory scenarios—parent‑child communication, IPC, tmpfs, Android ashmem, and memfd—by using APIs such as shmem_file_setup, handling page faults through cache and swap mechanisms, and employing a specialized reclamation process to manage memory efficiently.

Linux kernelVirtual Memorymemfd
0 likes · 10 min read
Linux Shared Memory (shmem) Deep Dive: Architecture, Implementation, and Practice
DataFunSummit
DataFunSummit
Jan 22, 2024 · Artificial Intelligence

Improving Efficiency of Large‑Scale AI Model Training, Fine‑tuning, and Deployment with Colossal‑AI

This article introduces Colossal‑AI, an open‑source platform that tackles the challenges of training, fine‑tuning, and deploying massive AI models by leveraging efficient memory management, N‑dimensional parallelism, and high‑performance inference to dramatically reduce cost and improve scalability across thousands of GPUs.

AI InfrastructureColossal-AIDistributed Training
0 likes · 21 min read
Improving Efficiency of Large‑Scale AI Model Training, Fine‑tuning, and Deployment with Colossal‑AI
Java Tech Enthusiast
Java Tech Enthusiast
Jan 4, 2024 · Databases

Redis Simple Dynamic String (SDS) Implementation Overview

Redis implements its own Simple Dynamic String (SDS) instead of plain C strings because SDS stores length for O(1) queries, pre‑allocates extra space and lazily reuses freed bytes, prevents buffer overflows, handles binary data, and uniformly backs all string keys, values and container elements.

C languageRedisSDS
0 likes · 8 min read
Redis Simple Dynamic String (SDS) Implementation Overview
Code Ape Tech Column
Code Ape Tech Column
Dec 31, 2023 · Backend Development

How to Set JVM Parameters for a Platform Handling 1 Million Daily Logins on an 8 GB Server

This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.

BackendGC TuningJVM
0 likes · 25 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Logins on an 8 GB Server
Bilibili Tech
Bilibili Tech
Dec 29, 2023 · Artificial Intelligence

Performance Optimization of Bilibili's Online Inference Service for the Effect Advertising Engine

To cope with soaring traffic on Bilibili’s effect‑advertising engine, the team systematically measured latency, eliminated redundant Redis calls, switched JSON to Protobuf, applied branch‑prediction hints, loop‑unrolling and AVX256 SIMD, introduced object‑pooling and an inverted‑index request format, cutting CPU usage by 21 % and boosting peak throughput 13 %.

C++CPUmemory management
0 likes · 21 min read
Performance Optimization of Bilibili's Online Inference Service for the Effect Advertising Engine
Liangxu Linux
Liangxu Linux
Dec 25, 2023 · Fundamentals

7 Proven Techniques to Boost Embedded System Reliability

This article presents seven practical, long‑term strategies—such as ROM filling, CRC checks, RAM validation, stack monitoring, MPU usage, robust watchdog design, and avoiding volatile memory allocation—to help embedded engineers build more reliable firmware and catch abnormal behavior early.

MPUembedded systemsfirmware
0 likes · 9 min read
7 Proven Techniques to Boost Embedded System Reliability
php Courses
php Courses
Dec 20, 2023 · Backend Development

File Caching and Memory Management in PHP Development

This article explains how to implement file caching and effective memory management in PHP, providing step‑by‑step instructions and code examples for creating cache directories, generating cache filenames, checking and clearing caches, and releasing variables and objects to prevent memory leaks.

BackendCode ExamplesPerformance
0 likes · 5 min read
File Caching and Memory Management in PHP Development
MaGe Linux Operations
MaGe Linux Operations
Dec 17, 2023 · Fundamentals

How Linux Kernel Manages Dynamic Memory and Process Address Space

This article explains how the Linux kernel allocates dynamic memory, distinguishes kernel and user‑space allocation strategies, describes the mm_struct layout of a process address space, and shows how pages and page tables translate virtual addresses to physical memory.

KernelLinuxVirtual Memory
0 likes · 10 min read
How Linux Kernel Manages Dynamic Memory and Process Address Space
Test Development Learning Exchange
Test Development Learning Exchange
Dec 12, 2023 · Fundamentals

Python Memory Management and Optimization Techniques

Python automatically manages memory through garbage collection, and this article explains how the garbage collector works and presents ten practical techniques—including manual gc calls, generators, sys.getsizeof, slice copying, del statements, sys.intern, NumPy, pandas, reference counting, and __slots__—to reduce memory usage and improve performance.

OptimizationPerformancePython
0 likes · 5 min read
Python Memory Management and Optimization Techniques
DevOps Cloud Academy
DevOps Cloud Academy
Dec 11, 2023 · Operations

Managing Java Process Memory in Kubernetes Pods to Prevent OOMKilled

This article explains why Java processes in Kubernetes pods often encounter OOMKilled despite correct JVM heap settings, analyzes the discrepancy between JVM‑reported memory and container metrics, and provides practical steps such as adjusting MaxRAMPercentage and pod memory limits to stabilize memory usage.

JVMJavaKubernetes
0 likes · 9 min read
Managing Java Process Memory in Kubernetes Pods to Prevent OOMKilled
Deepin Linux
Deepin Linux
Dec 1, 2023 · Fundamentals

65 Essential Embedded System Interview Questions and Answers

This comprehensive guide presents 65 common embedded‑system interview questions covering topics such as memory layout, stack vs. heap, static and volatile keywords, pointers and references, malloc usage, C vs. C++ differences, compilation stages, process and thread concepts, IPC mechanisms, and networking fundamentals, providing concise explanations and code examples for each.

C Programmingembedded systemsmemory management
0 likes · 64 min read
65 Essential Embedded System Interview Questions and Answers
Architect
Architect
Nov 19, 2023 · Artificial Intelligence

Why AutoGPT Abandoned Vector Databases – A Deep Dive into Simpler Memory Strategies

The article examines AutoGPT's shift away from vector databases, detailing the original vision of using embeddings for long‑term memory, the performance calculations that exposed unnecessary complexity, the adoption of JSON‑based storage, and the emerging trend of specialized multi‑agent architectures.

AI AgentsArtificial IntelligenceAutoGPT
0 likes · 9 min read
Why AutoGPT Abandoned Vector Databases – A Deep Dive into Simpler Memory Strategies
Open Source Linux
Open Source Linux
Nov 17, 2023 · Databases

How Large Linux Pages Boost Database Performance on Kubernetes

This article explains how using larger Linux page sizes—especially 2 MB hugepages—dramatically improves database throughput on Kubernetes nodes by reducing TLB cache misses, and provides practical guidance on configuring hugepages, disabling transparent hugepages, and sizing resources for optimal performance.

HugePagesKubernetesLinux
0 likes · 13 min read
How Large Linux Pages Boost Database Performance on Kubernetes