Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Path
  • Cache Coherency Glossary
  • The Shared Course Model
  • Cache Coherency Revision Sheet
  • Why Coherence Exists8
  • States and Protocols12
    • Single-Writer, Multiple-Reader Invariant
    • Line States and Transitions
    • Directory Versus Snoop Fundamentals
  • Transactions12
  • Races and Controller Design8
  • Progress and the Fabric16
  • Ordering and Synchronization12
  • Performance and Scalability12
  • Real Protocols12
  • SoC Integration12
  • Power, Clocking and Reliability12
  • Verification12
  • Debug and Bring-up12
  • Interview and Design Review17
  • Capstone: A Coherent Model Lab5
Loading lesson

‹Cache Coherency
  1. Topics
  2. Cache Coherency
  3. States and Protocols

Part 2 · States and Protocols · All levels

States and Protocols

Derive coherence invariants, MSI/MESI/MOESI states and the home or bus mechanisms that coordinate cached copies.

  • 3topics
  • 12lessons

Topics in this section

  1. 1Single-Writer, Multiple-Reader Invariant4 lessons
    • SWMR Precisely
    • The Data-Value Invariant
    • Invalidate Versus Update
    • What a Violation Looks Like
  2. 2Line States and Transitions4 lessons
    • MSI Protocol
    • MESI and the Exclusive State
    • MOESI and Dirty Sharing
    • Stable Versus Transient States
  3. 3Directory Versus Snoop Fundamentals4 lessons
    • Snooping on a Shared Bus
    • Directory, Home and Sharers
    • Choosing Snoop or Directory
    • Hybrids and Snoop Filters

A state letter is a compressed statement about permissions and data responsibility. Start with the invariants, then derive why MSI needs three states and what E and O add. Finally ask how the system discovers other copies and orders their requests. Read Why Coherence Exists first if exclusive holders and dirty responsibility are unfamiliar.

Invariant-first route to MSI, the additional roles of E and O, and the choice of snooping or directory coordination.
The state names serve correctness rules, not the other way round.

Twelve lessons

Lesson

After it you can...

SWMR Precisely

Recognize legal reader/writer permission combinations.

The Data-Value Invariant

Spot wrong values even when state permissions look legal.

Invalidate Versus Update

Explain two policies without mixing their message contracts.

What a Violation Looks Like

Find the first incorrect permission or lost value.

MSI Protocol

Connect states to processor events, forwarded requests and invalidations, and actions.

MESI and the Exclusive State

Explain why a clean exclusive holder can store silently.

MOESI and Dirty Sharing

Distinguish dirty responsibility from write permission.

Stable Versus Transient States

Record the work still required before a permission grant.

Snooping on a Shared Bus

Explain what the ordered broadcast contributes.

Directory, Home and Sharers

Track possible holders without treating metadata as data.

Choosing Snoop or Directory

Compare discovery, ordering, traffic and storage assumptions.

Hybrids and Snoop Filters

Explain safe conservative filtering and its limits.

Common pitfall

Do not combine MSI's dirty-read handling (memory updated, then S/S) with MOESI's O state in one unlabelled trace. Protocol variants are alternatives with explicit contracts.

Check yourself Why are both invariants and state transitions needed?

The invariants specify what must remain true. The transition rules implement those obligations across incoming events, outgoing messages and intermediate states. Naming an invariant alone does not show a controller preserves it.

Related topics

  • Shared course model

  • Prerequisite: Why Coherence Exists

  • Start: Correctness invariants

  • Revision sheet

PreviousNext: Single-Writer, Multiple-Reader Invariant

Up next

Up nextSingle-Writer, Multiple-Reader Invariant

Sign in to save progress

Practice this lessonReport an error

See also

  • How to Use This Course
  • Reading Path
  • Cache Coherency Glossary