AMBA AXI · Module 5

Read Transaction Waveforms

Annotated end-to-end AXI read waveforms — single-beat, burst, and multi-ID (out-of-order) — assembling AR and R (RDATA/RID/RRESP/RLAST) into one readable picture.

This chapter closes the read path the way 4.6 closed the write path: the end-to-end read waveform, in three canonical shapes — a single-beat read, a burst read, and a multi-ID read (two reads outstanding, completing out of order). We annotate AR and R (RDATA/RID/RRESP/RLAST) so you can read a read off a capture at a glance, then distill the reading method. This is the Critical capstone of Module 5: master these three pictures and you can debug a read on sight, including the multi-outstanding case that trips people up.

1. The Whole Read, Assembled

A read is two handshakes: AR launches it (address + shape), and R returns the answer (data + per-beat RRESP + RID, ending in RLAST). On a waveform you read it by finding the AR transfer (ARVALID && ARREADY) and the R transfers (RVALID && RREADY), then checking they agree: the R-beat count matches ARLEN+1, each RID matches the read's ARID, the RRESP codes are clean, and RLAST lands on the last beat. The three shapes below are the same read under different conditions.

2. The Single-Beat Read

The baseline: one address, one data beat — with the request-to-data latency visible as the gap.

valid / ready (per channel)

Single-beat read — AR → (latency) → R

10 cycles

ARLEN=0 (one beat); the R beat carries RLAST=1 and RRESP=OKAY; the gap between AR and R is the read latency.

Figure 1 — a single-beat AXI read. The address transfers on the AR handshake; some cycles later (the read latency) the one data beat transfers on the R handshake, with RLAST=1 (single beat) and RRESP=OKAY. ARLEN=0, one beat, and the data return is itself the acknowledgement — no separate response channel.

This is every read's foundation. The AR launches it, and after the latency the lone R beat (with RLAST=1) delivers the data and closes the read in one go.

3. The Burst Read

One AR launches multiple data beats. AR is accepted once; after the latency, the R channel streams ARLEN+1 beats, each with its RRESP, asserting RLAST on the last.

Burst read — one AR, four R beats

10 cycles

Figure 2 — a 4-beat burst read (ARLEN=3) end to end. AR is accepted at cycle 2; after the read latency, the R channel returns D0–D3 on cycles 5–8 (RID constant for the read, RRESP=OKAY per beat), with RLAST on D3. One address out, four data beats back; the R-beat count (4) equals ARLEN+1.

Read it as: AR (cycle 2), a latency gap, then the R burst (cycles 5–8, four beats, RLAST on the fourth). Each beat carries its own RRESP; the read is complete at the RLAST beat.

4. The Multi-ID Read — Out-of-Order Completion

Now two reads are outstanding with different ARIDs, and they complete out of order — but each contiguously (AXI4 forbids beat interleaving, Chapter 5.5). RID tags every beat so the manager routes each to the right read.

Multi-ID read — out-of-order, contiguous per read

8 cycles

Figure 3 — two outstanding reads completing out of order (AXI4-style). The manager issued read ID0 then ID1; the subordinate returns ID1's beats first (E0,E1 with RLAST), then ID0's (D0,D1 with RLAST) — out-of-order completion, but each read contiguous (RID stays constant until each RLAST, never interleaved). The manager demuxes by RID. A later read returning first is legal and is how latency is hidden.

The signatures to read here: RID is constant within each read (ID1 for its beats, then ID0 for its beats) — contiguous, not interleaved — and the reads completed in a different order than issued (ID1 before ID0), which is legal out-of-order completion. If RID had switched mid-read (ID1, ID0, ID1, ID0) that would be illegal AXI4 interleaving (5.5).

5. How to Read Any Read Waveform

The three shapes share one reading method, the read-side mirror of 4.6's:

Figure 4 — the read-waveform reading method. Find the AR handshake (get the shape and ARID), then for each returning read: match RID to an outstanding ARID, count R beats to RLAST (= ARLEN+1), and check RRESP per beat. Each step checks the R channel against what AR declared, demuxing by RID when multiple reads are in flight.

In words: AR gives the contract; R is checked against it, demuxed by RID. Find ARLEN/ARID from AR; for each returning read, match RID, count beats to RLAST (must equal ARLEN+1), and check RRESP. Every read bug from Module 5 shows up as a step that disagrees — wrong beat count, mis-placed RLAST, an RID matching no read, a bad RRESP, or (illegal) RID switching mid-read.

