BestHub
Sign in
Tagged articles
950 articles
Page 3 of 10
Refining Core Development Skills
Refining Core Development Skills
Mar 25, 2025 · Fundamentals

Understanding Linux Kernel Physical Memory Management and the memblock Allocator

Linux does not expose all physical memory to users; this article explains why the kernel reserves memory, detailing the early memblock allocator, crash kernel reservations, page structure overhead, and the handoff to the buddy system, illustrating how these mechanisms consume several hundred megabytes of RAM.

Crash KernelMemory ManagementPage Structures
0 likes · 15 min read
Understanding Linux Kernel Physical Memory Management and the memblock Allocator
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.

Garbage CollectionJavaScriptMark-and-Sweep
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.

Memory ManagementOperating SystemPage Fault
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.

Garbage CollectionJavaScriptMark‑Sweep
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.

Database TuningJavaMemory Management
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 StructuresMemory ManagementNetwork Latency
0 likes · 8 min read
Common Redis Performance Issues and How to Make Your Cache Fly
IT Services Circle
IT Services Circle
Mar 21, 2025 · Fundamentals

Understanding Linux PageCache: How the OS Accelerates File Reads and Writes

PageCache, a kernel-managed memory cache that stores disk data in RAM, dramatically speeds up file operations by turning repeated reads and writes into pure memory accesses, and its dynamic sizing, read‑ahead, and LRU eviction are demonstrated through Linux experiments with large files.

Memory ManagementPageCachefile I/O
0 likes · 9 min read
Understanding Linux PageCache: How the OS Accelerates File Reads and Writes
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.

Garbage CollectionJavaScriptMemory Management
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.

JVMJavaMemory Management
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.

FastThreadLocalJavaMemory Management
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.

Garbage CollectionJVMJava
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.

Memory ManagementTier-2 Optimizerinterpreter
0 likes · 5 min read
Planned Enhancements and Performance Goals for Python 3.13
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 12, 2025 · Backend Development

What Are GC Roots? Understanding JVM Garbage Collection Basics

The article explains the concept of GC Roots in the JVM, detailing the four main types—stack variables, static fields, constant pool references, and JNI references—along with code examples, and describes how these roots determine object liveness during garbage collection.

GC RootsGarbage CollectionJVM
0 likes · 7 min read
What Are GC Roots? Understanding JVM Garbage Collection Basics
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 kernelMemory ManagementTHP
0 likes · 5 min read
How One Linux Kernel Patch Boosted Memory Allocation Speed by 40×
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 11, 2025 · Backend Development

Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms

This article explains the main Java garbage collection algorithms—Mark‑Sweep, Mark‑Copying, Mark‑Compact, and Generational Collection—detailing their principles, advantages, and drawbacks, helping developers choose the appropriate strategy for efficient memory management in backend applications.

AlgorithmsGarbage CollectionJVM
0 likes · 5 min read
Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms
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 kernelMemory ManagementPerformance Optimization
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.

CMemory ManagementRuntime Library
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.

Memory ManagementOperating SystemRAM
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 ProfilingMemory ManagementPerformance Optimization
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 ProfilingMemory ManagementPerformance Optimization
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.

AddCleanupGarbage CollectionGo
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.

Boot ProcessE820Linux kernel
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.

CacheKey DesignMemory Management
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.

ExpirationLazy DeletionMemory Management
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.

Garbage CollectionJVMJava
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.

Escape AnalysisGoMemory Management
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.

Big DataMemory ManagementPython
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.

BackendMemory Managementfile-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.

I/O ThreadsMemory ManagementPython
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++Memory ManagementRule 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.

Garbage CollectionGoMemory Management
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 kernelMemory ManagementNUMA
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.

Garbage CollectionMemory Managementcode-examples
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++Memory ManagementRAII
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.

Database OptimizationLatencyMemory Management
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.

Garbage CollectionJVMJava
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.

Memory ManagementRedis Clustercaching
0 likes · 7 min read
Understanding Redis Maxmemory and Eviction Policies
Code Ape Tech Column
Code Ape Tech Column
Dec 10, 2024 · Backend Development

Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter

