Question bank — MESI - MOESI coherence protocols

False. E is a performance optimization (silent E→M writes), not a correctness requirement. A 3-state MSI protocol is still coherent — it just broadcasts on every first write.

True. M by definition means you wrote it and memory is stale; if it were clean you'd be in E instead.

True in MESI. Sharing requires all copies agree with memory. (In MOESI the owner is dirty-and-shared, but sharers who hold S are still reading a value that the O-owner guarantees — the S copies themselves match what the owner holds.)

False. E means provably the only copy. Two exclusive holders contradict each other; the moment a second cache reads, both must become S (or O/S in MOESI).

True. S is precisely the multiple-reader case — that's its whole purpose.

False. There is exactly one owner per line; O designates the single cache responsible for supplying data and eventual write-back. Others are S.

True. The store writes the cache word locally and flips the state to M; because you were the sole holder, no bus message and no other cache is affected.

False. Write-through updates memory but does not invalidate stale copies sitting in other caches, so readers can still see old values. You still need coherence — see Write-back vs Write-through caches.

False. They enforce the same SWMR invariant and often the same MESI/MOESI states; they differ only in how they discover who holds a line — broadcast vs a tracked directory. See Snooping vs Directory-based protocols.

False. MOESI wins when dirty data is repeatedly shared (cache-to-cache forwarding beats memory round-trips), but it adds a state and complexity; for read-mostly or single-writer patterns MESI's behaviour is identical.

Error: it becomes S, not E. A BusRd means another cache now wants a copy, so the line is provably shared afterward — sharing status, not clean/dirty, decides E vs S.

Error. BusRdX (Read-for-Ownership) reads the current data into your cache and invalidates others; the actual store happens locally afterward. No new value is on the bus.

Error. A read that finds no other holder lands in E (sole clean owner). Only a read that observes existing copies lands in S.

Error. MESI forbids dirty+shared: writing forces invalidation of all others first. The dirty+shared combination is exactly what MOESI's O adds.

Error. The whole point of O is to forward cache-to-cache without touching memory; memory is written only when the owner is finally evicted.

Error. False sharing is correct coherence behaviour applied to a whole cache line: two unrelated variables in one line ping-pong ownership. The fix is software layout, not the protocol. See False Sharing.

Error. I means the line holds no valid data for that address — a hit is impossible; any access is a miss requiring a bus fetch.

Error. Coherence is per-address (all cores agree on the value history of one location); consistency orders operations across different locations. See Cache Coherence vs Memory Consistency.

Because MESI makes a writer invalidate every other copy before writing, so the instant a line becomes dirty it is also exclusive. No mechanism keeps other copies alive alongside a dirty one.

E is a proof you're the only holder, so writing endangers no one else's correctness — no notification needed. S admits other readers who could go stale, so you must broadcast BusRdX to invalidate them first.

The dirty value is likely to change again soon or be served to peers, so writing memory now is often wasted work. Keeping it in the owner and forwarding cache-to-cache defers the memory write until eviction.

M holds the only up-to-date copy. Dropping to I without writing back would destroy the sole good value, leaving memory and everyone else with stale data — violating coherence.

Acquiring an uncontended lock is read-then-write on a line nobody else touches; E lets the write be an E→M with zero bus messages, so the common (uncontended) path is nearly free.

The bus and the cache move data in fixed line-sized chunks, so the smallest unit hardware can independently own or invalidate is a line. Finer granularity would need far more state bits and bus complexity. (This is also why false sharing exists.)

Nothing. It's a read hit; state stays M and no bus traffic occurs — cached reads of your own dirty data are local.

None. M→M is a local store; you already have single-writer ownership, so no invalidation is needed.

The interconnect serializes them via bus arbitration; one grabs ownership first (lands in M), the loser's request is re-ordered after and effectively re-fetches, ending in M once the first releases.

No. E is clean (matches memory), so it can be silently dropped with no write-back — one of E's cost savings.

No. S is clean too, and other sharers (or memory) still hold the value; silent drop.

The owner holds the only dirty copy, so eviction forces a write-back to memory. This is the deferred write MOESI has been postponing.

I → (read) E → (write) M, and it stays M. It never needs S/O and never emits invalidations — the fully private, cheapest case.

MESIF adds an F (Forward) state so exactly one sharer answers read requests (fast cache-to-cache) instead of many caches or memory responding; AMD's MOESI instead keeps dirty data shareable via O. Both refine who supplies data, not the SWMR guarantee.