Skip to content
Tagged articles

memory optimization

253 articles · Page 1 of 3
Code Farming
Code Farming
Nov 15, 2026 · Artificial Intelligence

Five Cuts to Attention Optimization: MHA, MQA, GQA, FlashAttention Layer-by-Layer

This article dissects MHA, MQA, GQA, and FlashAttention across five analytical layers, revealing how structural optimizations (MQA/GQA) reduce KV Cache memory by sharing keys/values, while FlashAttention tackles memory bandwidth via tiled computation and online softmax, and why modern LLMs combine GQA with FlashAttention for 2-4x speedups without accuracy loss.

Attention MechanismFlashAttentionGQA
0 likes · 11 min read
Five Cuts to Attention Optimization: MHA, MQA, GQA, FlashAttention Layer-by-Layer
21CTO
21CTO
Nov 7, 2026 · Industry Insights

Discord Replaces Electron with Rust + GPUI, Cutting Memory to 290MB

Discord is rewriting its desktop client from Electron to Rust with the GPUI framework and shifting mobile away from React Native to native UI while sharing a Rust business-logic core, achieving 290 MB memory usage in tests versus multi-gigabyte Electron footprints.

DiscordElectronGPUI
0 likes · 6 min read
Discord Replaces Electron with Rust + GPUI, Cutting Memory to 290MB
MaGe Linux Operations
MaGe Linux Operations
Nov 7, 2026 · Artificial Intelligence

LoRA/QLoRA Fine-Tuning on a Single GPU: Practical Guide for 7B/13B Models

This comprehensive guide walks through efficient LoRA/QLoRA fine-tuning of 7B and 13B language models on a single 24GB GPU, covering memory budgeting, environment setup, data preparation, training configuration, evaluation strategies, model merging, deployment verification, and production best practices with concrete code examples and benchmarks.

Fine-tuningGPUHuggingFace
0 likes · 78 min read
LoRA/QLoRA Fine-Tuning on a Single GPU: Practical Guide for 7B/13B Models
Tech Freedom Circle
Tech Freedom Circle
Nov 4, 2026 · Artificial Intelligence

Production-Grade KV Cache Optimization: Memory Budgeting, PagedAttention, Quantization & Offloading

This article provides a comprehensive guide to production-grade KV Cache optimization for LLM inference, covering memory budget formulas, PagedAttention paging mechanism, prefix caching, FP8/NVFP4 quantization, hierarchical offloading, and eviction strategies with concrete deployment priorities.

KV CacheLLM inferenceOffloading
0 likes · 32 min read
Production-Grade KV Cache Optimization: Memory Budgeting, PagedAttention, Quantization & Offloading
Lao Guo's Learning Space
Lao Guo's Learning Space
Oct 26, 2026 · Artificial Intelligence

M5 Max 128GB: Running 125B Qwen3.8-Flash-Next at 60 tok/s with MLX & MTP

This guide details running Qwen3.8-Flash-Next 125B MoE on Apple M5 Max 128GB, covering hardware bandwidth limits, memory constraints, framework selection (MLX vs llama.cpp), command-level optimizations including MTP speculative decoding and GPU memory limit tuning, and realistic performance expectations of 45–60 tok/s with MTP enabled.

Apple SiliconLLM inferenceM5 Max
0 likes · 9 min read
M5 Max 128GB: Running 125B Qwen3.8-Flash-Next at 60 tok/s with MLX & MTP
Deepin Linux
Deepin Linux
Oct 22, 2026 · Backend Development

Memory Optimization Deep Dive: Allocate Less, Allocate Faster, Use Efficiently

This article presents a systematic approach to memory optimization across three dimensions—reducing allocation frequency, accelerating allocation speed, and improving memory usage efficiency—with practical C++ techniques including stack allocation, object pools, size-class allocators, huge pages, data structure packing, and false sharing prevention.

C++Performance Tuningdata structure alignment
0 likes · 23 min read
Memory Optimization Deep Dive: Allocate Less, Allocate Faster, Use Efficiently
Tencent Advertising Technology
Tencent Advertising Technology
Oct 21, 2026 · Databases

AdaBool: Adaptive Sparse Boolean Matrix Processing on GPU (SIGMOD 2027)

Tencent and HKU propose AdaBool, an adaptive GPU framework for sparse boolean matrix multiplication that dynamically selects offset arrays or bitmaps per block, achieving up to 264x throughput over cuSPARSE/cuBool and 2-7.9x memory reduction, deployed for million-ad real-time filtering.

Adaptive Data RepresentationGPU accelerationReal-time Ad Filtering
0 likes · 25 min read
AdaBool: Adaptive Sparse Boolean Matrix Processing on GPU (SIGMOD 2027)
liandk
liandk
Oct 13, 2026 · Artificial Intelligence

Mac Local LLM Deployment Pitfalls: Ollama Memory Optimization & Model Selection Guide

