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

  • Architecture Metrics Reference
  • Workload Taxonomy for Architects
  • Architecture Glossary
  • Computer Architecture Cheatsheet
  • Pipeline Fundamentals14
  • Memory Hierarchy15
  • NoC and Interconnect Architecture6
  • Coherency and Memory Ordering9
    • Cache Coherence for the Architect
      • MESI States and the Single-Writer Invariant
      • Misses, Upgrades, and Evictions
      • Variants and Scaling: MOESI, MESIF, Snoop, Directory
      • ACE and CHI: An Honest Introduction
      • Sharing Costs and Coherence Triage
    • Memory Ordering Models
  • Performance Analysis9
  • Accelerator Architectures6
  • SoC Architecture Tradeoffs9
  • Architecture Interview Prep14
Loading lesson

‹Cache Coherence for the Architect
  1. Topics
  2. Computer Architecture
  3. Coherency and Memory Ordering
  4. Cache Coherence for the Architect
  5. Variants and Scaling: MOESI, MESIF, Snoop, Directory

Computer Architecture · All levels

Variants and Scaling: MOESI, MESIF, Snoop, Directory

MOESI and MESIF variants, plus when snoop broadcast gives way to directories.

On this page

    Owned and Forward: why variants exist

    MOESI adds Owned: a dirty sharer that forwards data without writing back. MESIF adds Forward: one designated clean sharer that answers instead of memory.

    Both keep single-writer semantics. They differ only in which cache answers a read without touching memory.

    Protocol

    Extra state

    Saving

    Cost

    MSI

    None; baseline

    Simplest to verify

    Every private write pays invalidations

    MESI

    E: clean exclusive

    Silent upgrades for private data

    Needs sharer tracking at miss time

    MOESI

    O: dirty shared forwarder

    No writeback on dirty-to-shared transfers

    Dirty sharing complicates eviction

    MESIF

    F: clean designated forwarder

    One responder, fewer memory fetches

    Forwarder election on every sharing change

    Snoop broadcast versus directory

    Snooping broadcasts every miss to every cache. A directory tracks sharers per line and probes only them.

    Broadcast is simple and fast at small core counts. Its probe traffic grows with cores, while directory traffic grows with sharers.

    Axis

    Snoop broadcast

    Directory

    Probe fanout per miss

    Every other core

    Only recorded sharers

    State cost

    None beyond cache tags

    Sharer bits on every line

    Best when

    Few cores, mostly private lines

    Many cores with real sharing

    Organization and protocol are separate axes. Any of MSI, MESI, MOESI, or MESIF can ride either fabric.

    Two worked scalings

    Sharer bits cost area on every line. Assume 2^20 lines and 16 cores.

    Diagram
    Directory sharer state, 16 cores, 1 048 576 lines:
      bits  = 1 048 576 x 16 = 16 777 216 bits
      bytes = 16 777 216 / 8 = 2 097 152 B, about 2 MB

    Owned state saves memory writebacks. Assume 64 B lines and 5 successive reads of one Modified line by 5 different cores.

    Diagram
    Five dirty-to-shared transfers, 64 B lines:
      MESI:  5 writebacks x 64 B + 5 fetches x 64 B = 320 + 320 = 640 B through memory
      MOESI: 5 dirty forwards x 64 B = 320 B cache to cache, 0 writebacks until eviction
      saving = 640 - 320 = 320 B of memory traffic, one half

    Common mistakes

    Common pitfall

    Calling the directory a protocol variant beside MESI. Organization (snoop versus directory) is one axis and the state set is another; mixing them up breaks whiteboard answers.

    Interview

    Likely probe: when a directory pays for itself. Answer with the two scalings above: probe fanout against sharers, and sharer-bit area against broadcast energy.

    Check yourself 16 cores share one line across 8 of them, and a ninth core writes. How many probes does each fabric send?

    Broadcast sends 15, one per other core. The directory sends 8 targeted probes plus 8 acknowledgements.

    Check yourself A Modified line is read in turn by 5 new cores. How many memory writebacks under MESI and under MOESI?

    MESI performs 5 writebacks plus 5 memory fetches. MOESI performs 0 writebacks until eviction and forwards cache to cache.

    Related topics

    • Cache-coherency course

    • Caches

    Previous

    42 / 86

    Next: ACE and CHI: An Honest Introduction

    Up next

    Up nextACE and CHI: An Honest Introduction

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • MESI States and the Single-Writer Invariant
    • Sharing Costs and Coherence Triage