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
  • Transactions12
  • Races and Controller Design8
  • Progress and the Fabric16
  • Ordering and Synchronization12
  • Performance and Scalability12
  • Real Protocols12
    • MESI Versus MOESI Trade-Offs
      • When the Owned State Pays
      • MESIF and the Forward State
      • Comparing Protocol Traffic
      • Choosing a Protocol
    • CHI and ACE Message Models
    • TileLink and Custom Coherence Extensions
  • SoC Integration12
  • Power, Clocking and Reliability12
  • Verification12
  • Debug and Bring-up12
  • Interview and Design Review17
  • Capstone: A Coherent Model Lab5
Loading lesson

‹MESI Versus MOESI Trade-Offs
  1. Topics
  2. Cache Coherency
  3. Real Protocols
  4. MESI Versus MOESI Trade-Offs
  5. Choosing a Protocol

Part 8 · Real Protocols · All levels

Choosing a Protocol

Decide between MSI, MESI, MOESI and MESIF from the sharing pattern, memory bandwidth, state and directory bits, and verification cost.

On this page

    Which states earn their place?

    A state is worth adding when the event it optimises is common in the target workload and the resource it saves is the one that limits performance or energy. Each state costs state bits, directory metadata, and above all new transitions and races to verify. Decide from measured or modelled sharing patterns, not from the length of the acronym.

    Protocol

    Stable states

    Bits per line

    Optimises

    Adds to verify

    MSI

    I, S, M

    2

    Nothing beyond correctness

    Smallest state space, the baseline

    MESI

    adds E

    2

    Read then write of a private line: no upgrade

    E to M silent store, H forwarding to a possibly clean holder, PutE

    MOESI

    adds E and O

    3

    Dirty line read by others: no memory write or memory read

    M to O, O upgrade, Fwd-GetM to O with sharers, PutM from O while sharers remain

    MESIF

    adds E and F

    3

    Clean shared read served by one cache, not memory

    F hand-off on every read, F eviction, a forward that finds no F copy

    Directory metadata grows too. MESI's exclusive(C0) reuses the exclusive-holder pointer. MOESI's O: C0, sharers {C1} needs a holder pointer and a sharer set at the same time, and MESIF needs an F pointer beside the sharers. For sharer-set cost see Full Bit-Vector Cost.

    Flowchart: add E for private read-then-write lines, add O when dirty lines are read by other cores and memory bandwidth limits, add F when clean lines are widely read and memory is slower than a cache transfer.
    Decision flow for a state set. Each question is answered from a profile of the workload, and each added state must name the resource it saves.

    Almost every design answers the first question yes: E costs no extra bit and the private read-then-write pattern is everywhere. The O and F questions need the profile. The verification column decides close calls: an extra state that saves little in the profile is not worth its races.

    Two illustrative workloads

    Workload

    Pattern from profile

    What the counts say

    Recommendation

    A: pipeline hand-off. C0 fills a descriptor line each step, C1 and C2 read it

    Every line is written by one core then read by two, repeatedly

    Simulator, 3 rounds: MOESI 1 memory write and 1 memory read against MESI's 3 and 4, but 40 messages against 34 through H

    MOESI when memory bandwidth limits, ideally with direct forwarding so the extra reader legs shorten

    B: mostly private data plus a lookup table written once at start-up

    Private lines read then written, shared lines clean and read-mostly

    E saves one GetM and Data per private line. O almost never occurs: dirty lines are rarely read by others before eviction

    MESI. Consider F only if clean shared misses to far memory dominate the profile

    Workload A's numbers come from Comparing Protocol Traffic. If the same pipeline were limited by interconnect bandwidth instead of memory, the six extra messages would count against MOESI and MESI would be the safer pick. The decision follows the limiting resource.

    Common pitfall

    Choosing MOESI because it has 'more optimisations'. If dirty lines are rarely read by other cores, O almost never appears, yet its transitions and races still have to be designed, verified and covered.

    Interview

    Answer a 'which protocol?' question with the sharing pattern, the limiting resource, the cost in states and directory bits, and the verification cost, then recommend. Mention that ACE (IHI 0022 H.c) exposes five MOESI-like states (UniqueClean, UniqueDirty, SharedClean, SharedDirty, Invalid). CHI (IHI 0050 E.a) adds UniqueCleanEmpty and UniqueDirtyPartial. The AMBA interfaces are covered in the next topic, and the choice is often which of those states a cache actually uses.

    Check yourself A design is limited by interconnect bandwidth, and its dirty lines are each read by exactly one other core before the producer writes again. Is O still worthwhile?

    Yes, in the course model. With one consumer, MOESI sends exactly as many messages as MESI per round and removes the memory write each time, so it adds no messages (only the final eviction carries data, as PutM instead of PutS). The extra messages appear only with a second reader, which MOESI forwards to the O holder instead of serving from memory.

    Related topics

    • Shared course model

    • When the Owned State Pays

    • MESIF and the Forward State

    Previous

    89 / 167

    Next: CHI and ACE Message Models

    Up next

    Up nextCHI and ACE Message Models

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • When the Owned State Pays
    • MESIF and the Forward State