This article details real-world pitfalls when deploying large language models locally on Mac using Ollama, covering memory overflow causes, key parameter tuning (num_ctx, num_parallel, num_gpu), quantization level selection, model recommendations for coding vs chat, and monitoring strategies to avoid swap-induced performance degradation.

LLM DeploymentMacOllama
0 likes · 14 min read
Mac Local LLM Deployment Pitfalls: Ollama Memory Optimization & Model Selection Guide
LuTiao Programming
LuTiao Programming
Sep 30, 2026 · Backend Development

Spring Boot Excel Export OOM: Replacing XSSFWorkbook with SXSSFWorkbook and Batch Processing

The author describes how exporting 500k order records caused a 2GB heap OOM, then fixed it by replacing XSSFWorkbook with streaming SXSSFWorkbook, switching from full entity loading to cursor-based batch queries with DTOs, reusing cell styles, and finally decoupling large exports from HTTP requests via async task processing.

Apache POICursor PaginationExcel Export
0 likes · 14 min read
Spring Boot Excel Export OOM: Replacing XSSFWorkbook with SXSSFWorkbook and Batch Processing
Machine Heart
Machine Heart
Sep 23, 2026 · Backend Development

DeepSeek DSec: Scaling Sandbox Infrastructure to 380K Concurrent Agents

DeepSeek's new paper introduces DSec, a production sandbox infrastructure that manages 300 million daily sandbox instances with 380,000 concurrent at peak, using on-demand image loading, composable layers, memory sharing, and CPU QoS to support large-scale agentic reinforcement learning training.

CPU SchedulingDSecDeepSeek
0 likes · 19 min read
DeepSeek DSec: Scaling Sandbox Infrastructure to 380K Concurrent Agents
JD Tech
JD Tech
Sep 16, 2026 · Backend Development

18 Battle-Tested Java Coding Techniques for High-Performance, Low-CPU Systems (Part 1)

This article presents 18 practical coding techniques derived from million-QPS production systems to reduce CPU consumption and improve performance, covering type unification, string handling, loop optimization, caching strategies, and data structure selection with concrete before/after code examples.

CPU optimizationCoding Best PracticesGC Reduction
0 likes · 67 min read
18 Battle-Tested Java Coding Techniques for High-Performance, Low-CPU Systems (Part 1)
Architecture Digest
Architecture Digest
Sep 13, 2026 · Artificial Intelligence

Running 2.78T-Parameter Kimi K3 on 8GB RAM: Pure C Inference Engine Explained

A pure C inference engine runs the 2.78 trillion parameter Kimi K3 model on just 8GB RAM by streaming weights from disk, leveraging MoE sparsity (only 3.7% active per token) and computing directly on compressed formats, achieving correct output at 32.69 seconds per token on consumer hardware.

C languageKimi K3LLM compression
0 likes · 11 min read
Running 2.78T-Parameter Kimi K3 on 8GB RAM: Pure C Inference Engine Explained
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 26, 2026 · Backend Development

Million-Row Excel Import/Export: Streaming, Batching & Async Patterns for Zero-OOM Performance

This guide details a production-grade architecture for million-row Excel import/export using EasyExcel streaming reads, SXSSF streaming writes, JDBC batch inserts with rewriteBatchedStatements, async MQ processing, and resource isolation — achieving 10-100x speedups and sub-100MB memory.

EasyExcelExcel streamingJDBC optimization
0 likes · 32 min read
Million-Row Excel Import/Export: Streaming, Batching & Async Patterns for Zero-OOM Performance
Architecture Digest
Architecture Digest
Aug 19, 2026 · Big Data

How to Deduplicate 4 Billion QQ IDs with Only 1 GB Memory

The article explains how to solve the classic massive‑data deduplication problem of 4 billion QQ numbers within a 1 GB memory limit by analyzing memory requirements, comparing BitMap and Bloom filter approaches, and detailing a step‑by‑step BitMap implementation with its pros and cons.

AlgorithmBitmapInterview
0 likes · 5 min read
How to Deduplicate 4 Billion QQ IDs with Only 1 GB Memory
51CTO HarmonyOS Developer Community
51CTO HarmonyOS Developer Community
Jun 26, 2026 · Mobile Development

HarmonyOS Float Precision Pitfalls: Choosing the Right Type for Sensor Data

This article explores floating-point precision issues in HarmonyOS development, demonstrating how float's 7-digit limit corrupts sensor data, why double increases memory 30% and fails in Native calls, and why BigDecimal kills real-time performance, concluding with a scenario-based selection strategy and validation mechanism.

HarmonyOSNative interfacebigdecimal
0 likes · 10 min read
HarmonyOS Float Precision Pitfalls: Choosing the Right Type for Sensor Data
liandk
liandk
Jun 25, 2026 · Fundamentals

Flyweight Pattern Explained with Java Code and Real-World Scenarios

This article introduces the Flyweight design pattern, explains its intrinsic and extrinsic state concepts, presents real-world use cases such as board games and text editors, and provides a complete Java implementation with an abstract piece, concrete piece, factory pool, and test demonstration, highlighting memory savings and potential pitfalls.

