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
    • Caches and Shared Data
    • Permissions and Values
      • Permission Versus Data
      • Who Has the Newest Data?
      • Dirty Responsibility
      • Epochs and Serialization
  • States and Protocols12
  • 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

‹Why Coherence Exists
  1. Topics
  2. Cache Coherency
  3. Why Coherence Exists
  4. Permissions and Values

Part 1 · Why Coherence Exists · All levels

Permissions and Values

Separate permission, usable data, dirty responsibility and directory knowledge, then follow a value between permission epochs.

  • 4topics
  • 4lessons

Knowing a cache's state letter is only useful if you can say what the core may do, where the newest value is, and who must preserve it. These four lessons separate those questions before following short transactions on the two-core course model. This makes a stale memory value understandable without excusing a stale load.

Lesson

After it you can...

Permission Versus Data

Classify a copy without confusing readable data with write permission.

Who Has the Newest Data?

Follow the newest value from a dirty cache through H to memory and a new reader.

Dirty Responsibility

Explain why an MOESI O holder preserves dirty data but cannot write.

Epochs and Serialization

Locate the boundary between readers and a writer and justify the acknowledgement wait.

Suggested order: read top to bottom, keeping the Course Model beside the snapshots. We use C0 and C1 with private write-back caches, home H and memory; X is one location inside a 64-byte line. Initially memory holds X = 0 and neither cache holds the line; later examples name their warm starting snapshot.

Check yourself If two caches hold the newest value, must one be allowed to write?

No. Both can be read-only sharers in a read epoch. Equal values do not confer write permission; a writer must first exclude independent readers.

Related topics

  • Up: Why Coherence Exists

  • Course Model

PreviousNext: Permission Versus Data

Up next

Up nextPermission Versus Data

Sign in to save progress

Practice this lessonReport an error

See also

  • Caches and Shared Data