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 Paths
  • Concept Map
  • How to Read the Diagrams
  • Part 0: What Is a Protocol?10
  • Part 1: Timing and Clocking11
  • Part 2: Encoding and Framing12
  • Part 3: Handshakes13
  • Part 4: Flow Control17
  • Part 5: Transactions19
  • Part 6: Concurrency and Performance17
  • Part 7: Ordering13
  • Part 8: Sharing and Arbitration12
  • Part 9: Deadlock and Liveness13
  • Part 10: Reliability and Recovery20
  • Part 11: Bring-Up and Link Management10
  • Part 12: Power8
  • Part 13: Shared State and Coherence9
  • Part 14: Security and Isolation7
  • Part 15: Specifying and Verifying11
  • Part 16: Protocols Dissected17
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹First Principles of Hardware Protocols
  1. Topics
  2. First Principles of Hardware Protocols
  3. Concept Map

Start here · All levels

Concept Map

The fifteen questions the course is built on, how they group, and which parts build on which.

On this page

    The course is built on fifteen questions that every protocol has to answer. Each part answers one. Every part page shows this grid with its own question highlighted, so you always know where you are.

    The fifteen questions in four rows, from getting bits across a wire to system-level concerns.

    The four rows

    Row

    Parts

    What it covers

    Getting bits across

    0–3

    What a protocol is, when a receiver samples, how it finds message boundaries, and how two sides agree a word moved

    Moving transactions

    4–7

    How much may be in flight, what a transaction asks for, how many can overlap, and in what order results appear

    Sharing and surviving

    8–11

    Who gets a shared resource, why systems hang, how errors are caught and repaired, and how links start up

    System concerns

    12–15

    Power, shared state across caches, security, and proving the whole thing correct

    Which parts build on which

    Flowchart of part dependencies. Contract leads to clocking, framing and handshakes. Handshakes lead to flow control, which leads to transactions, concurrency and ordering, and also to arbitration and deadlock. Concurrency also feeds deadlock. Framing and flow control feed reliability, which feeds start-up. Ordering feeds coherence.
    Main dependencies between parts. Parts 12, 14 and 15 draw on everything before them; parts 16 to 18 apply the whole course.

    Two threads matter most. The sizing thread runs through handshakes, credits, concurrency and replay: each time, a buffer or a window must cover a round trip, and the same bandwidth × latency reasoning answers it. The agreement thread runs through handshakes, ordering, deadlock and coherence: each time, two or more agents must reach the same conclusion from what they can see.

    Check yourself Which earlier lesson does replay-buffer sizing (Part 10) reuse, and why?

    The credit loop (Part 4). Both hold something until an answer comes back, so both must cover bandwidth × round-trip time or the sender stalls.

    Related topics

    • Course hub

    • Reading paths

    Previous

    3 / 234

    Next: How to Read the Diagrams

    Up next

    Up nextHow to Read the Diagrams

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • How to Use This Course
    • Part 0: What Is a Protocol?
    • Part 1: Timing and Clocking