Design Patternflyweightmemory optimization
0 likes · 5 min read
Flyweight Pattern Explained with Java Code and Real-World Scenarios
Cloud Architecture
Cloud Architecture
Jun 23, 2026 · Databases

Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design

Redis sustains millions of concurrent operations not merely because it is single‑threaded, but thanks to its non‑blocking event‑loop I/O, compact in‑memory data structures, serialized command execution that eliminates lock contention, and robust production features such as replication, sharding, persistence, observability and governance.

ClusterLua ScriptingRedis
0 likes · 40 min read
Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design
21CTO
21CTO
Jun 17, 2026 · Fundamentals

Project Valhalla Hits JDK 28: Preview of Value Types Arrives

Project Valhalla's JEP 401, introducing value classes and objects, merges into the OpenJDK mainline as a preview feature in JDK 28, involving 1,816 files and over 197,000 new lines, with a cautious rollout timeline and notable design trade‑offs for Java performance.

JEP 401JavaOpenJDK
0 likes · 7 min read
Project Valhalla Hits JDK 28: Preview of Value Types Arrives
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 16, 2026 · Backend Development

Avoid OOM: Stream Massive Excel Files with Minimal Memory Using Excel‑Streaming‑Reader

This article explains how to prevent out‑of‑memory errors when importing huge Excel files in Java by using the open‑source excel‑streaming‑reader library, showing Maven setup, streaming code examples, memory‑saving configurations for shared strings and comments, and tips for handling extremely large workbooks.

Apache POIExcelJava
0 likes · 8 min read
Avoid OOM: Stream Massive Excel Files with Minimal Memory Using Excel‑Streaming‑Reader
HarmonyOS Developer Technology
HarmonyOS Developer Technology
Jun 14, 2026 · Mobile Development

Douyin HarmonyOS: 50% Dev Efficiency Boost via Indexing, Memory & Build Optimizations

Douyin's HarmonyOS team collaborated with DevEco Studio to optimize large-scale monorepo development, cutting code indexing time 80% (10→2 min), reducing IDE memory usage 65% (20→7 GB), and accelerating builds 30% (4.5→3 min), delivering a 50% overall efficiency gain now integrated into DevEco Studio 26.

Build OptimizationCode IndexingDevEco Studio
0 likes · 8 min read
Douyin HarmonyOS: 50% Dev Efficiency Boost via Indexing, Memory & Build Optimizations
Golang Shines
Golang Shines
Jun 5, 2026 · Backend Development

Using Go’s unique Package for Efficient String Interning

The article explains string interning as a memory‑saving technique, shows how to implement it manually in Go, compares the go4.org/intern library with the standard‑library unique package, and presents benchmark results that reveal memory savings but a modest speed trade‑off.

BenchmarkConcurrencygolang
0 likes · 15 min read
Using Go’s unique Package for Efficient String Interning
IoT Full-Stack Technology
IoT Full-Stack Technology
Jun 5, 2026 · Industry Insights

Can Rust Replace C in Embedded Firmware? An Industrial Study from ST and Academia

A ten‑week side‑by‑side study by ST, Inria and university researchers shows that Rust firmware for an STM32U585 microcontroller uses 45 % less RAM than an equivalent C implementation while matching performance, highlighting Rust's zero‑heap model, portability advantages and the remaining limitations for low‑end MCUs.

Ariel OSC++Embedded Firmware
0 likes · 12 min read
Can Rust Replace C in Embedded Firmware? An Industrial Study from ST and Academia
Java Backend Technology
Java Backend Technology
Jun 1, 2026 · Fundamentals

Why Is fastutil Up to 10× Faster Than Java’s Standard Collections?

fastutil dramatically outperforms Java’s standard collections by eliminating boxing, cutting memory usage and GC pressure, offering primitive‑specific maps and lists, providing 64‑bit indexed BigArrays for massive data, and delivering faster I/O utilities, all while remaining API‑compatible.

BigArraysFastUtilJava Collections
0 likes · 6 min read
Why Is fastutil Up to 10× Faster Than Java’s Standard Collections?
Java Architect Essentials
Java Architect Essentials
May 16, 2026 · Game Development

How 128 KB Contra Managed a Long Storyline on the NES

Despite being limited to just 128 KB of ROM, the 1987 NES game Contra achieved a surprisingly long storyline by exploiting tile‑based graphics, tightly packed audio data generated by the Ricoh 2A03 chip, and minimalist code that leveraged the console’s built‑in hardware functions.

ContraNESTile Graphics
0 likes · 6 min read
How 128 KB Contra Managed a Long Storyline on the NES
21CTO
21CTO
May 11, 2026 · Artificial Intelligence

How jcode Runs 10‑20 AI Agents on an 8 GB Laptop with Rust

jcode, a Rust‑based AI agent framework, uses only 27.8 MB per agent and 14 ms startup time, enabling 10‑20 concurrent agents on an 8 GB laptop, outperforming Claude Code, GitHub Copilot CLI and other Python‑based solutions in memory, speed, and scalability.