This article demonstrates how to experimentally determine the heap memory allocated by individual HTTP and RPC requests in a SpringBoot application using JMeter load testing, GC logging, and code analysis, providing insights into memory consumption, GC frequency, and optimization strategies for backend performance.

JMeterJVMMemory Management
0 likes · 9 min read
Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter
Linux Kernel Journey
Linux Kernel Journey
Nov 27, 2024 · Operations

How to Resolve Linux Out‑of‑Memory Issues with a Swap Partition

When a small 2 CPU / 2 GB Alibaba Cloud instance runs Java, Nginx, MySQL, and Redis, memory quickly exhausts; this guide shows how to create and configure a swap file, set appropriate permissions, enable it at boot, and tune the swappiness parameter to mitigate out‑of‑memory failures.

Memory ManagementSwapdd
0 likes · 4 min read
How to Resolve Linux Out‑of‑Memory Issues with a Swap Partition
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.

Memory ManagementOOM killerSystem Administration
0 likes · 5 min read
How Linux’s OOM Killer Works and How to Protect Critical Processes
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.

Kernel ArchitectureMemory ManagementOS fundamentals
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.

Garbage CollectionJVMJava
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
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.

Garbage CollectionGoMemory Management
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.

BackendGarbage CollectionJVM
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.

DockerMemory Managementcontainerization
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.

IPCMemory Managementkernel
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++Copy ConstructorMemory Management
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 kernelMemory Management
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 CollectorJavaLow latency
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.

CGarbage CollectionJavaScript
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 AlgorithmG1Garbage Collection
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.

CMemory Managementcompaction
0 likes · 37 min read
Inside Linux Memory Compaction: A Source‑Code Walkthrough of Memory Management
Liangxu Linux
Liangxu Linux
Oct 7, 2024 · Fundamentals

What Exactly Do “buffers” and “cached” Mean in the Linux free Command?

The article explains how the Linux free utility calculates the “buffers” and “cached” fields, detailing their definitions, the kernel source functions that produce them, the role of block‑device page cache versus ordinary file cache, and how to verify the numbers with simple commands.

BuffersMemory Managementcached
0 likes · 10 min read
What Exactly Do “buffers” and “cached” Mean in the Linux free Command?
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.

Garbage CollectionMemory ManagementNode.js
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.

Kernel ArchitectureMemory ManagementOperating System
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 DevelopmentGarbage CollectionJVM
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.

AndroidExceptionHandler
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.

LRUMemory Managementdirect 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.

Memory ManagementPythonfunctional programming
0 likes · 8 min read
Common Built-in Functions in Python: Type Conversion, Math Operations, Control Flow, Sequence Operations, I/O, and More
MaGe Linux Operations
MaGe Linux Operations
Sep 2, 2024 · Operations

How to Configure Swap Space on Linux: Step‑by‑Step Guide

This article explains what swap space is, why it matters for system stability and performance, and provides detailed Linux commands and procedures for creating, configuring, activating, and monitoring swap files or partitions.

Memory ManagementPerformance OptimizationSystem Administration
0 likes · 5 min read
How to Configure Swap Space on Linux: Step‑by‑Step Guide
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.

Memory ManagementPythoncombined-table
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.

BackendComposerGenerators
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.

Memory ManagementPerformance Optimizationkernel
0 likes · 28 min read
Analyzing Linux Memory Management Locks and Key Optimization Cases
Open Source Linux
Open Source Linux
Aug 15, 2024 · Fundamentals

What Do “buffers” and “cached” Really Mean in Linux’s free Command?

This article demystifies the Linux free command’s “buffers” and “cached” fields by tracing their origins through /proc/meminfo, kernel source functions such as meminfo_proc_show, nr_blockdev_pages, and page‑cache mechanisms, and demonstrates the differences with practical experiments.

BuffersMemory Managementcached
0 likes · 12 min read
What Do “buffers” and “cached” Really Mean in Linux’s free Command?
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 kernelMemory Management
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.

Big DataMemory ManagementQuery Execution
0 likes · 24 min read
Velox Memory Management and Execution Engine Overview
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.

Garbage CollectionJVMJava
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 programmingMemory ManagementPage Fault
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.

ARM64BenchmarkLinux kernel
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.

Garbage CollectionGoLarge heap
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