The article compares DeepSeek V4 and GLM‑5.1 AI coding models by analyzing their pricing structures, cache‑hit mechanisms, real‑world billing data, and suitability for different coding workloads, ultimately offering guidance on when each model provides the most cost‑effective solution.
The article explains how Claude Code achieves extreme speed and low cost by building its architecture around a static prompt prefix, detailing the mechanics of prompt caching, safe model and tool switching, plan‑mode tooling, deferred loading, and cache‑safe context compression.
The article details five counterintuitive design principles for Claude Code's prompt caching—optimizing prompt layout, using message‑based updates, never switching models or tools mid‑conversation, safely compressing context, and monitoring cache health—backed by concrete examples and up to 90% cost savings.
Prompt caching, a prefix‑matching technique that reuses prior LLM interactions, proved essential for Claude Code’s low latency and cost, and the article details counter‑intuitive practices such as arranging static prompts first, updating info via messages, avoiding mid‑session model or tool changes, and ensuring cache‑safe context forks.
The article provides a detailed technical walkthrough of OpenClaw's three‑stage context‑management framework—including pre‑emptive pruning, LLM‑driven compaction, and overflow‑recovery truncation—showing how each layer protects long‑running AI agent sessions from exceeding token windows while preserving essential information.
AliSQL 8.0 introduces a shared Nodes Cache and per‑transaction cache to speed up vector queries, implements RC‑level transaction isolation for read‑only and read‑write operations, and leverages SIMD‑based pre‑computation to dramatically improve high‑dimensional vector distance calculations and concurrency performance.
CPU caches bridge the speed gap between processors and memory, but cache misses can dramatically degrade performance, especially under high concurrency or big‑data workloads; this article explains cache architecture, common miss causes, diagnostic tools like perf and cachestat, and practical optimization techniques for Linux systems.
Google engineer Zecheng Li’s patch series merges the CFS scheduler’s cfs_rq and sched_entity structures and switches to a per‑CPU allocator, cutting LLC miss rates by up to 31% and raising kernel IPC by up to 25% on AMD and Intel platforms, with negligible regression.
This article explores how to replace fixed‑parameter cache‑expiration settings with mathematically derived, adaptive time‑window formulas that start slow, accelerate, and respect upper bounds, using linear, exponential, and sigmoid models refined through large‑model assistance.
This article explains why heterogeneous servers cause CPU performance layering, describes how to detect the issue using metrics such as NUMA hit/miss rates, cache miss ratios and frequency states, and provides step‑by‑step remediation techniques—including NUMA binding, cache isolation, recompilation and frequency locking—to improve resource pooling efficiency in modern data centers.
This article explains the hidden performance killer of cache false sharing in multicore Java applications, demonstrates its impact with benchmark code, and shows how padding, the @Contended annotation, and Caffeine's internal structures can eliminate the issue for faster execution.
This article explains the cache architecture behind false sharing, demonstrates its dramatic performance impact with benchmark code, and shows how Java's @Contended annotation and Caffeine's memory‑padding techniques can effectively eliminate the issue for high‑concurrency applications.
This article explains how CPU caches bridge the speed gap between the processor and main memory, describes cache hierarchy, locality principles, write policies, coherence protocols, and provides concrete C code examples and practical tips such as data alignment and loop restructuring to improve cache hit rates and overall program speed.
This article addresses a high-concurrency inventory problem in a second-hand market's second-hand market system, focusing on solving the system's inventory deduction issue during flash sales using cache and asynchronous processing to achieve horizontal scalability.
The article shows how adding Transform functions to client-go and controller-runtime informers trims metadata, cutting apiserver memory usage by up to 60% when watching hundreds of Secrets and ConfigMaps in large Kubernetes clusters.
iQIYI integrates Alluxio with its QBFS multi‑AZ unified scheduling system, automatically caching hot tables, applying table‑level policies, page‑level storage and AZ‑aware worker selection, which together cut cross‑zone traffic, halve query latency, achieve up to 20× I/O speedup and a three‑fold overall performance boost.
StarRocks 3.3 introduces a comprehensive set of enhancements—including maturity levels, ARM‑optimized performance, advanced caching, materialized‑view rewrites, storage optimizations, and expanded lakehouse ecosystem support—that together boost stability, query speed, and usability for large‑scale analytics workloads.
This article explains what constitutes a large Redis key, the performance problems it can cause such as CPU spikes, client timeouts and memory imbalance, and presents practical solutions including key cleanup, splitting, compression, pipeline usage, and alternative storage options.
This article explains how to use Redis' Sorted Set and Hash structures to achieve efficient pagination, multi‑condition fuzzy queries, and their combination, while also discussing performance optimizations such as expiration handling and data synchronization strategies.
This article walks through a real‑world R2M (Redis‑like) cache alert, detailing the email notification, large‑key analysis, code inspection, root‑cause identification, and both immediate and long‑term solutions that reduced cache usage by over 97% and prevented future incidents.
Vivo tackled high CPU overhead in large‑scale Dubbo deployments by disabling unused routers, caching routing results with BitMap intersections and epoch validation, optimizing weight calculations, and adding a grouping router, which together delivered over 100 % TPS gains for 20 k+ providers and cut CPU usage by roughly 27 %.
This article explains the purpose of CPU caches, their hierarchical structure and internal designs—including direct‑mapped, set‑associative, and fully‑associative caches—and demonstrates how understanding cache behavior can dramatically improve program performance, illustrated with C++ traversal benchmarks.
This article explains how to implement efficient pagination and multi‑condition fuzzy queries in Redis using Sorted Sets and Hashes, outlines the underlying commands, discusses combining both techniques, and offers optimization strategies such as expiration handling to maintain cache performance.
To reduce costly database I/O, the article explains how Bloom filters, Counting Bloom filters, and Cuckoo filters work, detailing their bitmap/hash mechanisms, false‑positive behavior, deletion limitations, and practical enhancements such as multi‑hash functions and bucket‑level fingerprints.
This article explains how Bloom filters, their counting variant, and Cuckoo filters work to reduce unnecessary database I/O by using bitmap or fingerprint techniques, discusses their false‑positive and deletion limitations, and presents practical optimizations for high‑performance hash‑based filtering.
To protect the outbox Redis cluster from extreme read amplification during hot events, the service adds a resident local cache for hot creators’ latest posts, using a threshold‑based list, change‑broadcast updates, and checksum verification, which achieved over 55% cache hits and cut peak Redis load by roughly 44% and CPU usage by 37%.
This article provides a comprehensive guide to Redis memory architecture, covering memory analysis, fragmentation, object and buffer usage, Linux copy‑on‑write effects, maxmemory settings, eviction policies, and practical tips for monitoring and optimizing Redis in production environments.
The article details how a rapidly growing airline ticket order system was re‑architected by identifying performance bottlenecks, applying vertical and horizontal sharding, optimizing cache layers, implementing dual‑write mechanisms, and planning a phased migration to achieve ten‑fold QPS growth while reducing resource usage and operational risk.
This article examines Baidu's Limitless ad‑funnel optimization, detailing how a cache‑friendly HybridIndexTable and adaptive memory containers dramatically improve inverted‑list scan speed, reduce memory overhead, and enable lock‑free updates for high‑throughput retrieval systems.
This article explains the concepts, advantages, and limitations of Bloom filters, Counting Bloom filters, and Cuckoo filters, illustrating how they reduce unnecessary I/O in backend systems and offering practical improvements such as multi‑hash functions and bucket designs to enhance space and time efficiency.
This article explains the motivation behind using probabilistic filters to reduce I/O, describes how Bloom filters, Counting Bloom filters, and Cuckoo filters work, analyzes their false‑positive and deletion problems, and presents practical optimizations such as multiple hash functions and multi‑slot buckets.
The article explains how Bloom filters, Counting Bloom filters, and Cuckoo filters work, their hash‑based bitmap mechanisms, advantages and limitations such as false positives and deletion issues, and presents practical improvements and hash functions for efficient cache and database query optimization.
The article explains the principles, advantages, and limitations of Bloom filters, introduces Counting Bloom filters as an enhanced version, and then details Cuckoo filters and Cuckoo hashing, including their algorithms, performance trade‑offs, and practical improvements for reducing unnecessary I/O operations.
This article details the JD Daojia coupon system's high‑traffic architecture, describing its multi‑layer design, Redis cache challenges such as large‑key and hot‑key issues, and practical optimization techniques including key redesign, expiration strategies, and active‑expire algorithms to improve performance and scalability.
The article explains Bloom filters—a probabilistic, space‑efficient data structure using multiple hash functions on a bit array to answer set‑membership queries with controllable false‑positive rates, detailing their construction, query process, optimal parameters, and common uses such as URL deduplication, cache protection, and spam filtering.
This article explains how to use Redis's SCAN command to iterate over dictionary data, clean up stale keys, understand the command's underlying mechanics during dictionary resizing, and avoid common pitfalls through practical code examples and performance analysis.
This article examines Ceph’s architecture, identifies performance bottlenecks on Huawei’s Kunpeng ARM platform, and presents practical tuning methods—including NUMA placement, cache tagging, vector acceleration, thread scaling, and monitoring tools—to improve storage efficiency, reduce latency, and lower power consumption.
This article explains Kafka's index architecture, the AbstractIndex class hierarchy, how entry sizes are chosen, the use of memory‑mapped files, the binary‑search algorithm for locating index entries, and a cache‑friendly improvement that reduces page faults and I/O latency.
The article outlines Tencent Classroom’s cloud VOD solution, detailing HLS streaming fundamentals, a Mongoose‑based local HTTP proxy with LFU caching and pre‑loading, performance optimizations for latency, buffering, security, and playback reliability, and common transcoding pitfalls with practical fixes, highlighting cloud migration benefits.
This article provides a comprehensive overview of MonetDB, covering its origins at CWI, column‑oriented storage with BATs, memory‑mapped and vectorized execution, three‑layer system architecture, cache‑aware optimizations such as vector operations and radix‑partitioned hash joins, as well as its limitations and reference sources.
This article details how Weibo leverages Redis across billions of requests, describing its massive scale, the challenges of trillion‑level reads/writes, the technical choices and customizations made—including LongSet, HA solutions, multi‑level caching, RocksDB integration—and outlines ongoing capacity and future development strategies.
Meituan’s DSP system boosted high‑QPS ad serving performance by layering an LRU cache in front of Redis, then adding time‑based eviction, sharding the cache into HashLruCache instances to cut lock contention, and employing a zero‑copy, reference‑counted design, ultimately cutting average latency to about 20 % of the original and similarly reducing 99.9th‑percentile delays.
The article details iQIYI’s Bubble social service cache architecture, comparing Couchbase and Redis, explaining vBucket design and management UI, and presenting three real‑world optimizations—like‑system key redesign, voting‑system aggregation, and SDK upgrade—along with migration, synchronization, and operational best‑practice recommendations.
This article explains the differences between traditional page‑number pagination and infinite‑scroll (streaming) pagination, compares their characteristics, and provides detailed front‑end and back‑end implementation methods along with common pitfalls and optimization techniques such as caching, cursor‑based paging, and client‑side deduplication.
This article explores how various caching techniques—from DNS and CDN to browser and hardware caches—exhibit self‑similar fractal patterns, illustrating the universal space‑for‑time trade‑off that improves system efficiency across front‑end, back‑end, and real‑world scenarios.
The article outlines 27 C++ performance optimization techniques for ray tracing, emphasizing profiling hot paths, minimizing branches and memory accesses, using inline and reference passing, aligning data, loop unrolling, avoiding unnecessary temporaries, and simplifying math to exploit cache locality and modern CPU parallelism.