AI agentsRustjcode
0 likes · 11 min read
How jcode Runs 10‑20 AI Agents on an 8 GB Laptop with Rust
Deepin Linux
Deepin Linux
May 5, 2026 · Fundamentals

Master Linux Memory Performance with HugePages

Linux’s default 4 KB pages cause massive page tables and TLB misses in high‑memory workloads; this article explains the HugePage mechanism, its types, how it reduces page‑table entries, improves TLB hit rates, lowers fragmentation, and provides step‑by‑step configuration for static and transparent huge pages in production.

HugePagesLinuxPerformance Tuning
0 likes · 39 min read
Master Linux Memory Performance with HugePages
Data Party THU
Data Party THU
Apr 20, 2026 · Artificial Intelligence

How MemPO Uses Reinforcement Learning to Turn Agent Memory into a Trainable Policy

MemPO introduces a self‑memory policy optimization framework that lets long‑horizon LLM agents autonomously manage and refine their memory via reinforcement learning, using global‑trajectory and informative‑memory advantage estimates, achieving up to 25.98% F1 gain and 73% token reduction on benchmark tasks.

BenchmarkLLMLong-Horizon Agents
0 likes · 8 min read
How MemPO Uses Reinforcement Learning to Turn Agent Memory into a Trainable Policy
Deepin Linux
Deepin Linux
Apr 19, 2026 · Fundamentals

How Linux Fork Uses Copy‑On‑Write to Boost Process Creation Efficiency

This article explains the fork system call in the Linux kernel, details the copy‑on‑write (COW) mechanism that underpins its efficiency, provides code examples, and explores practical scenarios and performance implications for process creation, memory usage, and concurrent server programming.

COWLinuxProcess Management
0 likes · 36 min read
How Linux Fork Uses Copy‑On‑Write to Boost Process Creation Efficiency
SuanNi
SuanNi
Apr 12, 2026 · Artificial Intelligence

How MemPO Gives AI Agents Long‑Term Memory and Cuts Costs by 70%

The paper introduces MemPO, a self‑memory strategy optimization algorithm that lets large language model agents actively manage their memory, dramatically improving accuracy on complex multi‑step tasks while reducing token consumption by up to 73%, and validates the approach with extensive experiments and analysis.

AIEfficiencyLarge Language Models
0 likes · 11 min read
How MemPO Gives AI Agents Long‑Term Memory and Cuts Costs by 70%
ShiZhen AI
ShiZhen AI
Apr 2, 2026 · Artificial Intelligence

How KV Cache Works and Why Large Model Outputs Cost Five Times More Than Inputs

The article explains the KV Cache mechanism that stores previously computed key/value vectors to avoid redundant Transformer calculations, delivering roughly a 5× speedup, while also detailing why generating output tokens is far more expensive than processing input tokens due to serial generation and memory trade‑offs.

KV CacheLLM inferenceTransformer
0 likes · 9 min read
How KV Cache Works and Why Large Model Outputs Cost Five Times More Than Inputs
Data STUDIO
Data STUDIO
Mar 20, 2026 · Fundamentals

Save Up to 80% Memory in Python with 5 Built‑In Tricks

The article shows how to diagnose and dramatically cut Python’s memory usage by using built‑in tools such as sys.getsizeof, psutil, __slots__, generator expressions, memory‑mapped files (mmap) and string interning, providing concrete code examples, benchmarks and practical tips to avoid common pitfalls.

Python__slots__generator
0 likes · 15 min read
Save Up to 80% Memory in Python with 5 Built‑In Tricks
Data Party THU
Data Party THU
Feb 28, 2026 · Artificial Intelligence

How MIT’s Attention Matching Turns Linear Regression into Fast KV Compression

The article explains MIT’s Attention Matching technique that reformulates large‑model context compression as a linear regression problem, detailing its theoretical foundations, three‑step gradient‑free implementation, architectural adaptations, non‑uniform budgeting, and extensive evaluations showing orders‑of‑magnitude speed gains with minimal accuracy loss.

Attention MatchingKV compressionlinear regression
0 likes · 10 min read
How MIT’s Attention Matching Turns Linear Regression into Fast KV Compression
IT Services Circle
IT Services Circle
Feb 13, 2026 · Fundamentals

5 Proven Python Memory‑Optimization Patterns to Slash RAM Usage

Learn five practical Python techniques—streaming large files, using generator pipelines, leveraging __slots__, avoiding temporary objects in loops, and reusing buffers—that together can reduce memory consumption by up to 70% and dramatically improve performance when processing gigabyte‑scale datasets.

Python__slots__generators
0 likes · 9 min read
5 Proven Python Memory‑Optimization Patterns to Slash RAM Usage
HyperAI Super Neural
HyperAI Super Neural
Feb 11, 2026 · Artificial Intelligence

Reduce Memory by 75% Using D‑CHAG’s Cross‑Channel Hierarchical Aggregation

