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
    • Deadlock, Livelock and Starvation
    • Deadlock Conditions and Graphs
    • Channel Dependencies
    • Message-Dependent Deadlock
    • The Consumption Assumption
    • Routing Deadlock
    • Pre-allocation or Retry
    • Retry Livelock
    • Timeouts and Watchdogs
    • Hang Debug
    • Proving Deadlock Freedom
    • Protocols Compared: Deadlock and Liveness
    • Drills: Deadlock and Liveness
  • 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. Part 9: Deadlock and Liveness

Part 9 · Deadlock and Liveness · All levels

Part 9: Deadlock and Liveness

Why can it hang? Draw the wait-for cycle behind a hang.

  • 13topics
  • 13lessons
On this page

    Part 9 answers: Why can it hang?

    Where Part 9 sits among the fifteen questions of the course.

    Most protocol hangs are not random. They come from a cycle of waits that the protocol allowed: a buffer waiting on a channel waiting on the buffer. Once you can draw that cycle, you can prevent it by design and prove you did.

    This part covers deadlock, livelock and starvation; dependency graphs; channel dependencies; message-dependent deadlock; the consumption assumption; routing deadlock; pre-allocation versus retry; retry storms; timeouts; hang debug; and proving deadlock freedom.

    After this part you can

    • Draw the wait-for cycle behind a hang.

    • Explain why responses need their own channel or class.

    • Argue to a review board that a fabric cannot deadlock.

    Warm-up: three questions from Part 8

    Answer each in your head before opening it. If two or more feel shaky, revisit Part 8: Sharing and Arbitration first.

    Check yourself Why can fixed-priority arbitration starve a requester?

    A higher-priority requester that asks every cycle always wins, so a lower one may never be granted.

    Check yourself What does round-robin guarantee?

    Bounded waiting: with N requesters, each one waits at most N − 1 grants to others before its turn.

    Check yourself What is a virtual channel?

    A separate logical channel, with its own buffering and flow control, sharing one physical link with others, so traffic in one cannot block traffic in another.

    Lessons

    #

    Lesson

    Level

    Status

    9.1

    Deadlock, Livelock and Starvation

    W · Working

    Ready

    9.2

    Deadlock Conditions and Graphs

    W · Working

    Ready

    9.3

    Channel Dependencies

    S · Senior

    Ready

    9.4

    Message-Dependent Deadlock

    S · Senior

    Ready

    9.5

    The Consumption Assumption

    S · Senior

    Ready

    9.6

    Routing Deadlock

    S · Senior

    Ready

    9.7

    Pre-allocation or Retry

    P · Principal

    Ready

    9.8

    Retry Livelock

    S · Senior

    Ready

    9.9

    Timeouts and Watchdogs

    W · Working

    Ready

    9.10

    Hang Debug

    S · Senior

    Ready

    9.11

    Proving Deadlock Freedom

    P · Principal

    Ready

    —

    Protocols compared

    all levels

    Ready

    —

    Drills and checkpoint

    all levels

    Ready

    Every lesson in this part is ready. Work through them in order: each one sets up the problem the next one solves.

    Tip

    DCLink in this part. Step 8: separate request and response classes, removing a planted deadlock. DCLink is the small protocol you build across the course; see How to use this course.

    Where other courses go deeper

    This course teaches why protocols are designed the way they are. These lessons show how to build or sign off the same ideas, so this part links to them instead of repeating them.

    • Architecture: XY Routing and Deadlock Freedom

    • RTL: Stalling without deadlock

    Related topics

    • Course hub

    • Previous: Part 8 · Sharing and Arbitration

    • Next: Part 10 · Reliability and Recovery

    PreviousNext: Deadlock, Livelock and Starvation

    Up next

    Up nextDeadlock, Livelock and Starvation

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • How to Use This Course
    • Reading Paths
    • Concept Map