Skip to practice questions

Part 2 · AXI transfers

AXI channels, handshakes, and bursts

Preserve independent channel handshakes while reconstructing complete transactions and checking every burst beat.

Reading path
2 of 3
Concept chapters
2
Practice links
11

Question-first preparation

Practice the mechanisms on this page.

Each question maps directly to one of the chapters below, so you can test the contract before reading the explanation.

Recommended start

One representative prompt from each major mechanism. Open any card in the live question bank.

  1. Q035AXI Write Address Changes While StalledWaveform Debugging · MediumPractice
  2. Q081Read Burst Marks the Third Beat as LastWaveform Debugging · MediumPractice
  3. Q070AXI Write Response Is Issued Too EarlyWaveform Debugging · MediumPractice
  4. Q690Check independent AXI write channelsAssertions and Formal · MediumPremium
  5. Q839Allow AXI address and data reorderingComputer Architecture · MediumPremium
  6. Q340Assertions for a one-beat AXI writeAssertions & Formal · MediumPremium
Complete question directoryFilter every stable practice link by mechanism.11 questions

04 · Five independent handshakes

AXI verification must preserve channel independence and transaction dependencies.

AXI separates read address, read data, write address, write data and write response traffic so each channel can stall independently while the transaction remains coherent.

Rule to say firstTreat AW, W, B, AR and R as separate ready/valid channels. Reconnect them only through explicit transaction rules—not same-cycle assumptions.

AXI transaction ledger

Independent channel events converge at explicit completion gates.

Write address
offerstallaccept
Write data
accept beat 0accept last
Write response
blockedblockedeligibleBVALIDaccept
Read path
AR acceptR beat 0stallR lastcomplete
  1. 01AWWrite address

    Address and attributes transfer whenever AWVALID && AWREADY.

  2. 02WWrite data beats

    Data may arrive before or after AW; accepted WLAST closes the stream.

  3. 03B gateAW seen ∧ final W seen

    The write response becomes eligible only after both dependencies.

  4. 04BWrite response

    BVALID persists independently until BREADY accepts it.

  5. 05AR → RRead request to beats

    An accepted read address creates a response stream ending in RLAST.

AWWrite address

Address and attributes transfer whenever AWVALID && AWREADY.

Channels
5
AW, W, B, AR and R each own a handshake.
AW versus W
Either order
A legal monitor cannot require same-cycle arrival.
Write completion
AW + WLAST + B
The response depends on both accepted request components.
Stall rule
Per channel
VALID and payload persist independently on every channel.

Channel independence improves concurrency but moves complexity into bookkeeping. Verification needs one local handshake checker per channel and one transaction-level model that joins the legal dependencies.

01

Observe

Record every channel handshake independently, including IDs, attributes, beat counts, LAST and responses.

02

Decide

Maintain channel-local state plus a transaction ledger that expresses dependencies such as AW accepted and final W accepted before B.

03

Failure

A design couples AW to W, changes payload under stall, emits B too early or a monitor loses transactions when channels arrive in an unexpected order.

04

Prove

Bind ready/valid properties to all channels, reconcile channel events in a scoreboard and cover every arrival order, independent stall pattern and outstanding depth.

Give every channel its own monitor state

The five channels use the same ready/valid contract but carry different roles. A robust monitor observes them independently before a transaction assembler or scoreboard joins related events.

AXI channel responsibilities
ChannelDirectionTransaction roleKey terminal event
AWManager → subordinateWrite address and attributesAW handshake
WManager → subordinateWrite data and byte strobesAccepted WLAST beat
BSubordinate → managerWrite completion responseB handshake
ARManager → subordinateRead address and attributesAR handshake
RSubordinate → managerRead data and responseAccepted RLAST beat

Encode the write-response dependency explicitly

For AXI4 and AXI5, a subordinate issues a write response only after the write address and the final write data beat have both been accepted. The example below illustrates one-outstanding bookkeeping; multi-outstanding designs need queues keyed by the architectural association.

  • Do not make BVALID combinationally dependent on BREADY.
  • Do not infer AW/W order from waveform habit; test W-first, AW-first and simultaneous acceptance.
  • This one-outstanding ledger must reject a second AW, a second terminal W beat, or same-cycle response turnover unless the implementation explicitly adds queueing for those cases.
  • AXI4 removed WID and write-data interleaving. Write-data bursts remain associated in AW transaction order even though an individual W burst may begin before its AW handshake.
  • A multi-outstanding checker can keep ordered AW and completed-W-burst queues, then join their fronts; independent channel timing does not permit arbitrary address/data pairing.