Researchers at Oak Ridge National Laboratory introduced D‑CHAG, a distributed cross‑channel hierarchical aggregation method that cuts memory consumption by up to 75% and more than doubles throughput when training massive multi‑channel foundation models on up to 1,024 AMD GPUs, as demonstrated on hyperspectral imaging and weather‑forecasting workloads.

D-CHAGdistributed trainingfoundation models
0 likes · 14 min read
Reduce Memory by 75% Using D‑CHAG’s Cross‑Channel Hierarchical Aggregation
Data STUDIO
Data STUDIO
Feb 9, 2026 · Fundamentals

5 Python Memory‑Optimization Patterns That Cut Usage by 70%

The article walks through five concrete Python techniques—streaming file reads, generator expressions, __slots__, avoiding temporary objects in loops, and reusing buffers—showing code examples and measured memory reductions that together lowered overall RAM consumption by about 70%.

__slots__generatorsmemory optimization
0 likes · 9 min read
5 Python Memory‑Optimization Patterns That Cut Usage by 70%
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 12, 2026 · Artificial Intelligence

How CodeGenius Re‑engineered Memory to Tame AI Agent Context Bloat

This article explains how the rapid evolution of AI agents caused context explosion, why the original fixed‑window memory failed, and how CodeGenius introduced a layered memory system that unloads stale data, deduplicates files, generates structural summaries, and dynamically compresses dialogue to keep prompts stable, reduce token cost, and improve task continuity.

AI agentContext ManagementLLM cost reduction
0 likes · 18 min read
How CodeGenius Re‑engineered Memory to Tame AI Agent Context Bloat
Deepin Linux
Deepin Linux
Dec 25, 2025 · Operations

How to Optimize Linux Thread Stack Memory for High‑Concurrency Services

This article explains the fundamentals of Linux thread stack memory, identifies why default stack sizes can cause waste or overflow in high‑concurrency scenarios, and provides practical techniques—including stack‑size tuning, code refactoring, and memory‑mapping—to reduce memory usage and improve service stability.

C++LinuxPOSIX
0 likes · 34 min read
How to Optimize Linux Thread Stack Memory for High‑Concurrency Services
AI2ML AI to Machine Learning
AI2ML AI to Machine Learning
Dec 21, 2025 · Artificial Intelligence

Why KV Caching Is Critical for Efficient LLM Inference

The article breaks down the principles of KV caching in large language models, explaining how Q/K/V behavior differs between training and inference, the role of prompts, cache size trade‑offs, and the complexities of concurrent inference, all backed by concrete examples and references.

Concurrent InferenceKV CacheLLM inference
0 likes · 7 min read
Why KV Caching Is Critical for Efficient LLM Inference
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Dec 11, 2025 · Artificial Intelligence

Fine‑Grained Activation Offloading: Cutting Memory Use While Preserving LLM Throughput

The article introduces a fine‑grained activation offloading technique implemented in Megatron‑Core that offloads module‑level activations to CPU, overlaps transfer with computation, and remains compatible with pipeline and virtual pipeline parallelism, dramatically reducing peak GPU memory for large language models while incurring minimal throughput loss.

LLMMegatronPipeline Parallelism
0 likes · 18 min read
Fine‑Grained Activation Offloading: Cutting Memory Use While Preserving LLM Throughput
Top Architect
Top Architect
Dec 8, 2025 · Backend Development

How Much Heap Memory Does Each SpringBoot HTTP Request Really Use?

This article explains how to measure the exact heap memory consumption of individual SpringBoot HTTP and RPC requests by calculating required memory from request size, configuring JVM GC parameters, creating a JMeter test plan, collecting GC logs, and analyzing results to identify optimization opportunities.

GCJMeterJVM
0 likes · 10 min read
How Much Heap Memory Does Each SpringBoot HTTP Request Really Use?
Liangxu Linux
Liangxu Linux
Nov 13, 2025 · Fundamentals

Boost Embedded Performance: 10 Proven C Code Optimization Tricks

This article presents a collection of practical embedded‑system optimization techniques, covering time‑efficiency improvements such as avoiding floating‑point arithmetic and inlining functions, space‑efficiency strategies like choosing appropriate data types, using unions and flexible arrays, as well as loop unrolling, bit‑field usage, and data‑type selection to maximize performance on resource‑constrained devices.

Embeddedlow‑levelmemory optimization
0 likes · 10 min read
Boost Embedded Performance: 10 Proven C Code Optimization Tricks
Xiao Liu Lab
Xiao Liu Lab
Oct 28, 2025 · Operations

How to Safely Optimize Tomcat Memory for Stable Production

This guide walks you through why Tomcat's default JVM settings are insufficient, common pitfalls when manually editing catalina.sh, and the recommended, maintainable approach using setenv.sh to configure heap, Metaspace, and GC options for reliable, high‑performance server operation.

