Cache Coherence and Consistency Models - A Guide for Distributed Systems

• 🧠 What is Cache Coherence?
  • ✅ Common Cache Coherence Techniques:
• 📜 Cache Consistency Models
  • 🔐 1. Strict Consistency
  • 📚 2. Sequential Consistency
  • 🔁 3. Causal Consistency
  • 🕒 4. Eventual Consistency
  • 📊 Summary Table
  • ⚖️ How to Choose?
• 🔍 Final Thoughts

When designing a caching strategy for distributed systems or multi-core processors, it's essential to understand cache coherence and consistency models. These concepts ensure that data remains accurate and up-to-date—even when multiple caches are involved.

🧠 What is Cache Coherence?

Cache coherence ensures that all nodes or processors see a consistent view of shared data. In systems with multiple caches, each may hold a copy of a data item. If one copy is updated, all others must reflect that change.

✅ Common Cache Coherence Techniques:

1. Write-invalidate

   • When a cache writes to its local copy, it invalidates all other copies in other caches.
   • Other caches must fetch fresh data when needed.
   • ✅ Lower network usage; ❌ Possible performance hit on frequent invalidation.

2. Write-update (write-broadcast)

   • When a cache writes, it broadcasts the updated value to all other caches.
   • All caches update their copies instantly.
   • ✅ Real-time data propagation; ❌ Higher network traffic.

📜 Cache Consistency Models

While coherence ensures all copies eventually agree, consistency models define how and when updates become visible across the system. Let's break down the four consistency models — with scenarios, diagrams in words, and when to use which model in real systems.

🔐 1. Strict Consistency

✅ Definition:

Every read must reflect the latest write, immediately and globally.

📈 Example Scenario:

Imagine a stock trading platform. When Alice buys 100 shares, Bob (on another server) should instantly see that change, or else trades could happen with stale data.

🔧 Diagram (conceptual):

Write(W1) → [Node A] Read(W1)
          → [Node B] Read(W1)

Every node instantly reflects the latest value.

🟢 Use When:

• Absolute accuracy is critical
• Ex: Banking, real-time trading

🔴 Avoid When:

• You have high network latency or distributed nodes across the globe
• It's nearly impossible to implement practically

📚 2. Sequential Consistency

✅ Definition:

All operations appear in the same sequence for all nodes, but the system doesn't guarantee immediate visibility.

📈 Example Scenario:

In a shared document editor, two users type sequentially. Everyone should see edits in the same order, even if there's a slight delay.

🔧 Diagram:

Client A: Write(W1) → Read(W1)
Client B: Write(W2) → Read(W1 → W2)

All clients see the same order: W1 → W2

🟢 Use When:

• Order matters, but instant sync isn't required
• Ex: Collaborative editing, logging systems

🔴 Avoid When:

• You need higher performance and can tolerate slight disorder

🔁 3. Causal Consistency

✅ Definition:

Only causally related operations must appear in order. Unrelated ops can appear in any order.

📈 Example Scenario:

In a social media feed:

• Alice posts “I got the job!”
• Then replies to her own post “So excited!” Anyone seeing the reply should have already seen the original post.

But:

• Bob posts a cat meme — not related to Alice's post — and can appear in any order.

🔧 Diagram:

Alice: Post P1 → Comment C1
      Everyone must see: P1 before C1

Bob: Post B1 (unrelated) → can appear anytime

🟢 Use When:

• You have user interactions with logical cause-effect
• Ex: Social networks, collaborative apps

🔴 Avoid When:

• You need strict order for every operation

🕒 4. Eventual Consistency

✅ Definition:

Every node will eventually reflect the latest value, but no guarantees on when or in what order.

📈 Example Scenario:

You change your Twitter bio — it might show the old bio for a few seconds on some devices, but it updates eventually.

🔧 Diagram:

Write(W1) → Node A (immediate)
          → Node B (after delay)
          → Node C (after longer delay)

🟢 Use When:

• You care about availability and performance
• Ex: DNS, NoSQL DBs, shopping cart systems

🔴 Avoid When:

• Consistency is critical (e.g., banking, seat booking)

📊 Summary Table

⚖️ How to Choose?

🔍 Final Thoughts

Understanding cache coherence and consistency models is key to building robust, scalable systems. Whether you're optimizing for accuracy or performance, choosing the right model can make or break your application's reliability and speed.