Skip to content
Reliability Engine

Reliability Engine

Every chapter so far that named a timer, a retry count, or an acknowledgment left the actual mechanism closed. This part opens it: the live state a Queue Pair keeps to know what it sent and what still needs confirming, the buffer that holds an unacknowledged packet’s worth of information long enough to resend it, the two parallel state machines that decide when a timeout becomes a retry and when a retry becomes a QP driven to ERROR, what actually gets retransmitted when it does, what happens when many Queue Pairs need retransmission service from the same shared pipeline at once, and what happens when a Queue Pair resets with a timer armed and a replay buffer entry still waiting on an acknowledgment that will now never come.

This part covers two resources, not one: per-QP retry and timeout state, and the Replay Buffer itself.

One difference matters before you reach it. The Replay Buffer can’t use an LRU, priority-weighted, or error-weighted eviction policy the way a QP or key-table cache can: evicting an unacknowledged entry early isn’t a performance cost paid on a future re-fetch, it’s a correctness violation – discarding a requester’s only copy of data it may still need to resend. The chapter that would have been “Eviction Policy” instead explains why that frame breaks here, and what governs capacity in its place.

One sent packet, until it’s safe to forget – what reliability-owned state does after a packet leaves, from the held copy and armed timer through the retry state machine, to the hazards that can interrupt it (multi-QP arbitration, backpressure, mid-transaction reset). Each step names the chapter that covers it.

Chapters

Retry and Timeout State
QP Context named four fields and stopped, deferring them to a part of the book that didn’t exist yet. This is that part, and these are the fields – plus the live state built on top of them that no field name alone can carry.
The Replay Buffer
A reliable sender can’t forget what it sent the instant it sends it – only once something confirms the other side actually has it. This chapter is where that in-between state actually lives, and what it costs to hold it.
Message Completion and the MSN
PSN answers which packet arrived. It cannot answer which Work Request is done, because software posts work at message granularity and a single message can span many packets. This chapter covers the field that answers that question instead, and the one handoff no earlier chapter in this Part actually owns.
Replay Buffer Caching
Every other cached resource in this book competes for the same shared SRAM. The Replay Buffer is no exception, and its own working set is shaped by something neither the QP Cache nor the Key Cache has to think about: how fast acknowledgments actually come back.
The Retry and RNR Timeout State Machines
A lost packet and a full receive queue are not the same failure, and Reliable Connection doesn’t treat them the same way – two parallel timeout branches, counted independently, both capable of driving a Queue Pair to the same terminal state.
Go-Back-N Retransmission
When a retry fires, hardware doesn’t need to know exactly which packet was lost – only where to resume from. That’s cheaper to build than it sounds, and the price is wasted bandwidth on packets that technically already arrived.
Multi-QP Retry Arbitration
One QP’s retransmission is a self-contained event. Many QPs losing packets to the same root cause at the same moment is a different problem entirely – and on a shared fabric, that correlation is the common case, not the exception.
Replay Buffer Capacity and Backpressure
Every other cache in this book answers capacity pressure by evicting something. This one can’t – evicting an unacknowledged entry doesn’t cost a future re-fetch, it costs correctness. This chapter is what governs capacity instead.
Mid-Transaction Reliability Reset
Mid-Transaction QP Reset named replay-buffer contents and armed timers among the leftovers RESET has to reconcile, and left both unresolved. This chapter resolves them, and finds one hazard neither chapter can fully close.
Last updated on