JVMTomcatmemory optimization
0 likes · 7 min read
How to Safely Optimize Tomcat Memory for Stable Production
MaGe Linux Operations
MaGe Linux Operations
Sep 20, 2025 · Operations

Master Tomcat Memory Tuning: Boost Performance Up to 300%

This comprehensive guide shows how a seasoned operations engineer can dramatically improve Tomcat stability and throughput by understanding JVM memory structures, configuring optimal JVM and connector parameters, selecting the right garbage collector, and implementing robust monitoring and diagnostics to prevent crashes and latency.

JVMServer configurationTomcat
0 likes · 15 min read
Master Tomcat Memory Tuning: Boost Performance Up to 300%
macrozheng
macrozheng
Sep 18, 2025 · Fundamentals

How Bitmaps and Bloom Filters Slash Memory Usage for Massive Datasets

This article explains how using a bitmap can reduce the memory needed to store billions of integers from about 15 GB to under 500 MB, describes the bitmap concept, introduces Bloom filters, outlines their principles, advantages, common use cases, and provides Java and Redis code examples for implementation.

BitmapBloom filterData Structures
0 likes · 11 min read
How Bitmaps and Bloom Filters Slash Memory Usage for Massive Datasets
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 17, 2025 · Fundamentals

Unlock Massive Memory Savings in Python with __slots__: A Complete Guide

This article explains how Python's default class memory overhead can be dramatically reduced using the __slots__ magic attribute, providing detailed code examples, memory and speed benchmarks, practical use cases, limitations, and best‑practice recommendations for developers who need high‑performance, memory‑efficient objects.

Best PracticesPython__slots__
0 likes · 12 min read
Unlock Massive Memory Savings in Python with __slots__: A Complete Guide
Su San Talks Tech
Su San Talks Tech
Sep 11, 2025 · Databases

Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture

This article explains how Redis achieves ultra‑high concurrency by combining a single‑threaded event‑driven core, highly optimized in‑memory data structures, efficient I/O multiplexing, smart memory management, asynchronous persistence, and scalable clustering, allowing it to comfortably serve hundreds of thousands of simultaneous requests.

Performance TuningPersistenceRedis
0 likes · 16 min read
Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture
Data Party THU
Data Party THU
Sep 4, 2025 · Artificial Intelligence

How MXFP4 Quantization Lets a 1200‑Billion‑Parameter LLM Run on a Single 80GB GPU

This article analyzes the memory bottleneck of massive language models, explains the mathematical modeling of memory requirements, evaluates traditional sharding limits, and details how GPT‑OSS’s MXFP4 quantization combined with Mixture‑of‑Experts reduces memory, bandwidth, and compute demands enough to fit a 1200‑billion‑parameter model onto an 80 GB GPU with minimal accuracy loss.

FP4LLMMXFP4
0 likes · 11 min read
How MXFP4 Quantization Lets a 1200‑Billion‑Parameter LLM Run on a Single 80GB GPU
21CTO
21CTO
Aug 19, 2025 · Backend Development

How Generators Slash PHP Memory Usage When Processing Massive CSV Files

This article explains how PHP lazy evaluation using generators and the Iterator API can dramatically reduce memory consumption when loading huge CSV files, provides side‑by‑side code examples and benchmarks, and offers guidance on when to choose each approach for real‑world data processing tasks.

PHPcsv-processinggenerators
0 likes · 7 min read
How Generators Slash PHP Memory Usage When Processing Massive CSV Files
ITPUB
ITPUB
Jul 29, 2025 · Big Data

How to Deduplicate 4 Billion QQ IDs Using a Bitmap Within 1 GB Memory

Learn how to efficiently remove duplicates from 4 billion QQ numbers using a memory‑friendly Bitmap approach that fits within a 1 GB limit, including calculations, step‑by‑step implementation, Java code, and a discussion of its advantages and drawbacks.

BitmapData StructuresJava
0 likes · 9 min read
How to Deduplicate 4 Billion QQ IDs Using a Bitmap Within 1 GB Memory
Deepin Linux
Deepin Linux
Jul 24, 2025 · Fundamentals

Boosting Large-Scale std::vector Performance: Memory, Moves, and SIMD

This article examines why std::vector can become a bottleneck when handling millions of elements, analyzes memory consumption, insertion/deletion costs, and cache behavior, and presents practical optimizations such as pre‑allocation, move semantics, SIMD vectorization, and cache‑friendly designs illustrated with real‑world case studies and code examples.

C++SIMDmemory optimization
0 likes · 21 min read
Boosting Large-Scale std::vector Performance: Memory, Moves, and SIMD
AntData
AntData
Jul 8, 2025 · Artificial Intelligence

How RaBitQ Achieves 32× Vector Compression Without Sacrificing Accuracy

This article explains the challenges of high‑dimensional vector retrieval, introduces quantization techniques—especially the binary RaBitQ method and its MRQ extension—detailing their compression ratios, speed gains, compatibility with search indexes, and real‑world performance results in the VSAG system.

