Tagged articles
mesi
15 articles · Page 1 of 1
The article demystifies why Java's synchronized keyword can be slower by tracing the full path from CPU cache‑coherence (MESI) through bus and cache locks, volatile, biased and lightweight locks, up to the heavyweight monitor implementation, revealing each layer’s impact on visibility, ordering and atomicity.
ConcurrencyJVMJava
0 likes · 15 min read

This article explains the purpose of CPU cache memory, the principles of temporal and spatial locality, the multi‑level cache architecture, the MESI cache‑coherence protocol for multi‑core processors, and the optimizations such as store buffers and memory barriers that address performance and consistency challenges.
CPU cachecache coherencememory hierarchy
0 likes · 16 min read

Modern CPUs use multi‑level cache memory to bridge the speed gap with main memory, relying on temporal and spatial locality, and employ the MESI protocol with states M, E, S, I to maintain coherence across cores, while techniques like store buffers and memory barriers mitigate latency and ordering issues.
CPUCache Memoryhardware architecture
0 likes · 15 min read

Cache consistency spans icache‑dcache synchronization, multi‑CPU cache coherence, and device‑CPU interactions; the article explains the MESI protocol, demonstrates performance impacts with multithreaded code, explores prefetching, false sharing, mapping strategies, and practical tips for writing cache‑aware software.
CPUCacheCoherence
0 likes · 24 min read

This article explains the multiple layers of CPU cache consistency, the MESI protocol, and how improper cache handling can dramatically slow programs, then demonstrates performance gains through code examples, prefetching, false‑sharing avoidance, and DMA strategies, offering practical guidance for low‑level optimization.
CPUCacheFalseSharing
0 likes · 23 min read

This article thoroughly explains the low‑level implementation of Java's volatile keyword by analysing CPU multi‑level cache design, the MESI cache‑coherency protocol, the Java Memory Model, memory barriers, the happens‑before principle, and the impact on singleton patterns and synchronized blocks.
CPU cacheConcurrencyHappens-Before
0 likes · 36 min read

The article explains Java’s concurrency mechanisms, detailing how threads communicate and synchronize via shared memory and the Java Memory Model (JMM), describing atomic actions, the MESI cache protocol, and key principles such as happens‑before, visibility, atomicity, and ordering.
ConcurrencyJMMMemory Model
0 likes · 8 min read

This article explains how the volatile keyword ensures visibility in Java multithreaded programs by examining CPU cache architecture, cache‑coherency mechanisms such as the MESI protocol, and the low‑level assembly effects of volatile writes on modern x86 processors.
CPU cacheConcurrencymemory visibility
0 likes · 12 min read

This article explores the fundamentals of CPU cache hierarchy, why caches are needed, how cache inconsistency arises in multicore systems, and the mechanisms—such as cache coherence protocols, MESI, store buffers, invalidate queues, and memory barriers—that ensure correct data ordering and visibility across processors.
CPUConcurrencycache coherence
0 likes · 21 min read

This article explains the hardware origins of CPU caches, bus locks, cache‑coherence protocols such as MESI, store buffers and memory barriers, then shows how the Java Memory Model abstracts these mechanisms and how the volatile keyword guarantees visibility and ordering while not providing atomicity.
CPU cacheJavaMemory Model
0 likes · 28 min read

This article provides a comprehensive overview of cache memory, explaining why caches are needed, their placement strategies, operation principles, replacement policies, write handling methods, and coherence protocols such as MESI, offering essential knowledge for computer architecture and system design.
CacheReplacement Policiescomputer architecture
0 likes · 12 min read

This article explains the two core properties of Java's volatile keyword—visibility and ordering—how they are implemented via lock prefixes and memory barriers, compares volatile with synchronized and CAS, and details the underlying CPU cache‑coherency mechanisms such as MESI, store buffers, and invalidate queues.
ConcurrencyHappens-BeforeJava
0 likes · 13 min read

This article provides a comprehensive tutorial on Java concurrency, covering the usage and implementation principles of the volatile and synchronized keywords, the Java Memory Model, the MESI cache protocol, common visibility and reordering issues, and practical code examples for designing efficient multithreaded solutions.
ConcurrencyJMMJava
0 likes · 17 min read

False sharing occurs when multiple threads modify variables that reside on the same CPU cache line, causing unnecessary cache coherency traffic; this article explains cache line basics, CPU cache hierarchy, MESI protocol, and presents Java solutions—including padding, @sun.misc.Contended annotation, and JVM flags—to prevent performance degradation.
Java concurrencyPerformance Optimizationcache line
0 likes · 9 min read

CPU caches, organized into L1‑L3 levels, accelerate memory access by exploiting locality, but their independent copies can cause data inconsistency across cores; coherence protocols such as MESI and memory‑barrier instructions ensure that reads and writes remain ordered and visible across all processors.
CPUCacheCoherence
0 likes · 10 min read