One-outstanding write dependency ledgersystemverilog
always_ff @(posedge ACLK or negedge ARESETn) begin
  if (!ARESETn) begin
    aw_seen    <= 1'b0;
    wlast_seen <= 1'b0;
  end else begin
    if (AWVALID && AWREADY) aw_seen    <= 1'b1;
    if (WVALID  && WREADY && WLAST)
      wlast_seen <= 1'b1;
    if (BVALID && BREADY) begin
      aw_seen    <= 1'b0;
      wlast_seen <= 1'b0;
    end
  end
end

assert property (@(posedge ACLK) disable iff (!ARESETn)
  BVALID |-> aw_seen && wlast_seen);

assert property (@(posedge ACLK) disable iff (!ARESETn)
  AWVALID && AWREADY |-> !aw_seen);

assert property (@(posedge ACLK) disable iff (!ARESETn)
  WVALID && WREADY && WLAST |-> !wlast_seen);

assert property (@(posedge ACLK) disable iff (!ARESETn)
  BVALID && !BREADY |=> BVALID && $stable(BRESP));

Use reset to terminate protocol obligations deliberately

Reset clears interface VALID state and local channel trackers, but a system-level environment must also decide what happens to already accepted work beyond the reset boundary.

  • Flush or epoch-tag expected transactions according to the architectural reset scope.
  • Reject unmatched late responses rather than allowing them to alias a newly reused ID.
  • Randomize reset during every channel stall and between dependent write events.
  • After release, verify all output VALID signals start from the required reset state before new traffic begins.

Explain it out loud

Interview reasoning checkpoints

Strong answer

No. AW and W are independent channels, so write data may be accepted before, after or with the write address.

Reason it through
  1. Each channel has its own VALID/READY handshake.
  2. A subordinate or interconnect retains enough state to associate the accepted components legally.
  3. The write response waits for both the address and the final data beat.
Interviewer lens

This exposes testbenches that accidentally constrain AXI into a simpler same-cycle protocol.

Common trap

Writing a monitor or slave driver that ignores WVALID until AW has already handshaken.

Strong answer

No. As the response source, it asserts BVALID when the response is available and holds it until BREADY accepts it.

Reason it through
  1. VALID ownership always belongs to the source of that channel.
  2. Waiting for READY can create a circular dependency.
  3. BRESP must remain stable while BVALID is stalled.
Interviewer lens

The question checks whether the candidate applies the same handshake rule consistently in the reverse direction.

Common trap

Remembering the manager-side VALID rules but treating response channels as special.

Strong answer

Channel monitors preserve independent handshake truth, while the transaction scoreboard joins those events using AXI’s explicit dependencies, IDs and beat rules.

Reason it through
  1. Local monitors can report payload stability and channel timing precisely.
  2. A transaction assembler can tolerate legal channel reordering.
  3. The scoreboard remains focused on end-to-end data, response and ordering correctness.
Interviewer lens

This tests verification architecture, not only protocol memorization.

Common trap

One monolithic monitor that assumes a fixed AW/W/B sequence and silently misses unusual but legal timing.

05 · Address arithmetic becomes protocol state

A burst is one request with a beat-by-beat proof obligation.

At address acceptance, the verifier can derive beat count, bytes per beat, legal addresses, byte lanes, terminal beat and 4 KiB legality before any data arrives.

Rule to say firstBeats = AxLEN + 1 and bytes per beat = 2^AxSIZE. Advance state only on accepted data beats, and require LAST exactly on the final accepted beat.

INCR burst derivation

Derive the complete legal window before accepting beat zero.

Accepted beat
0123complete
INCR address
startaligned + B+ 2B+ 3B
B is bytes per beat; the first beat may be unaligned.
LAST
0001
Stall effect
holdholdholdholdnone
A cycle without handshake never advances the ledger.
  1. 01AddressAxADDR

    Record the first transfer address and its 4 KiB page.

  2. 02ShapeLEN + SIZE + BURST

    Compute beat count, bytes per beat and address progression.

  3. 03Boundary gateSame 4 KiB region

    Reject a burst whose highest transferred byte enters another 4 KiB block.

  4. 04Beat ledger0 … AxLEN

    Advance the index only on a data-channel handshake.

  5. 05TerminalLAST at final beat

    Exactly one accepted beat closes the burst.

AddressAxADDR

Record the first transfer address and its 4 KiB page.

Beat count
AxLEN + 1
LEN is encoded as beats minus one.
Beat width
2^AxSIZE bytes
Bus width can be larger than the requested transfer.
Boundary
4 KiB
No single burst may cross the address boundary.
Terminal
WLAST / RLAST
LAST aligns with the final accepted beat.