AI embeddingsMRQRaBitQ
0 likes · 15 min read
How RaBitQ Achieves 32× Vector Compression Without Sacrificing Accuracy
macrozheng
macrozheng
Jul 3, 2025 · Game Development

How 128KB Powered Classic Games Like Contra – Secrets of Retro Game Tech

This article explores why early 1980s games such as Contra could deliver rich graphics, music, and gameplay within just 128KB of memory, explaining tile‑based rendering, limited audio chip capabilities, and ultra‑compact code techniques that made such feats possible.

Graphicsaudiogame development
0 likes · 7 min read
How 128KB Powered Classic Games Like Contra – Secrets of Retro Game Tech
Tencent Cloud Developer
Tencent Cloud Developer
Jul 1, 2025 · Game Development

Mastering Memory Optimization for Unity Mobile Games: Practical Steps and Tools

This article explains why memory optimization is critical for Unity mobile games, outlines a three‑step workflow of testing, analysis, and fixing, details practical testing methods, data‑analysis toolchains, and concrete optimization techniques such as resource LOD, array pre‑allocation, string deduplication, compression, and atlas management, and concludes with a concise checklist for effective memory management.

ToolchainUnitymemory optimization
0 likes · 16 min read
Mastering Memory Optimization for Unity Mobile Games: Practical Steps and Tools
Tencent Cloud Developer
Tencent Cloud Developer
May 21, 2025 · Operations

How Tencent Docs Cut Desktop Memory Usage by 60% with Tombstone and Page‑Freeze Techniques

This article details the memory‑bloat problem of the Electron‑based Tencent Docs desktop client, outlines several optimization ideas, explains the implemented tombstone mechanism and Windows‑level memory cleaning plus Chromium page‑freezing, and presents benchmark results showing a roughly 60% reduction in RAM consumption.

Electrondesktop applicationmemory optimization
0 likes · 11 min read
How Tencent Docs Cut Desktop Memory Usage by 60% with Tombstone and Page‑Freeze Techniques
Architect
Architect
May 18, 2025 · Artificial Intelligence

How Much GPU Memory Can One Model Use? A Deep Dive into Transformer Memory Accounting

This article breaks down GPU memory consumption for large Transformer models, explains how to estimate each component—parameters, optimizer state, activations, gradients—and shows how parallelism, mixed precision, and recomputation strategies can dramatically reduce the footprint.

AI TrainingGPU memoryModel Scaling
0 likes · 14 min read
How Much GPU Memory Can One Model Use? A Deep Dive into Transformer Memory Accounting
Code Mala Tang
Code Mala Tang
May 17, 2025 · Backend Development

How Lazy Imports Can Slash Python Startup Time by 80%

Learn how Python's eager import mechanism can cause slow startup in large projects and discover practical lazy import techniques—including function-level imports, custom LazyLoader classes, context manager approaches, and standard library solutions—that dramatically reduce launch time and memory usage while maintaining IDE support.

Startup timelazy importmemory optimization
0 likes · 11 min read
How Lazy Imports Can Slash Python Startup Time by 80%
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Apr 27, 2025 · Databases

Why MySQL Memory Stays High and How to Optimize It

This article explains MySQL's memory architecture, why memory usage often stays high after spikes, and provides practical steps—including connection checks, slow query analysis, workload scaling, and switching to jemalloc—to diagnose and reduce memory consumption on 360's internal cloud platform.

Connection ManagementDatabase Performancejemalloc
0 likes · 7 min read
Why MySQL Memory Stays High and How to Optimize It
macrozheng
macrozheng
Apr 7, 2025 · Big Data

How to Deduplicate 4 Billion QQ Numbers Using a Bitmap Under 1 GB

This article explains how to efficiently remove duplicates from 4 billion QQ numbers within a 1 GB memory limit by replacing the naïve HashSet approach with a memory‑saving Bitmap data structure, complete with calculations, algorithm steps, Java code, and a discussion of its pros and cons.

BitmapJavadeduplication
0 likes · 9 min read
How to Deduplicate 4 Billion QQ Numbers Using a Bitmap Under 1 GB
php Courses
php Courses
Mar 27, 2025 · Fundamentals

Understanding Python List Comprehensions and Generator Expressions

This article explores Python's list comprehensions and generator expressions, detailing their syntax, performance characteristics, memory usage, multi‑level nesting, and practical tips such as dictionary/set comprehensions and integration with functional programming, helping developers choose the appropriate tool for efficient data processing.

Pythondata processinggenerator expression
0 likes · 6 min read
Understanding Python List Comprehensions and Generator Expressions
Cognitive Technology Team
Cognitive Technology Team
Mar 1, 2025 · Databases

Understanding and Mitigating Redis Large‑Key Issues

The article explains what constitutes a Redis large key, outlines its performance and stability risks, describes common scenarios and root causes, and provides practical detection commands, mitigation techniques such as splitting, compression, proper data modeling, and monitoring strategies to prevent future issues.