6. Common Misconceptions

Myths to unlearn

"A read needs a separate response after the data." No — the data return is the acknowledgement; RRESP rides per beat and RLAST closes the read. There's no B-equivalent on the read path.
"Reads must return in the order issued." Different-ID reads may complete out of order (a later read returning entirely first) — legal and how latency is hidden. What's not allowed (AXI4) is interleaving their beats.
"RID changing between beats is normal." Within one read, RID is constant until its RLAST. RID switching mid-read is illegal AXI4 interleaving (5.5). It only changes between contiguous reads.
"The latency gap between AR and the first R beat is a bug." That gap is read latency (5.4) — legal and unbounded. Only the absence of any R after a clean AR, or a wrong beat count, is a bug.
"You read a read waveform cycle by cycle." You read it by handshake events (AR, each R) and check against ARLEN/ARID/RRESP — demuxing by RID when multiple reads are in flight.

7. Debugging Insight

🔍 Debugging insight — the four-step read localizes any read bug

Apply the §5 method and each failure mode falls out at a step:

AR handshake missing/malformed? The master never issued the read, or ARSIZE > bus width / illegal burst — broken before any data. (Fix at the source.)
RID matches no outstanding read? Response mis-routing — the interconnect/subordinate tagged data with the wrong RID, or returned data for a read that wasn't issued. The data lands in the wrong buffer.
Beat count ≠ ARLEN+1, or RLAST mis-placed? Length mismatch — too few/many beats or RLAST early/late. The subordinate and AR disagree; the manager may hang waiting for missing beats (5.3).
RRESP not OKAY on some beat? That beat's data is invalid — DECERR → address/map; SLVERR → inside the target. Remember the burst still completes all beats even with an error (5.3).
RID switching mid-read (AXI4)? Illegal interleaving (5.5) — usually a bad subordinate or an un-de-interleaved AXI3 bridge.

So a read waveform is never overwhelming: walk AR → (match RID) → R count/RLAST → RRESP, and the failing step is the bug class.

8. Verification Insight

✅ Verification insight — these three shapes plus RID demux are your read coverage floor

The single, burst, and multi-ID shapes are the floor of a read coverage plan, and the monitor reconstructs each the way the eye does: capture AR (ARID/ARLEN), then collect R beats — demuxing by RID — until each read's RLAST, checking against AR. Coverage must hit: single-beat (ARLEN=0), multi-beat bursts of varied length/size/type, and multiple outstanding reads with distinct ARIDs returning out of order — plus crossed with error RRESP beats (5.3) and variable read latency (5.4, including backpressure via RREADY). A plan that only runs one in-order, full-OKAY, single-beat read verifies almost none of the read path.

The waveform shapes map to assertions: RLAST on beat ARLEN+1, each RID pairs to an outstanding read, read data contiguous per RID (no interleaving, AXI4), and per-beat RRESP legal/expected. The multi-ID shape is where the interactions live — out-of-order completion, RID demux, contiguity — which per-channel and single-read tests miss. Mechanics in Module 16.

9. Interview Questions

10. Summary

A read on a waveform is two handshakes to find and reconcile: AR (the contract — address and ARLEN/ARSIZE/ARBURST/ARID) and the R return (exactly ARLEN+1 beats, each with RRESP and RID, ending in RLAST). The three canonical shapes are the same read under different conditions: the single-beat read (ARLEN=0, one beat that delivers data and closes), the burst read (one AR, a latency gap, then a contiguous run of beats with RLAST on the last), and the multi-ID read (two outstanding reads completing out of order but each contiguous, demuxed by RID).

Read any of them with one method: find AR, match RID, count R to RLAST (= ARLEN+1), check RRESP — and every Module 5 bug surfaces as the step that disagrees, with RID-switching-mid-read being the illegal-interleaving tell and a wrong-RID being mis-routing. Verify with these shapes as the floor, crossed with error responses, variable latency/backpressure, deep outstanding, and (AXI3) interleaving. That completes the read path; Module 6 zooms into every Ax* / WSTRB / RESP / LAST signal in depth.

11. What Comes Next

That closes Module 5 — Read Transactions. Module 6 goes deep on the individual signals across both paths:

6.1 — AxADDR, AxLEN & AxSIZE (coming next) — the address, beat-count, and beat-width signals together, in depth.

Previous: 5.5 — Read Data Interleaving. For the broader protocol catalog, see the AMBA family overview doc.