The burst request is a compact program for the following data stream. A predictor should expand it once, then use accepted-beat events to compare the actual stream.

01

Observe

Capture AxADDR, AxLEN, AxSIZE, AxBURST, ID and attributes, then count only W or R handshakes.

02

Decide

Precompute the legal beat sequence, byte-lane mask, wrap boundary and final-beat index for each accepted request.

03

Failure

LAST is early or late, an address crosses 4 KiB, a narrow or unaligned transfer uses illegal lanes, or wait cycles are counted as beats.

04

Prove

Compare every accepted beat with the derived model, assert terminal placement and cover burst type, length, alignment, stalls, lanes and boundary-adjacent starts.

Calculate from the address request, not the waveform

For an INCR burst, align the start down to the transfer size for subsequent address progression. The first beat may use only the legal lanes at or above an unaligned start address.

  • beats = AxLEN + 1
  • bytes_per_beat = 1 << AxSIZE
  • aligned_start = floor(AxADDR / bytes_per_beat) × bytes_per_beat
  • For INCR, last_byte = aligned_start + beats × bytes_per_beat − 1; compare the first and last byte's upper address bits for the 4 KiB rule.
  • For WRAP, derive the wrap span from beats × bytes_per_beat and enforce the protocol's legal lengths and alignment.
Burst-type model
AxBURSTAddress behaviorKey checks
FIXEDEvery beat uses the same addressLength limit, lane legality and terminal beat.
INCRAddress advances by bytes per beatAlignment progression and 4 KiB boundary.
WRAPINCR progression wraps within a fixed spanLegal length, alignment and wrap boundary.

Count accepted beats and validate LAST on that event

VALID cycles are not beats when READY is low. The terminal rule therefore belongs inside the handshake branch, where the accepted index and observed LAST are compared together.

  • The snippet shows one stream; a complete checker associates burst state according to the interface's outstanding and ordering rules.
  • Apply the same accepted-beat discipline to RLAST.
  • Keep LAST stable with the rest of the payload during a stall.
Accepted-beat terminal checksystemverilog
always_ff @(posedge ACLK or negedge ARESETn) begin
  if (!ARESETn) begin
    beat_index <= '0;
  end else if (WVALID && WREADY) begin
    assert (WLAST == (beat_index == expected_beats - 1));

    if (WLAST)
      beat_index <= '0;
    else
      beat_index <= beat_index + 1'b1;
  end
end

assert property (@(posedge ACLK) disable iff (!ARESETn)
  WVALID && !WREADY |=>
    WVALID && $stable({WDATA, WSTRB, WLAST}));

Check byte lanes as data semantics

A correct address sequence can still corrupt memory if WSTRB marks illegal lanes or if a narrow transfer is shifted incorrectly. Model the lane mask for each beat and compare final memory effects.

  • Cross transfer size with address offset, bus width, burst type and WSTRB pattern.
  • Exercise unaligned first beats and boundary-adjacent legal and illegal bursts.
  • Distinguish a protocol-legal strobe pattern from the product's narrower functional constraints.
  • For reads, compare only bytes architecturally transferred and interpret response errors per beat.

Explain it out loud

Interview reasoning checkpoints

Strong answer

Eight. AXI encodes the burst length as beats minus one, so the count is AxLEN + 1.

Reason it through
  1. Accepted beat indices run from zero through AxLEN.
  2. LAST must coincide with accepted index AxLEN.
  3. Wait cycles do not increment the index.
Interviewer lens

This is a small arithmetic check that often reveals off-by-one scoreboards and LAST assertions.

Common trap

Using AxLEN directly as the number of beats.

Strong answer

At address acceptance, because AxADDR, AxLEN, AxSIZE and AxBURST already determine the complete transfer window.

Reason it through
  1. The rule concerns the whole burst, not a later data-channel surprise.
  2. Early detection gives a precise request-side error.
  3. Boundary-adjacent starts and unaligned first beats need arithmetic based on actual transferred byte addresses.
Interviewer lens

This tests whether the candidate derives protocol state rather than waiting for symptoms.

Common trap

Reporting the violation only when a later beat appears across the boundary.

Strong answer

It remains the same final beat. VALID, LAST and the rest of the payload stay stable until READY accepts it.

Reason it through
  1. LAST is a payload qualifier on W and R.
  2. The burst does not finish merely because LAST is visible.
  3. Completion state advances only on the LAST handshake.
Interviewer lens

This combines ready/valid persistence with burst terminal semantics.

Common trap

Clearing LAST after one cycle even though the destination never accepted it.