Large KeyRedisdatabase
0 likes · 6 min read
Understanding and Mitigating Redis Large‑Key Issues
DataFunSummit
DataFunSummit
Feb 2, 2025 · Artificial Intelligence

BladeDISC++: A Dynamic‑Shape AI Compiler for Memory‑Peak Optimization in Deep Learning Training

The article introduces BladeDISC++, a dynamic‑shape AI compiler from Alibaba Cloud PAI, explains the memory‑peak challenges of dynamic‑shape deep‑learning workloads, describes its symbolic‑shape graph, joint compile‑time/runtime optimizations such as operation fusion, scheduling and just‑in‑time rematerialization, and presents Llama2 experiments showing significant GPU memory savings and throughput gains.

AI CompilerBladeDISCLlama2
0 likes · 15 min read
BladeDISC++: A Dynamic‑Shape AI Compiler for Memory‑Peak Optimization in Deep Learning Training
php Courses
php Courses
Jan 24, 2025 · Backend Development

Using PHP Generator Functions to Create Infinite Iterable Objects

This article explains PHP generator functions introduced in PHP 5.5 and enhanced in PHP 7, demonstrating how to implement infinite iterable objects such as a Fibonacci sequence, and discusses their advantages for processing large data sets, memory efficiency, and typical use cases like log handling and pagination.

Large Data ProcessingPHPbackend development
0 likes · 5 min read
Using PHP Generator Functions to Create Infinite Iterable Objects
DeWu Technology
DeWu Technology
Jan 22, 2025 · Operations

How We Cut Video Detection Memory Usage by 78% with WebAssembly and WorkerFS

This article details the challenges of video corruption detection on a creator platform, analyzes existing server‑side and client‑side approaches, and presents a WebAssembly‑based solution using ffmpeg, WorkerFS, and memory‑growth tuning that reduces memory consumption by up to 78% while speeding up large‑file processing.

FFmpegWeb WorkerWebAssembly
0 likes · 13 min read
How We Cut Video Detection Memory Usage by 78% with WebAssembly and WorkerFS
Alibaba Cloud Big Data AI Platform
Alibaba Cloud Big Data AI Platform
Jan 17, 2025 · Artificial Intelligence

How BladeDISC++ Cuts Memory Peaks for Dynamic‑Shape Deep Learning Models

This article explains the challenges of dynamic‑shape deep learning workloads and introduces BladeDISC++, an AI compiler that uses symbolic shape graphs, operation scheduling, and just‑in‑time auto‑rematerialization to dramatically reduce GPU memory peaks while maintaining training throughput.

AI CompilerBladeDISC++LLM training
0 likes · 16 min read
How BladeDISC++ Cuts Memory Peaks for Dynamic‑Shape Deep Learning Models
Radish, Keep Going!
Radish, Keep Going!
Dec 6, 2024 · Backend Development

How BigCache Achieves Ultra‑Fast In‑Memory Caching in Go

This article explains how the Go library BigCache uses sharding, efficient hash functions, and memory‑optimised data structures to deliver high‑concurrency, low‑latency caching, while avoiding GC bottlenecks and providing practical code examples and performance benchmarks.

Gobigcachecaching
0 likes · 12 min read
How BigCache Achieves Ultra‑Fast In‑Memory Caching in Go
Python Programming Learning Circle
Python Programming Learning Circle
Nov 23, 2024 · Fundamentals

Useful Python Tricks and Advanced Techniques

This article presents a collection of lesser‑known Python tricks—including string cleaning with translate, iterator slicing via itertools.islice, skipping header lines, keyword‑only functions, custom context managers, memory‑saving __slots__, resource limits, import control, and total_ordering—to help developers write cleaner, more efficient code.

PythonResource Limitscontext manager
0 likes · 10 min read
Useful Python Tricks and Advanced Techniques
BirdNest Tech Talk
BirdNest Tech Talk
Oct 4, 2024 · Fundamentals

How Go’s New unique Package Enables Efficient Interning and Memory Savings

Go 1.23 introduces the unique package, which provides generic interning for comparable values, allowing canonicalization of strings and structs, reducing memory usage and speeding up equality checks; the article walks through a simple map‑based implementation, its limitations, the advanced Handle[T] design, real‑world netip usage, and future prospects.

Garbage Collectioncanonicalizationgeneric
0 likes · 10 min read
How Go’s New unique Package Enables Efficient Interning and Memory Savings
360 Smart Cloud
360 Smart Cloud
Jul 17, 2024 · Artificial Intelligence

Parallelism and Memory‑Optimization Techniques for Distributed Large‑Scale Transformer Training

This article reviews the principles and practical implementations of data, pipeline, tensor, sequence, and context parallelism together with memory‑saving strategies such as recomputation and ZeRO, and demonstrates how the QLM framework leverages these techniques to accelerate large‑model training and fine‑tuning on multi‑GPU clusters.

GPUMegatron-LMParallelism
0 likes · 18 min read
Parallelism and Memory‑Optimization Techniques for Distributed Large‑Scale Transformer Training