Width Converters: Upsizing and Downsizing

Say what a width converter may change and what it must change. Run a downsizer beat by beat, and merge split read data without hiding an error.

You Will Be Able To

  • Predict the AxSIZE, AxLEN, lanes and strobes an upsizer and a downsizer produce for a request.
  • Explain why a downsizer must modify a full-width request even when it is Non-modifiable.
  • Merge the two halves of a read beat so that an error in either half reaches the manager.
Lesson
P2.19
Time
30 min
Runs on
Your browser
Check
5 questions

A 64-bit DMA engine read a table through a 32-bit peripheral bus. One word sat in a powered-down block, and its half of a beat answered SLVERR. The downsizer kept the response of the first half, which was OKAY, so the engine stored garbage and reported success.

Two 8-byte Beats Become Four 4-byte BeatsEdges 3 to 12 of the example, part 1: the manager side is 64 bits wide, the memory side 32.
  • Manager
  • Interconnect
  • Subordinate
WVALIDs_wvalidBVALIDManager64-bitDownsizersplits each beatMemory32-bit
WVALID→ Downsizers_wvalid→ MemoryBVALID→ ManagerManager64-bitDownsizersplits each beatMemory32-bit

A pill is one 4-byte beat on the narrow side.

0123456789clkawvalidwvalidwreadys_awvalids_awlenx3s_wvalids_wdatax4433221188776655bbaa0099ffeeddccs_wlastbvalid
Scroll horizontally ↔
  1. Cycle 1

    The request leaves with AxSIZE 2 and AxLEN 3: four beats of four bytes, the same eight-byte-aligned address.

  2. Cycle 2

    Lanes 0 to 3 of the first 64-bit beat go first, as one 32-bit beat.

  3. Cycle 3

    Then lanes 4 to 7, the bytes at the next four addresses.

  4. Cycle 6

    The second half of the last beat carries WLAST.

  5. Cycle 9

    One write response, passed back unchanged.

Size halves, length doubles, the address stays.

Upsizing: Lanes Move, Nothing Is Rewritten

Lesson P2.7 put a 32-bit manager on a 64-bit memory. A 4-byte transfer is a legal narrow transfer on the wider bus, so the upsizer passes AxSIZE, AxLEN and the address unchanged. It moves each beat into the half of the wide word its address names, and the strobes move with it.

An upsizer may do more for a Modifiable request: pack two 4-byte beats into one 8-byte beat, halving the length. That changes AxSIZE and AxLEN, so for a Non-modifiable request it is forbidden.

Downsizing: Half the Size, Twice the Length

A 64-bit manager on a 32-bit memory has no such freedom. AxSIZE must not exceed the data width of an interface, so an 8-byte beat cannot cross a 4-byte bus. The specification names this case: when a component downsizes below the size a request needs, it must modify the request.

So the downsizer halves AxSIZE and doubles AxLEN, and keeps the address. Each write beat leaves as two halves, lanes 0 to 3 first, because those bytes have the lower addresses. A request that already fits, AxSIZE 2 or less, passes unchanged. Only its data moves between the half of the 64-bit word and the 32-bit lanes.

ChannelFull-width request (AxSIZE 3)Narrow request (AxSIZE 2 or less)
AW, ARAxSIZE 2, AxLEN = 2 x (AxLEN + 1) - 1, address keptunchanged
Weach beat split in two, lanes 0-3 first; WLAST on the second half of the last beatthe half its address names, moved to lanes 0-3
Bpassed backpassed back
Rtwo beats merged into one; the worse response of the twomoved into the half its address names

What the bench's downsizer, axi_down.sv, does on each channel.

Doubling the length has a limit. An AXI4 INCR burst has at most 256 transfers. So a 64-bit burst of more than 128 beats cannot become one narrow burst. A real downsizer then splits it into several requests.

Merging the Read Data and Its Response

On the way back, two 4-byte beats become one 8-byte beat. Each half arrived with its own response, but the merged beat has room for one. The rule that keeps the manager honest is simple: if either half failed, the merged beat failed. Part 3 of the example reads two 8-byte beats; the second straddles the edge of a dead region.

Writes are easier: the memory gives one response for the whole narrow burst, and the downsizer passes it back unchanged.

Where You Will Meet It

Every SoC with more than one bus width has converters: a 128-bit CPU port, a 64-bit DRAM controller, 32-bit peripherals. Interconnect generators insert them automatically, so their rules show up in reviews and in interviews.

Asked in interviews: width converters
  1. May a downsizer change a Non-modifiable request?

    Yes, it has to. A size larger than the bus is illegal, and the specification lets a component modify a request it cannot carry otherwise.

  2. May an upsizer pack beats?

    Only for a Modifiable request. Packing changes AxSIZE and AxLEN; for a Non-modifiable one it must steer lanes only.

  3. How does a downsizer merge read responses?

    The merged beat carries the worse of the two responses, so an error in either half reaches the manager.

  4. What breaks when a 64-bit burst is very long?

    The narrow burst would need twice the transfers. Past 256 transfers it must be split into several requests.

Try It

Part 1 writes two 8-byte beats. The memory sees AxSIZE 2 and AxLEN 3, four beats, and the dump shows the sixteen bytes in address order. Part 2 writes one 4-byte beat to 0x114. It fits the narrow bus, so it passes unchanged, and only its data moves from lanes 4-7 to lanes 0-3.

Part 3 reads two 8-byte beats from 0x200. The memory refuses everything from 0x20c up, so the second beat's halves answer OKAY and SLVERR, and the merged beat reports SLVERR. Now change it. Set mem.err_above = 32'h0300 and both beats are OKAY. Set dn.no_merge_resp = 1 and the error disappears.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: down e3: AW 0x100 size 3 len 1 -> size 2 len 3 e3 AW id=1 addr=0x100 len=1 size=3 INCR down e4: W beat 0 split: lanes 0-3 now, lanes 4-7 next e4 W beat 0 data=0x8877665544332211 strb=11111111 last=0 addr 0x100 lanes 0-7 down e7: W beat 1 split: lanes 0-3 now, lanes 4-7 next e7 W beat 1 data=0xffeeddccbbaa0099 strb=11111111 last=1 addr 0x108 lanes 0-7 e12 B id=1 OKAY 0x00100 11 22 33 44 55 66 77 88 99 00 aa bb cc dd ee ff down e13: AW 0x114 size 2 len 0 fits: passed unchanged e13 AW id=2 addr=0x114 len=0 size=2 INCR e14 W beat 0 data=0x5a5a5a5a00000000 strb=11110000 last=1 addr 0x114 lanes 4-7 e18 B id=2 OKAY 0x00110 00 00 00 00 5a 5a 5a 5a 00 00 00 00 00 00 00 00 down e19: AR 0x200 size 3 len 1 -> size 2 len 3 e19 AR id=3 addr=0x200 len=1 size=3 INCR down e24: R beat 0 merged from two halves: OKAY + OKAY -> OKAY e25 R id=3 beat 0 data=0x0 OKAY addr 0x200 lanes 0-7 down e26: R beat 1 merged from two halves: OKAY + SLVERR -> SLVERR e27 R id=3 beat 1 data=0x0 SLVERR last addr 0x208 lanes 0-7 merged responses: OKAY SLVERR checker: 2 writes, 1 reads, 2 stalled edges, 0 rules broken
Read included file: axi_pkg.sv
`timescale 1ns/1ns
// axi_pkg.sv: the arithmetic of a burst (read-only).
// Every transfer n of a burst has an address and a set of byte lanes, computed from the start
// address, the burst length, the transfer size and the burst type exactly as the AXI specification
// defines them. The memory, the manager tasks and the checker all use these functions, so they
// never disagree about where a byte lands.
package axi_pkg;
  localparam logic [1:0] FIXED = 2'b00, INCR = 2'b01, WRAP = 2'b10;
  localparam logic [1:0] OKAY = 2'b00, EXOKAY = 2'b01, SLVERR = 2'b10, DECERR = 2'b11;

  function automatic string burst_name(input logic [1:0] b);
    case (b) FIXED: return "FIXED"; INCR: return "INCR"; WRAP: return "WRAP"; default: return "RESERVED"; endcase
  endfunction
  function automatic string resp_name(input logic [1:0] r);
    case (r) OKAY: return "OKAY"; EXOKAY: return "EXOKAY"; SLVERR: return "SLVERR"; default: return "DECERR"; endcase
  endfunction

  // Bytes in one transfer: 1, 2, 4, ... 128.
  function automatic int bytes_of(input logic [2:0] size);
    return 1 << size;
  endfunction

  // The address of transfer n (n counts from 0).
  //   transfer 0 uses the start address as given, aligned or not;
  //   later transfers use the start address aligned down to the transfer size, plus n transfers;
  //   a WRAP burst returns to its wrap boundary (the start aligned down to the whole burst) when
  //   it reaches the end of that window; a FIXED burst repeats the start address.
  function automatic int unsigned beat_addr(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n);
    int unsigned nb = 1 << size;
    int unsigned aligned = (start / nb) * nb;
    int unsigned window = nb * (len + 1);
    int unsigned boundary = (start / window) * window;
    int unsigned a;
    if (burst == FIXED || n == 0) return start;
    a = aligned + n * nb;
    // Unsigned offset also works when the window ends at 2**32.
    if (burst == WRAP && (a - boundary) >= window) a = a - window;
    return a;
  endfunction

  // The byte lanes transfer n uses on a bus of bus_bytes bytes, packed as {upper, lower}.
  // Transfer 0 of an unaligned burst (and every transfer of a FIXED burst) uses only the lanes from
  // its address up to the end of its aligned transfer; every other transfer uses all the lanes of
  // its size.
  function automatic logic [15:0] beat_lanes(input int unsigned start, input int len, input logic [2:0] size,
                                             input logic [1:0] burst, input int n, input int bus_bytes);
    int unsigned nb = 1 << size;
    int unsigned a = beat_addr(start, len, size, burst, n);
    int unsigned aligned = (a / nb) * nb;
    int unsigned word = (a / bus_bytes) * bus_bytes;
    int lower = a - word;
    int upper = (n == 0 || burst == FIXED) ? (aligned + nb - 1 - word) : (lower + nb - 1);
    return {upper[7:0], lower[7:0]};
  endfunction

  // The strobe of transfer n: a 1 for every lane it uses (bit l is lane l).
  function automatic logic [63:0] beat_strb(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n, input int bus_bytes);
    logic [15:0] lanes = beat_lanes(start, len, size, burst, n, bus_bytes);
    logic [63:0] s = 0;
    for (int l = lanes[7:0]; l <= lanes[15:8]; l++) s[l] = 1'b1;
    return s;
  endfunction

  // True when the burst crosses a 4 KB boundary (only an INCR burst can).
  function automatic bit crosses_4k(input int unsigned start, input int len, input logic [2:0] size, input logic [1:0] burst);
    if (burst != INCR) return 0;
    return (beat_addr(start, len, size, burst, 0) / 4096) != ((beat_addr(start, len, size, burst, len) + (1 << size) - 1) / 4096);
  endfunction
endpackage
Read included file: axi_mem.sv
`timescale 1ns/1ns
// axi_mem.sv: an AXI4 subordinate with a byte-addressed memory behind it (read-only in this lesson).
// It accepts requests on AW and AR, write beats on W (before or after their AW), writes the bytes a
// burst addresses using the strobes, and answers on B and R after a latency. The switches below are
// plain variables: the stimulus sets them by name (mem.reorder = 1;) before it starts.
//   rd_latency, wr_latency   cycles from a request (or its last write beat) to its first response
//   slow_latency, slow_above addresses at or above slow_above answer after slow_latency instead
//   err_above                addresses at or above err_above get SLVERR (and are not written)
//   reorder                  answer transactions with DIFFERENT IDs as soon as each is ready;
//                            transactions with the same ID still answer in order
//   interleave               interleave the read data beats of ready transactions with different IDs
//   excl_on                  support exclusive access (one monitor per ID), else answer OKAY
//   posted                   apply a write to the memory only when its response is sent, so a read
//                            that arrives between the last beat and B still sees the old bytes
//   trace                    print every byte the memory writes
// Broken twins, each off by default: early_b (B before the last write beat and before AW),
// ignore_strobes (write every lane of the bus word), drop_hold (RDATA changes while RVALID waits
// for RREADY), reorder_same_id (a later transaction with the same ID may answer first),
// wrap_bug (a WRAP burst addressed like INCR).
module axi_mem #(parameter int DATA_W = 32, parameter int ID_W = 4, parameter int DEPTH = 65536) (
  input  logic              aclk,
  input  logic              aresetn,
  input  logic [ID_W-1:0]   awid,
  input  logic [31:0]       awaddr,
  input  logic [7:0]        awlen,
  input  logic [2:0]        awsize,
  input  logic [1:0]        awburst,
  input  logic              awlock,
  input  logic [3:0]        awcache,
  input  logic [2:0]        awprot,
  input  logic              awvalid,
  output logic              awready,
  input  logic [DATA_W-1:0] wdata,
  input  logic [DATA_W/8-1:0] wstrb,
  input  logic              wlast,
  input  logic              wvalid,
  output logic              wready,
  output logic [ID_W-1:0]   bid,
  output logic [1:0]        bresp,
  output logic              bvalid,
  input  logic              bready,
  input  logic [ID_W-1:0]   arid,
  input  logic [31:0]       araddr,
  input  logic [7:0]        arlen,
  input  logic [2:0]        arsize,
  input  logic [1:0]        arburst,
  input  logic              arlock,
  input  logic [3:0]        arcache,
  input  logic [2:0]        arprot,
  input  logic              arvalid,
  output logic              arready,
  output logic [ID_W-1:0]   rid,
  output logic [DATA_W-1:0] rdata,
  output logic [1:0]        rresp,
  output logic              rlast,
  output logic              rvalid,
  input  logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int N = 16;                      // transactions in flight per direction

  // ---- switches ----
  int rd_latency = 2, wr_latency = 2, slow_latency = 8;
  int unsigned slow_above = 32'hffff_ffff, err_above = 32'hffff_ffff;
  bit reorder = 0, interleave = 0, excl_on = 0, posted = 0, trace = 0;
  bit early_b = 0, ignore_strobes = 0, drop_hold = 0, reorder_same_id = 0, wrap_bug = 0;

  // ---- the memory ----
  logic [7:0] mem [0:DEPTH-1];
  initial for (int i = 0; i < DEPTH; i++) mem[i] = 8'h00;

  int cycle = -1;
  int seq = 0;                                // every request gets a sequence number: issue order

  // ---- write side: accepted AW requests (a ring) and write beats (a ring) ----
  logic [ID_W-1:0] aw_id [0:N-1];
  int unsigned     aw_addr [0:N-1];
  int              aw_len [0:N-1];
  logic [2:0]      aw_size [0:N-1];
  logic [1:0]      aw_burst [0:N-1];
  logic            aw_lock [0:N-1];
  int aw_head = 0, aw_tail = 0, aw_count = 0;
  localparam int WQ = 1024;
  logic [DATA_W-1:0] w_data [0:WQ-1];
  logic [BUS-1:0]    w_strb [0:WQ-1];
  logic              w_last [0:WQ-1];
  int w_head = 0, w_tail = 0, w_count = 0, w_bursts = 0;   // w_bursts: complete bursts in the ring

  // ---- write responses waiting for their latency ----
  logic            b_use [0:N-1];
  logic [ID_W-1:0] b_id [0:N-1];
  logic [1:0]      b_rsp [0:N-1];
  int              b_at [0:N-1], b_seq [0:N-1];
  logic            b_driving = 0;
  logic            early_done = 0;            // the early_b twin answers once per burst
  // posted writes: the beats of a write kept until its response goes out
  logic [DATA_W-1:0] p_data [0:N-1][0:255];
  logic [BUS-1:0]    p_strb [0:N-1][0:255];
  int unsigned       p_addr [0:N-1];
  int                p_len [0:N-1];
  logic [2:0]        p_size [0:N-1];
  logic [1:0]        p_burst [0:N-1];
  logic              p_pending [0:N-1];

  // ---- read side: accepted AR requests with their progress ----
  logic            r_use [0:N-1];
  logic [ID_W-1:0] r_id [0:N-1];
  int unsigned     r_addr [0:N-1];
  int              r_len [0:N-1];
  logic [2:0]      r_size [0:N-1];
  logic [1:0]      r_burst [0:N-1];
  logic            r_lock [0:N-1];
  int              r_at [0:N-1], r_seq [0:N-1], r_beat [0:N-1], r_served [0:N-1];
  int              r_cur = -1;                // the transaction whose beat is on the wires
  logic            r_driving = 0;

  // ---- exclusive monitors, one per ID ----
  logic        mon_use [0:(1<<ID_W)-1];
  int unsigned mon_addr [0:(1<<ID_W)-1];
  int unsigned mon_bytes [0:(1<<ID_W)-1];

  initial begin
    for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; p_pending[i] = 0; end
    for (int i = 0; i < (1 << ID_W); i++) mon_use[i] = 0;
    awready = 0; wready = 0; arready = 0; bvalid = 0; rvalid = 0; bid = 0; bresp = 0; rid = 0; rresp = 0; rlast = 0; rdata = 0;
  end

  function automatic int latency_of(input int unsigned a, input int base);
    return (a >= slow_above) ? slow_latency : base;
  endfunction
  function automatic logic [1:0] burst_used(input logic [1:0] b);
    return (wrap_bug && b == WRAP) ? INCR : b;
  endfunction

  // ---- selection policies ----
  // The oldest of all pending entries, or the oldest of its ID: the in-order rule of the protocol.
  function automatic bit b_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (b_use[j] && j != i && b_seq[j] < b_seq[i] && (!same_id_only || b_id[j] == b_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit r_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (r_use[j] && j != i && r_seq[j] < r_seq[i] && (!same_id_only || r_id[j] == r_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit b_eligible(input int i);
    if (!b_use[i] || b_at[i] > cycle) return 0;
    if (!reorder) return b_oldest(i, 0);
    return reorder_same_id ? 1 : b_oldest(i, 1);
  endfunction
  function automatic bit r_eligible(input int i);
    if (!r_use[i] || r_at[i] > cycle) return 0;
    if (!reorder) return r_oldest(i, 0);
    return reorder_same_id ? 1 : r_oldest(i, 1);
  endfunction
  function automatic int free_b();
    for (int i = 0; i < N; i++) if (!b_use[i]) return i;
    return -1;
  endfunction
  function automatic int free_r();
    for (int i = 0; i < N; i++) if (!r_use[i]) return i;
    return -1;
  endfunction
  function automatic int pick_b();
    int best = -1;
    for (int i = 0; i < N; i++) if (b_eligible(i) && (best < 0 || b_seq[i] < b_seq[best])) best = i;
    return best;
  endfunction
  function automatic int pick_r();
    int best = -1;
    for (int i = 0; i < N; i++) if (r_eligible(i)) begin
      if (best < 0) best = i;
      else if (interleave ? (r_served[i] < r_served[best]) : (r_seq[i] < r_seq[best])) best = i;
    end
    return best;
  endfunction

  // ---- the bytes of one read beat, as the bus word that holds them ----
  function automatic logic [DATA_W-1:0] read_word(input int unsigned a);
    logic [DATA_W-1:0] d = 0;
    int unsigned word = (a / BUS) * BUS;
    for (int l = 0; l < BUS; l++) d[8*l +: 8] = (word + l < DEPTH) ? mem[word + l] : 8'h00;
    return d;
  endfunction

  // ---- the write of one complete burst into the memory ----
  task automatic write_burst(input int e);
    logic [1:0]  rsp = OKAY;
    logic        do_write = 1, ended = 0;
    int unsigned a, word;
    logic [15:0] lanes;
    int          n = 0, slot;
    int unsigned total = (1 << aw_size[e]) * (aw_len[e] + 1);
    slot = free_b();
    if (aw_lock[e] && excl_on) begin
      if (mon_use[aw_id[e]] && mon_addr[aw_id[e]] == aw_addr[e]) begin
        rsp = EXOKAY;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: the monitor matched, EXOKAY", cycle, aw_id[e], aw_addr[e]);
      end else begin
        do_write = 0;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: no monitor, OKAY and nothing written", cycle, aw_id[e], aw_addr[e]);
      end
    end
    while (!ended && n <= aw_len[e]) begin
      a = beat_addr(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n);
      lanes = beat_lanes(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n, BUS);
      word = (a / BUS) * BUS;
      if (a >= err_above) rsp = SLVERR;
      else if (do_write && posted && slot >= 0) begin
        p_data[slot][n] = w_data[w_head]; p_strb[slot][n] = w_strb[w_head];
      end else if (do_write) begin
        for (int l = 0; l < BUS; l++)
          if ((w_strb[w_head][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = w_data[w_head][8*l +: 8];
            if (trace) $display("mem e%0d: beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, w_data[w_head][8*l +: 8], word + l, l);
          end
      end
      ended = w_last[w_head];                      // a burst ends at its WLAST, whatever AWLEN said
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
      n = n + 1;
    end
    while (!ended) begin                           // beats past AWLEN (a broken manager) are dropped
      ended = w_last[w_head];
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
    end
    // A write clears every monitor that watches a byte it touched.
    if (do_write)
      for (int i = 0; i < (1 << ID_W); i++)
        if (mon_use[i] && mon_addr[i] < aw_addr[e] + total && aw_addr[e] < mon_addr[i] + mon_bytes[i]) mon_use[i] = 0;
    if (slot >= 0) begin
      b_use[slot] = 1; b_id[slot] = aw_id[e]; b_rsp[slot] = rsp; b_seq[slot] = seq; seq = seq + 1;
      b_at[slot] = cycle + latency_of(aw_addr[e], wr_latency);
      if (posted && do_write) begin
        p_pending[slot] = 1; p_addr[slot] = aw_addr[e]; p_len[slot] = n - 1; p_size[slot] = aw_size[e]; p_burst[slot] = aw_burst[e];
      end
    end
  endtask

  // A posted write reaches the memory when its response goes out.
  task automatic apply_posted(input int i);
    int unsigned a, word;
    for (int n = 0; n <= p_len[i]; n++) begin
      a = beat_addr(p_addr[i], p_len[i], p_size[i], burst_used(p_burst[i]), n);
      word = (a / BUS) * BUS;
      if (a < err_above)
        for (int l = 0; l < BUS; l++)
          if ((p_strb[i][n][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = p_data[i][n][8*l +: 8];
            if (trace) $display("mem e%0d: posted beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, p_data[i][n][8*l +: 8], word + l, l);
          end
    end
    p_pending[i] = 0;
  endtask

  int pick, extra;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      aw_head = 0; aw_tail = 0; aw_count = 0; w_head = 0; w_tail = 0; w_count = 0; w_bursts = 0;
      for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; end
      b_driving = 0; r_driving = 0; r_cur = -1;
      awready <= 0; wready <= 0; arready <= 0; bvalid <= 0; rvalid <= 0;
    end else begin
      // -- AW: take a request while there is room --
      if (awvalid && awready) begin
        aw_id[aw_tail] = awid; aw_addr[aw_tail] = awaddr; aw_len[aw_tail] = awlen; aw_size[aw_tail] = awsize;
        aw_burst[aw_tail] = awburst; aw_lock[aw_tail] = awlock;
        aw_tail = (aw_tail + 1) % N; aw_count = aw_count + 1;
      end
      // -- W: take a beat while there is room --
      if (wvalid && wready) begin
        w_data[w_tail] = wdata; w_strb[w_tail] = wstrb; w_last[w_tail] = wlast;
        w_tail = (w_tail + 1) % WQ; w_count = w_count + 1;
        if (wlast) w_bursts = w_bursts + 1;
      end
      // -- a complete burst with its request: write it and schedule B --
      if (aw_count > 0 && w_bursts > 0) begin
        write_burst(aw_head);
        aw_head = (aw_head + 1) % N; aw_count = aw_count - 1; w_bursts = w_bursts - 1;
        early_done = 0;
      end else if (early_b && !early_done && w_count > 0 && w_bursts == 0) begin
        // The broken twin: a response as soon as the first write beat arrived, before WLAST and,
        // when the data came first, before the address.
        pick = free_b();
        if (pick >= 0) begin
          b_use[pick] = 1; b_id[pick] = (aw_count > 0) ? aw_id[aw_head] : awid; b_rsp[pick] = OKAY; b_seq[pick] = seq; seq = seq + 1; b_at[pick] = cycle;
          early_done = 1;
        end
      end
      // -- B: finish a handshake, then put the next response on the wires --
      if (b_driving && bready) b_driving = 0;
      if (!b_driving) begin
        pick = pick_b();
        if (pick >= 0) begin
          if (p_pending[pick]) apply_posted(pick);
          b_driving = 1; bid <= b_id[pick]; bresp <= b_rsp[pick]; b_use[pick] = 0;
        end
      end
      bvalid <= b_driving;
      // -- AR: take a request while there is room --
      if (arvalid && arready) begin
        pick = free_r();
        if (pick >= 0) begin
          r_use[pick] = 1; r_id[pick] = arid; r_addr[pick] = araddr; r_len[pick] = arlen; r_size[pick] = arsize; r_burst[pick] = arburst;
          r_lock[pick] = arlock; r_beat[pick] = 0; r_seq[pick] = seq; seq = seq + 1; r_served[pick] = -1;
          r_at[pick] = cycle + latency_of(araddr, rd_latency);
          if (arlock && excl_on) begin
            mon_use[arid] = 1; mon_addr[arid] = araddr; mon_bytes[arid] = (1 << arsize) * (arlen + 1);
            $display("mem e%0d: exclusive read id=%0d at 0x%0h: monitor set", cycle, arid, araddr);
          end
        end
      end
      // -- R: finish a handshake, then put the next beat on the wires --
      if (r_driving && !rready && drop_hold) rdata <= rdata + 1;   // the broken twin: data not held
      if (r_driving && rready) begin
        r_driving = 0;
        if (r_beat[r_cur] > r_len[r_cur]) begin r_use[r_cur] = 0; r_cur = -1; end
        else if (interleave) r_cur = -1;
      end
      if (!r_driving) begin
        pick = (r_cur >= 0) ? r_cur : pick_r();
        if (pick >= 0) begin
          r_cur = pick; r_driving = 1; r_served[pick] = cycle;
          extra = r_beat[pick];
          rid <= r_id[pick];
          rdata <= read_word(beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra));
          rresp <= (beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra) >= err_above) ? SLVERR
                 : ((r_lock[pick] && excl_on) ? EXOKAY : OKAY);
          rlast <= (extra == r_len[pick]);
          r_beat[pick] = extra + 1;
        end
      end
      rvalid <= r_driving;
      awready <= (aw_count < N - 1);
      wready  <= (w_count < WQ - 2);
      arready <= 1;
    end
  end
endmodule
Read included file: axi_checker.sv
`timescale 1ns/1ns
// axi_checker.sv: the rules of an AXI4 interface, checked at every rising edge (read-only).
// Each broken rule is named with the channel and the edge where it was seen:
//   reset      a VALID is 1 while reset is active;
//   hold       a VALID dropped before its READY: the offer was withdrawn;
//   stable     a channel's payload changed while its offer waited;
//   known      a payload is x while its VALID is 1;
//   len        a FIXED or WRAP burst longer than 16 beats;
//   wrap       a WRAP burst whose length is not 2, 4, 8 or 16 beats or whose address is not aligned;
//   boundary   a burst that crosses a 4 KB boundary;
//   size       a transfer wider than the data bus;
//   strobe     a write strobe on a lane the beat does not address;
//   wlast      WLAST on the wrong beat (not AWLEN), or missing after it;
//   rlast      RLAST on the wrong beat of the oldest read with that ID, or missing after it;
//   border     BVALID before any outstanding write has its last beat, or before its AW;
//   bid, rid   a response ID with no outstanding request of that ID;
//   exokay     EXOKAY for a request that was not exclusive;
//   exclusive  an exclusive request whose bytes are not a power of two up to 128, or not aligned to them.
// The rules no checker can see on the wires (VALID must not wait for READY; same-ID responses
// in the order of their requests) are checked by the data the tasks compare (lessons P2.2, P2.10).
module axi_checker #(parameter int DATA_W = 32, parameter int ID_W = 4) (
  input logic              aclk,
  input logic              aresetn,
  input logic [ID_W-1:0]   awid,
  input logic [31:0]       awaddr,
  input logic [7:0]        awlen,
  input logic [2:0]        awsize,
  input logic [1:0]        awburst,
  input logic              awlock,
  input logic              awvalid,
  input logic              awready,
  input logic [DATA_W-1:0] wdata,
  input logic [DATA_W/8-1:0] wstrb,
  input logic              wlast,
  input logic              wvalid,
  input logic              wready,
  input logic [ID_W-1:0]   bid,
  input logic [1:0]        bresp,
  input logic              bvalid,
  input logic              bready,
  input logic [ID_W-1:0]   arid,
  input logic [31:0]       araddr,
  input logic [7:0]        arlen,
  input logic [2:0]        arsize,
  input logic [1:0]        arburst,
  input logic              arlock,
  input logic              arvalid,
  input logic              arready,
  input logic [ID_W-1:0]   rid,
  input logic [DATA_W-1:0] rdata,
  input logic [1:0]        rresp,
  input logic              rlast,
  input logic              rvalid,
  input logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int Q = 64;
  int cycle = -1, writes = 0, reads = 0, stalls = 0, broken = 0;
  logic [DATA_W-1:0] used;

  function void report(input string rule, input string what);
    broken++;
    $display("RULE %s broken at edge %0d: %s", rule, cycle, what);
  endfunction

  // Previous values of every channel, for hold and stable.
  logic p_awv = 0, p_awr = 0, p_wv = 0, p_wr = 0, p_bv = 0, p_br = 0, p_arv = 0, p_arr = 0, p_rv = 0, p_rr = 0;
  logic [31:0] p_awaddr, p_araddr;
  logic [7:0] p_awlen, p_arlen;
  logic [2:0] p_awsize, p_arsize;
  logic [1:0] p_awburst, p_arburst, p_bresp, p_rresp;
  logic [ID_W-1:0] p_awid, p_arid, p_bid, p_rid;
  logic [DATA_W-1:0] p_wdata, p_rdata;
  logic [BUS-1:0] p_wstrb;
  logic p_wlast, p_rlast, p_awlock, p_arlock;

  // Write requests in order (AXI4 write data follows the order of the addresses).
  int unsigned q_addr [0:Q-1];
  int q_len [0:Q-1];
  logic [2:0] q_size [0:Q-1];
  logic [1:0] q_burst [0:Q-1];
  int aw_n = 0;                 // requests accepted
  int wb_n = 0;                 // write bursts started
  int wb_done = 0;              // write bursts ended (WLAST seen)
  int w_beat = 0;               // beats so far in the current burst
  int b_n = 0;                  // responses given
  // Beats recorded for bursts that ran ahead of their AW: strobes and count, checked when AW arrives.
  logic [BUS-1:0] rec_strb [0:Q-1][0:255];
  int rec_beats [0:Q-1];
  logic rec_open [0:Q-1];
  // Outstanding requests per ID, and the read requests per ID in order.
  int aw_out [0:(1<<ID_W)-1], ar_out [0:(1<<ID_W)-1], aw_excl [0:(1<<ID_W)-1], ar_excl [0:(1<<ID_W)-1];
  int rq_len [0:(1<<ID_W)-1][0:15];
  int rq_head [0:(1<<ID_W)-1], rq_tail [0:(1<<ID_W)-1], r_beat [0:(1<<ID_W)-1];
  initial for (int i = 0; i < (1 << ID_W); i++) begin aw_out[i] = 0; ar_out[i] = 0; aw_excl[i] = 0; ar_excl[i] = 0; rq_head[i] = 0; rq_tail[i] = 0; r_beat[i] = 0; end
  initial for (int i = 0; i < Q; i++) begin rec_beats[i] = 0; rec_open[i] = 0; end

  function automatic bit pow2_le128(input int unsigned n);
    return (n == 1 || n == 2 || n == 4 || n == 8 || n == 16 || n == 32 || n == 64 || n == 128);
  endfunction

  task automatic check_request(input string ch, input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input logic lock);
    int unsigned bytes = (1 << size) * (len + 1);
    if ((burst == FIXED || burst == WRAP) && len > 15) report("len", $sformatf("%s: a %s burst of %0d beats (16 at most)", ch, burst_name(burst), len + 1));
    if (burst == WRAP && !(len == 1 || len == 3 || len == 7 || len == 15)) report("wrap", $sformatf("%s: a WRAP burst of %0d beats (2, 4, 8 or 16)", ch, len + 1));
    if (burst == WRAP && (addr % (1 << size)) != 0) report("wrap", $sformatf("%s: WRAP burst at 0x%0h is not aligned to its %0d-byte transfers", ch, addr, 1 << size));
    if (burst == 2'b11) report("len", $sformatf("%s: burst type 2'b11 is reserved", ch));
    if ((1 << size) > BUS) report("size", $sformatf("%s: %0d-byte transfers on a %0d-byte bus", ch, 1 << size, BUS));
    if (crosses_4k(addr, len, size, burst)) report("boundary", $sformatf("%s: burst at 0x%0h, %0d beats of %0d bytes, crosses a 4 KB boundary", ch, addr, len + 1, 1 << size));
    if (lock && (!pow2_le128(bytes) || (addr % bytes) != 0)) report("exclusive", $sformatf("%s: exclusive access of %0d bytes at 0x%0h (a power of two up to 128, aligned)", ch, bytes, addr));
  endtask

  task automatic check_strobe(input int k, input int n, input logic [BUS-1:0] strb);
    logic [63:0] allowed = beat_strb(q_addr[k % Q], q_len[k % Q], q_size[k % Q], q_burst[k % Q], n, BUS);
    if ((strb & ~allowed[BUS-1:0]) != 0)
      report("strobe", $sformatf("W beat %0d of write %0d: strobe %b on lanes outside %b", n, k, strb, allowed[BUS-1:0]));
  endtask

  always @(posedge aclk) begin
    cycle++;
    if (!aresetn) begin
      if (awvalid === 1 || wvalid === 1 || arvalid === 1) report("reset", "a manager VALID is 1 during reset");
      if (bvalid === 1 || rvalid === 1) report("reset", "a subordinate VALID is 1 during reset");
    end else begin
      // hold, stable and known, per channel
      if (p_awv && !p_awr && awvalid !== 1) report("hold", "AWVALID dropped before AWREADY");
      if (p_awv && !p_awr && awvalid === 1 && (awaddr !== p_awaddr || awlen !== p_awlen || awsize !== p_awsize || awburst !== p_awburst || awid !== p_awid || awlock !== p_awlock)) report("stable", "AW payload changed while the request waited");
      if (p_wv && !p_wr && wvalid !== 1) report("hold", "WVALID dropped before WREADY");
      if (p_wv && !p_wr && wvalid === 1 && (wdata !== p_wdata || wstrb !== p_wstrb || wlast !== p_wlast)) report("stable", "W payload changed while the beat waited");
      if (p_bv && !p_br && bvalid !== 1) report("hold", "BVALID dropped before BREADY");
      if (p_bv && !p_br && bvalid === 1 && (bresp !== p_bresp || bid !== p_bid)) report("stable", "B payload changed while the response waited");
      if (p_arv && !p_arr && arvalid !== 1) report("hold", "ARVALID dropped before ARREADY");
      if (p_arv && !p_arr && arvalid === 1 && (araddr !== p_araddr || arlen !== p_arlen || arsize !== p_arsize || arburst !== p_arburst || arid !== p_arid || arlock !== p_arlock)) report("stable", "AR payload changed while the request waited");
      if (p_rv && !p_rr && rvalid !== 1) report("hold", "RVALID dropped before RREADY");
      if (p_rv && !p_rr && rvalid === 1 && (rdata !== p_rdata || rresp !== p_rresp || rid !== p_rid || rlast !== p_rlast)) report("stable", "R payload changed while the beat waited");
      if (awvalid === 1 && ($isunknown(awaddr) || $isunknown(awlen) || $isunknown(awsize) || $isunknown(awburst) || $isunknown(awid))) report("known", "AW payload is x while AWVALID is 1");
      if (wvalid === 1 && ($isunknown(wstrb) || $isunknown(wlast))) report("known", "W strobe or last is x while WVALID is 1");
      else if (wvalid === 1) begin
        used = '0;
        for (int l = 0; l < BUS; l++) if (wstrb[l] === 1) used[8*l +: 8] = 8'hff;
        if ($isunknown(wdata & used)) report("known", "W data is x on a strobed lane while WVALID is 1");
      end
      if (arvalid === 1 && ($isunknown(araddr) || $isunknown(arlen) || $isunknown(arsize) || $isunknown(arburst) || $isunknown(arid))) report("known", "AR payload is x while ARVALID is 1");
      if (bvalid === 1 && ($isunknown(bresp) || $isunknown(bid))) report("known", "B payload is x while BVALID is 1");
      if (rvalid === 1 && ($isunknown(rresp) || $isunknown(rid) || $isunknown(rlast))) report("known", "R payload is x while RVALID is 1");
      if ((awvalid === 1 && awready !== 1) || (wvalid === 1 && wready !== 1) || (arvalid === 1 && arready !== 1) ||
          (bvalid === 1 && bready !== 1) || (rvalid === 1 && rready !== 1)) stalls++;
      // AW accepted
      if (awvalid === 1 && awready === 1) begin
        check_request("AW", awaddr, awlen, awsize, awburst, awlock);
        q_addr[aw_n % Q] = awaddr; q_len[aw_n % Q] = awlen; q_size[aw_n % Q] = awsize; q_burst[aw_n % Q] = awburst;
        aw_out[awid]++; if (awlock) aw_excl[awid]++;
        // beats of this write that arrived before its address: check them now
        if (rec_beats[aw_n % Q] > 0) begin
          for (int n = 0; n < rec_beats[aw_n % Q]; n++) check_strobe(aw_n, n, rec_strb[aw_n % Q][n]);
          if (!rec_open[aw_n % Q] && rec_beats[aw_n % Q] != awlen + 1)
            report("wlast", $sformatf("write %0d sent %0d beats before its AW said AWLEN=%0d", aw_n, rec_beats[aw_n % Q], awlen));
          if (!rec_open[aw_n % Q]) rec_beats[aw_n % Q] = 0;
        end
        aw_n++;
      end
      // W beat accepted
      if (wvalid === 1 && wready === 1) begin
        if (w_beat == 0) begin wb_n++; rec_beats[(wb_n - 1) % Q] = 0; rec_open[(wb_n - 1) % Q] = 1; end
        if (wb_n <= aw_n) begin
          check_strobe(wb_n - 1, w_beat, wstrb);
          if (wlast === 1 && w_beat != q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("WLAST on beat %0d of write %0d, AWLEN=%0d", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
          if (wlast !== 1 && w_beat == q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("beat %0d of write %0d is AWLEN=%0d but WLAST is 0", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
        end else begin
          rec_strb[(wb_n - 1) % Q][w_beat] = wstrb;
        end
        rec_beats[(wb_n - 1) % Q] = w_beat + 1;
        w_beat++;
        if (wlast === 1) begin w_beat = 0; wb_done++; rec_open[(wb_n - 1) % Q] = 0; if (wb_n <= aw_n) rec_beats[(wb_n - 1) % Q] = 0; end
      end
      // B offered or accepted
      if (bvalid === 1 && !p_bv) begin
        if (b_n >= aw_n && b_n >= wb_done) report("border", "BVALID with no write to answer: neither an AW nor a WLAST is outstanding");
        else if (b_n >= wb_done) report("border", "BVALID before the last beat of the write it answers");
        else if (b_n >= aw_n) report("border", "BVALID before the AW of the write it answers was accepted");
      end
      if (bvalid === 1 && bready === 1) begin
        if (aw_out[bid] == 0) report("bid", $sformatf("B with id %0d, which has no outstanding write", bid));
        else begin
          aw_out[bid]--; writes++;
          if (bresp === EXOKAY && aw_excl[bid] == 0) report("exokay", $sformatf("EXOKAY for write id %0d, which was not exclusive", bid));
          if (aw_excl[bid] > 0 && aw_excl[bid] > aw_out[bid]) aw_excl[bid] = aw_out[bid];
        end
        b_n++;
      end
      // AR accepted
      if (arvalid === 1 && arready === 1) begin
        check_request("AR", araddr, arlen, arsize, arburst, arlock);
        rq_len[arid][rq_tail[arid]] = arlen; rq_tail[arid] = (rq_tail[arid] + 1) % 16;
        ar_out[arid]++; if (arlock) ar_excl[arid]++;
      end
      // R beat accepted
      if (rvalid === 1 && rready === 1) begin
        if (ar_out[rid] == 0) report("rid", $sformatf("R with id %0d, which has no outstanding read", rid));
        else begin
          if (rlast === 1 && r_beat[rid] != rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("RLAST on beat %0d of the oldest read with id %0d, whose ARLEN is %0d", r_beat[rid], rid, rq_len[rid][rq_head[rid]]));
          if (rlast !== 1 && r_beat[rid] == rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("beat %0d of the oldest read with id %0d is its ARLEN but RLAST is 0", r_beat[rid], rid));
          if (rresp === EXOKAY && ar_excl[rid] == 0) report("exokay", $sformatf("EXOKAY for read id %0d, which was not exclusive", rid));
          r_beat[rid]++;
          if (rlast === 1) begin
            r_beat[rid] = 0; rq_head[rid] = (rq_head[rid] + 1) % 16; ar_out[rid]--; reads++;
            if (ar_excl[rid] > ar_out[rid]) ar_excl[rid] = ar_out[rid];
          end
        end
      end
    end
    p_awv = (awvalid === 1); p_awr = (awready === 1); p_wv = (wvalid === 1); p_wr = (wready === 1);
    p_bv = (bvalid === 1); p_br = (bready === 1); p_arv = (arvalid === 1); p_arr = (arready === 1);
    p_rv = (rvalid === 1); p_rr = (rready === 1);
    p_awaddr = awaddr; p_awlen = awlen; p_awsize = awsize; p_awburst = awburst; p_awid = awid; p_awlock = awlock;
    p_wdata = wdata; p_wstrb = wstrb; p_wlast = wlast; p_bresp = bresp; p_bid = bid;
    p_araddr = araddr; p_arlen = arlen; p_arsize = arsize; p_arburst = arburst; p_arid = arid; p_arlock = arlock;
    p_rdata = rdata; p_rresp = rresp; p_rid = rid; p_rlast = rlast;
  end
  final $display("checker: %0d writes, %0d reads, %0d stalled edges, %0d rules broken", writes, reads, stalls, broken);
endmodule
Read included file: axi_tasks.svh
// axi_tasks.svh: the manager side of the bench, as tasks for the stimulus (read-only).
// Data for a write burst goes in wd[0], wd[1], ... (one entry per beat, the lowest byte at the
// lowest address); the data of a read comes back in rd[0], rd[1], ... with its responses in rr[].
// Every task prints the beat log: one line per handshake, with the edge where it happened.
// `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge aclk) cycle = cycle + 1;

logic [63:0] wd [0:255];
logic [63:0] rd [0:255];
logic [1:0]  rr [0:255];
logic [63:0] rdq [0:15][0:255];     // read data per ID, for reads collected out of order
logic [1:0]  rrq [0:15][0:255];
int          rdn [0:15];            // beats received per ID
logic [1:0]  last_bresp = 0;
int          last_beats = 0;
// What the task is driving right now, for the waveform scenes: the address and lanes of the beat.
int unsigned beat_a = 0;
logic [7:0]  beat_m = 0;
// quiet = 1 silences the beat log (a predict item can then ask for a dump line instead).
bit          quiet = 0;
// Strobe override: when strb_force is 1, every write beat uses strb_val as it is.
bit          strb_force = 0;
logic [7:0]  strb_val = 8'hff;
// Outstanding read requests per ID, so the tasks know the lanes of the beats that come back.
int unsigned arq_addr [0:15][0:7];
int          arq_len [0:15][0:7];
logic [2:0]  arq_size [0:15][0:7];
logic [1:0]  arq_burst [0:15][0:7];
int          arq_head [0:15], arq_tail [0:15];
initial for (int i = 0; i < 16; i++) begin arq_head[i] = 0; arq_tail[i] = 0; rdn[i] = 0; end
// READY patterns for the response channels: bit (cycle % 16) of the pattern drives the signal.
bit          rpat_on = 0, bpat_on = 0;
logic [15:0] rpat = 16'hffff, bpat = 16'hffff;
always @(posedge aclk) begin
  #1;
  if (rpat_on) rready = rpat[cycle % 16];
  if (bpat_on) bready = bpat[cycle % 16];
end

// A text waveform for the lesson's trace blocks: with watch = 1, one line per rising edge with the
// values sampled at that edge (cycle k of a trace is what edge k sees).
bit watch = 0;
int wave_edge = -1;
always @(posedge aclk) begin
  wave_edge = wave_edge + 1;
  if (watch) $display("wave e%0d: aw=%b%b w=%b%b b=%b%b ar=%b%b r=%b%b awaddr=%h wdata=%h wstrb=%b wlast=%b bid=%h bresp=%b araddr=%h rid=%h rdata=%h rresp=%b rlast=%b",
                      wave_edge, awvalid, awready, wvalid, wready, bvalid, bready, arvalid, arready, rvalid, rready,
                      awaddr, wdata, wstrb, wlast, bid, bresp, araddr, rid, rdata, rresp, rlast);
end

// Drive RREADY (ch = 0) or BREADY (ch = 1) from a 16-bit pattern; 16'hffff restores always ready.
task automatic ready_pattern(input int ch, input logic [15:0] pat);
  if (ch == 0) begin rpat = pat; rpat_on = 1; rready = pat[cycle % 16]; end
  else begin bpat = pat; bpat_on = 1; bready = pat[cycle % 16]; end
endtask

// The write address channel: offer the request and hold it until it is taken.
task automatic aw_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  awid = id; awaddr = addr; awlen = len[7:0]; awsize = size; awburst = burst; awlock = lock; awvalid = 1;
  do @(posedge aclk); while (!awready);
  #1 if (!quiet) $display("e%0d AW id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  awvalid = 0; awaddr = 'x; awlen = 'x; awsize = 'x; awburst = 'x; awid = 'x; awlock = 0;
endtask

// The write data channel: the beats of one burst from wd[first..], each placed in its lanes.
task automatic w_burst(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input int first = 0);
  logic [15:0] lanes;
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    beat_a = beat_addr(addr, len, size, burst, n);
    beat_m = strb_force ? strb_val : beat_strb(addr, len, size, burst, n, BUS_BYTES);
    wdata = wd[first + n] << (8 * lanes[7:0]);
    wstrb = beat_m[BUS_BYTES-1:0];
    wlast = (n == len);
    wvalid = 1;
    do @(posedge aclk); while (!wready);
    #1 if (!quiet) $display("e%0d W  beat %0d data=0x%0h strb=%b last=%0d  addr 0x%0h lanes %0d-%0d", cycle, n, wdata, wstrb, wlast, beat_a, lanes[7:0], lanes[15:8]);
  end
  wvalid = 0; wdata = 'x; wstrb = 'x; wlast = 0; beat_m = 0;
endtask

// Wait for the write response of one transaction with this ID.
task automatic b_wait(input logic [ID_W-1:0] id);
  do @(posedge aclk); while (!(bvalid && bready && bid == id));
  last_bresp = bresp;                       // sampled at the edge, before the subordinate moves on
  #1 if (!quiet) $display("e%0d B  id=%0d %0s", cycle, id, resp_name(last_bresp));
endtask

// A complete write. order 0 offers the address, then the first beat one cycle later whether or
// not the address has been taken yet (a manager must never make WVALID wait for AWREADY); 1 offers
// the beats first and the address after beat 0; 2 offers the address and beat 0 in the same cycle.
// Returns after B, with the response in last_bresp.
task automatic axi_write(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                         input logic [1:0] burst, input int order = 0, input logic lock = 0);
  case (order)
    1: fork
         w_burst(addr, len, size, burst);
         begin @(posedge aclk); #1 aw_issue(id, addr, len, size, burst, lock); end
       join
    2: fork
         aw_issue(id, addr, len, size, burst, lock);
         w_burst(addr, len, size, burst);
       join
    default: fork
         aw_issue(id, addr, len, size, burst, lock);
         begin @(posedge aclk); #1 w_burst(addr, len, size, burst); end
       join
  endcase
  b_wait(id);
endtask

// The read address channel: offer the request and remember it for the beats that come back.
task automatic ar_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  arq_addr[id][arq_tail[id]] = addr; arq_len[id][arq_tail[id]] = len; arq_size[id][arq_tail[id]] = size;
  arq_burst[id][arq_tail[id]] = burst; arq_tail[id] = (arq_tail[id] + 1) % 8;
  arid = id; araddr = addr; arlen = len[7:0]; arsize = size; arburst = burst; arlock = lock; arvalid = 1;
  do @(posedge aclk); while (!arready);
  #1 if (!quiet) $display("e%0d AR id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  arvalid = 0; araddr = 'x; arlen = 'x; arsize = 'x; arburst = 'x; arid = 'x; arlock = 0;
endtask

// Collect read beats until n transactions have ended (their RLAST). Each beat lands in rdq[rid][k]
// with only the bytes of the transfer (lane-shifted down), and rd[] holds the last transaction.
task automatic r_collect(input int n);
  int done = 0, h;
  logic [15:0] lanes;
  logic [63:0] bytes;
  logic [ID_W-1:0] id;
  logic [DATA_W-1:0] data;
  logic [1:0] resp;
  logic last;
  while (done < n) begin
    do @(posedge aclk); while (!(rvalid && rready));
    id = rid; data = rdata; resp = rresp; last = rlast;   // sampled at the edge, before the subordinate moves on
    h = arq_head[id];
    lanes = beat_lanes(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    beat_a = beat_addr(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id]);
    beat_m = beat_strb(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    bytes = (data >> (8 * lanes[7:0])) & ((64'h1 << (8 * (lanes[15:8] - lanes[7:0] + 1))) - 1);
    rdq[id][rdn[id]] = bytes; rrq[id][rdn[id]] = resp;
    #1 if (!quiet) $display("e%0d R  id=%0d beat %0d data=0x%0h %0s%0s  addr 0x%0h lanes %0d-%0d", cycle, id, rdn[id], bytes, resp_name(resp),
                last ? " last" : "", beat_a, lanes[7:0], lanes[15:8]);
    rdn[id] = rdn[id] + 1;
    if (last) begin
      for (int k = 0; k < rdn[id]; k++) begin rd[k] = rdq[id][k]; rr[k] = rrq[id][k]; end
      last_beats = rdn[id]; rdn[id] = 0; arq_head[id] = (h + 1) % 8; done = done + 1;
    end
  end
  beat_m = 0;
endtask

// A complete read: AR, then every beat, into rd[] and rr[].
task automatic axi_read(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  ar_issue(id, addr, len, size, burst, lock);
  r_collect(1);
endtask

// The table of a burst before it runs: the address, lanes and strobe of every beat.
task automatic beat_table(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst);
  logic [15:0] lanes;
  logic [63:0] s;
  int unsigned a;
  $display("burst at 0x%0h: %0d beat%0s of %0d byte%0s, %0s, bus %0d bytes", addr, len + 1, len ? "s" : "", 1 << size, size ? "s" : "",
           burst_name(burst), BUS_BYTES);
  $display("  beat  address  lanes  strobe");
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    s = beat_strb(addr, len, size, burst, n, BUS_BYTES);
    a = beat_addr(addr, len, size, burst, n);
    $display("  %4d  0x%05h  %0d-%0d    %b", n, a[19:0], lanes[7:0], lanes[15:8], s[BUS_BYTES-1:0]);
  end
  if (crosses_4k(addr, len, size, burst)) $display("  this burst crosses a 4 KB boundary");
endtask

// One byte of the memory that owns an address (the fabric's second memory above 0x8000).
function automatic logic [7:0] mem_byte(input int unsigned a);
`ifdef AXI_MEM1
  if (a >= 32'h8000) return `AXI_MEM1.mem[a];
`endif
  return `AXI_MEM.mem[a];
endfunction
task automatic set_byte(input int unsigned a, input logic [7:0] v);
`ifdef AXI_MEM1
  if (a >= 32'h8000) `AXI_MEM1.mem[a] = v;
  else `AXI_MEM.mem[a] = v;
`else
  `AXI_MEM.mem[a] = v;
`endif
endtask

// A big-endian manager's view of a value: the most significant byte goes to the lowest address.
// Byte-invariant lanes never swap anything; the manager does, before the value reaches wd[].
function automatic logic [15:0] be16(input logic [15:0] v);
  return {v[7:0], v[15:8]};
endfunction
function automatic logic [31:0] be32(input logic [31:0] v);
  return {v[7:0], v[15:8], v[23:16], v[31:24]};
endfunction

// The memory, n bytes from addr, one bus word per group.
task automatic dump(input int unsigned addr, input int n);
  string line;
  int unsigned a = (addr / 16) * 16;
  while (a < addr + n) begin
    line = $sformatf("0x%05h ", a[19:0]);
    for (int i = 0; i < 16; i++) begin
      if (i % BUS_BYTES == 0) line = {line, " "};
      line = {line, $sformatf(" %02h", mem_byte(a + i))};
    end
    $display("%s", line);
    a = a + 16;
  end
endtask

// Fill n bytes from addr with first, first+1, ... so untouched bytes stay recognisable.
task automatic mem_fill(input int unsigned addr, input int n, input logic [7:0] first = 8'h00);
  for (int i = 0; i < n; i++) set_byte(addr + i, first + i[7:0]);
endtask

// Drive nothing for n cycles.
task automatic idle(input int n);
  repeat (n) @(posedge aclk);
  #1;
endtask
Read included file: axi_down.sv
`timescale 1ns/1ns
// axi_down.sv: a downsizer from a 64-bit manager port to a 32-bit subordinate port (read-only).
// One write and one read at a time, INCR bursts. A full-width request (AxSIZE = 3, eight bytes per
// beat) cannot fit the narrow bus, so it is modified whatever its AxCACHE: AxSIZE becomes 2, AxLEN
// becomes 2 x (AxLEN + 1) - 1, the address is kept, and every write beat leaves as two halves,
// lanes 0-3 first. Two read beats are merged into one, and the merged beat carries the worse of
// the two responses. A narrow request (AxSIZE 2 or less) already fits and passes unchanged, with
// its data moved between the half of the 64-bit word its address names and the 32-bit lanes.
// Limits: a full-width request must start 8-byte aligned (an unaligned start would send its lower
// lanes to the wrong word) and have AxLEN up to 127; WRAP and FIXED bursts are not converted.
// Switches: trace prints every conversion; no_merge_resp (the broken twin) gives a merged read
// beat the response of its first half only.
module axi_down #(parameter int ID_W = 4) (
  input  logic            aclk,
  input  logic            aresetn,
  // the 64-bit manager side
  input  logic [ID_W-1:0] awid,
  input  logic [31:0]     awaddr,
  input  logic [7:0]      awlen,
  input  logic [2:0]      awsize,
  input  logic [1:0]      awburst,
  input  logic            awlock,
  input  logic            awvalid,
  output logic            awready,
  input  logic [63:0]     wdata,
  input  logic [7:0]      wstrb,
  input  logic            wlast,
  input  logic            wvalid,
  output logic            wready,
  output logic [ID_W-1:0] bid,
  output logic [1:0]      bresp,
  output logic            bvalid,
  input  logic            bready,
  input  logic [ID_W-1:0] arid,
  input  logic [31:0]     araddr,
  input  logic [7:0]      arlen,
  input  logic [2:0]      arsize,
  input  logic [1:0]      arburst,
  input  logic            arlock,
  input  logic            arvalid,
  output logic            arready,
  output logic [ID_W-1:0] rid,
  output logic [63:0]     rdata,
  output logic [1:0]      rresp,
  output logic            rlast,
  output logic            rvalid,
  input  logic            rready,
  // the 32-bit subordinate side
  output logic [ID_W-1:0] s_awid,
  output logic [31:0]     s_awaddr,
  output logic [7:0]      s_awlen,
  output logic [2:0]      s_awsize,
  output logic [1:0]      s_awburst,
  output logic            s_awlock,
  output logic            s_awvalid,
  input  logic            s_awready,
  output logic [31:0]     s_wdata,
  output logic [3:0]      s_wstrb,
  output logic            s_wlast,
  output logic            s_wvalid,
  input  logic            s_wready,
  input  logic [ID_W-1:0] s_bid,
  input  logic [1:0]      s_bresp,
  input  logic            s_bvalid,
  output logic            s_bready,
  output logic [ID_W-1:0] s_arid,
  output logic [31:0]     s_araddr,
  output logic [7:0]      s_arlen,
  output logic [2:0]      s_arsize,
  output logic [1:0]      s_arburst,
  output logic            s_arlock,
  output logic            s_arvalid,
  input  logic            s_arready,
  input  logic [ID_W-1:0] s_rid,
  input  logic [31:0]     s_rdata,
  input  logic [1:0]      s_rresp,
  input  logic            s_rlast,
  input  logic            s_rvalid,
  output logic            s_rready
);
  import axi_pkg::*;
  bit trace = 0, no_merge_resp = 0;
  int cycle = -1;
  function automatic logic [1:0] worse(input logic [1:0] a, input logic [1:0] b);
    if (a == DECERR || b == DECERR) return DECERR;
    if (a == SLVERR || b == SLVERR) return SLVERR;
    return a;
  endfunction

  // ---- writes ----
  logic        w_on = 0, w_full = 0, w_half = 0, w_hold = 0;
  logic [31:0] w_addr;
  int          w_len = 0, w_beat = 0;
  logic [2:0]  w_size;
  logic [1:0]  w_burst;
  logic [63:0] w_d;
  logic [7:0]  w_s;
  logic        w_l;
  logic        aw_sent = 0;
  assign awready  = !w_on;
  assign wready   = w_on && !w_hold;
  assign bid      = s_bid;
  assign bresp    = s_bresp;
  assign bvalid   = s_bvalid;
  assign s_bready = bready;
  initial begin s_awvalid = 0; s_wvalid = 0; s_arvalid = 0; rvalid = 0; end

  // ---- reads ----
  logic        r_on = 0, r_full = 0, r_have_low = 0;
  logic [31:0] r_addr;
  int          r_len = 0, r_beat = 0;
  logic [2:0]  r_size;
  logic [1:0]  r_burst;
  logic [31:0] r_low;
  logic [1:0]  r_low_resp;
  assign arready  = !r_on;
  assign s_rready = r_on && (!rvalid || rready);

  int unsigned a;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      w_on <= 0; w_hold <= 0; w_half <= 0; aw_sent <= 0; s_awvalid <= 0; s_wvalid <= 0;
      r_on <= 0; r_have_low <= 0; s_arvalid <= 0; rvalid <= 0;
    end else begin
      // ---------------- writes ----------------
      if (awvalid && awready) begin
        w_on <= 1; w_full <= (awsize == 3); w_addr <= awaddr; w_len <= awlen; w_size <= awsize; w_burst <= awburst; w_beat <= 0;
        s_awvalid <= 1; s_awid <= awid; s_awaddr <= awaddr; s_awburst <= awburst; s_awlock <= awlock;
        s_awsize <= (awsize == 3) ? 3'd2 : awsize;
        s_awlen  <= (awsize == 3) ? 8'(2 * (int'(awlen) + 1) - 1) : awlen;
        if (trace) begin
          if (awsize == 3) $display("down e%0d: AW 0x%0h size 3 len %0d -> size 2 len %0d", cycle, awaddr, awlen, 2 * (int'(awlen) + 1) - 1);
          else $display("down e%0d: AW 0x%0h size %0d len %0d fits: passed unchanged", cycle, awaddr, awsize, awlen);
        end
      end
      if (s_awvalid && s_awready) s_awvalid <= 0;
      // a beat from the manager: hold it, then send one or two 32-bit beats
      if (s_wvalid && s_wready) begin
        if (w_full && !w_half) begin                     // the lower half went; now the upper half
          w_half <= 1; s_wdata <= w_d[63:32]; s_wstrb <= w_s[7:4]; s_wlast <= w_l;
        end else begin
          s_wvalid <= 0; w_hold <= 0; w_half <= 0;
        end
      end
      if (wvalid && wready) begin
        w_d <= wdata; w_s <= wstrb; w_l <= wlast; w_hold <= 1; s_wvalid <= 1; w_half <= 0;
        if (w_full) begin
          s_wdata <= wdata[31:0]; s_wstrb <= wstrb[3:0]; s_wlast <= 0;
          if (trace) $display("down e%0d: W beat %0d split: lanes 0-3 now, lanes 4-7 next", cycle, w_beat);
        end else begin
          a = beat_addr(w_addr, w_len, w_size, w_burst, w_beat);
          s_wdata <= a[2] ? wdata[63:32] : wdata[31:0]; s_wstrb <= a[2] ? wstrb[7:4] : wstrb[3:0]; s_wlast <= wlast;
        end
        w_beat <= w_beat + 1;
      end
      if (bvalid && bready) w_on <= 0;
      // ---------------- reads ----------------
      if (arvalid && arready) begin
        r_on <= 1; r_full <= (arsize == 3); r_addr <= araddr; r_len <= arlen; r_size <= arsize; r_burst <= arburst; r_beat <= 0; r_have_low <= 0;
        s_arvalid <= 1; s_arid <= arid; s_araddr <= araddr; s_arburst <= arburst; s_arlock <= arlock;
        s_arsize <= (arsize == 3) ? 3'd2 : arsize;
        s_arlen  <= (arsize == 3) ? 8'(2 * (int'(arlen) + 1) - 1) : arlen;
        if (trace) begin
          if (arsize == 3) $display("down e%0d: AR 0x%0h size 3 len %0d -> size 2 len %0d", cycle, araddr, arlen, 2 * (int'(arlen) + 1) - 1);
          else $display("down e%0d: AR 0x%0h size %0d len %0d fits: passed unchanged", cycle, araddr, arsize, arlen);
        end
      end
      if (s_arvalid && s_arready) s_arvalid <= 0;
      if (rvalid && rready) begin
        rvalid <= 0;
        if (rlast) r_on <= 0;
      end
      if (s_rvalid && s_rready) begin
        if (r_full && !r_have_low) begin
          r_low <= s_rdata; r_low_resp <= s_rresp; r_have_low <= 1;
        end else if (r_full) begin
          rvalid <= 1; rid <= s_rid; rdata <= {s_rdata, r_low}; rlast <= s_rlast; r_have_low <= 0;
          rresp <= no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp);
          if (trace) $display("down e%0d: R beat %0d merged from two halves: %0s + %0s -> %0s", cycle, r_beat, resp_name(r_low_resp), resp_name(s_rresp),
                              resp_name(no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp)));
          r_beat <= r_beat + 1;
        end else begin
          a = beat_addr(r_addr, r_len, r_size, r_burst, r_beat);
          rvalid <= 1; rid <= s_rid; rdata <= a[2] ? {s_rdata, 32'h0} : {32'h0, s_rdata}; rresp <= s_rresp; rlast <= s_rlast;
          r_beat <= r_beat + 1;
        end
      end
    end
  end
endmodule

Check Yourself

Predict the outputA 64-bit manager reads four 8-byte beats from 0x300 through the downsizer. A monitor records the request the 32-bit memory takes and counts the beats it sends. What does it print?
`timescale 1ns/1ps
module tb;
  import axi_pkg::*;
  localparam int DATA_W = 64, ID_W = 4, BUS_BYTES = DATA_W / 8;
  logic aclk = 0, aresetn = 0;
  always #5 aclk = ~aclk;                 // rising edges at 5, 15, 25, ...
  logic [ID_W-1:0]   awid = 0, bid, arid = 0, rid;
  logic [31:0]       awaddr = 0, araddr = 0;
  logic [7:0]        awlen = 0, arlen = 0;
  logic [2:0]        awsize = 0, arsize = 0;
  logic [1:0]        awburst = 0, arburst = 0, bresp, rresp;
  logic              awlock = 0, arlock = 0;
  logic [3:0]        awcache = 0, arcache = 0;
  logic [2:0]        awprot = 0, arprot = 0;
  logic              awvalid = 0, awready, wvalid = 0, wready, wlast = 0, bvalid, bready = 1;
  logic              arvalid = 0, arready, rvalid, rlast, rready = 1;
  logic [DATA_W-1:0] wdata = 0, rdata;
  logic [DATA_W/8-1:0] wstrb = 0;
  // The downsizer (axi_down.sv) between the 64-bit manager and a 32-bit memory.
  logic [ID_W-1:0] s_awid, s_bid, s_arid, s_rid;
  logic [31:0]     s_awaddr, s_araddr, s_wdata, s_rdata;
  logic [7:0]      s_awlen, s_arlen;
  logic [2:0]      s_awsize, s_arsize;
  logic [1:0]      s_awburst, s_arburst, s_bresp, s_rresp;
  logic [3:0]      s_wstrb;
  logic            s_awlock, s_arlock, s_awvalid, s_awready, s_wvalid, s_wready, s_wlast, s_bvalid, s_bready;
  logic            s_arvalid, s_arready, s_rvalid, s_rready, s_rlast;
  axi_down #(.ID_W(ID_W)) dn (.aclk(aclk), .aresetn(aresetn), .awid(awid), .awaddr(awaddr), .awlen(awlen), .awsize(awsize), .awburst(awburst), .awlock(awlock), .awvalid(awvalid), .awready(awready), .wdata(wdata), .wstrb(wstrb), .wlast(wlast), .wvalid(wvalid), .wready(wready), .bid(bid), .bresp(bresp), .bvalid(bvalid), .bready(bready), .arid(arid), .araddr(araddr), .arlen(arlen), .arsize(arsize), .arburst(arburst), .arlock(arlock), .arvalid(arvalid), .arready(arready), .rid(rid), .rdata(rdata), .rresp(rresp), .rlast(rlast), .rvalid(rvalid), .rready(rready), .s_awid(s_awid), .s_awaddr(s_awaddr), .s_awlen(s_awlen), .s_awsize(s_awsize), .s_awburst(s_awburst), .s_awlock(s_awlock), .s_awvalid(s_awvalid), .s_awready(s_awready), .s_wdata(s_wdata), .s_wstrb(s_wstrb), .s_wlast(s_wlast), .s_wvalid(s_wvalid), .s_wready(s_wready), .s_bid(s_bid), .s_bresp(s_bresp), .s_bvalid(s_bvalid), .s_bready(s_bready), .s_arid(s_arid), .s_araddr(s_araddr), .s_arlen(s_arlen), .s_arsize(s_arsize), .s_arburst(s_arburst), .s_arlock(s_arlock), .s_arvalid(s_arvalid), .s_arready(s_arready), .s_rid(s_rid), .s_rdata(s_rdata), .s_rresp(s_rresp), .s_rlast(s_rlast), .s_rvalid(s_rvalid), .s_rready(s_rready));
  axi_mem #(.DATA_W(32), .ID_W(ID_W)) mem (.aclk(aclk), .aresetn(aresetn), .awid(s_awid), .awaddr(s_awaddr), .awlen(s_awlen), .awsize(s_awsize), .awburst(s_awburst), .awlock(s_awlock), .awvalid(s_awvalid), .awready(s_awready), .wdata(s_wdata), .wstrb(s_wstrb), .wlast(s_wlast), .wvalid(s_wvalid), .wready(s_wready), .bid(s_bid), .bresp(s_bresp), .bvalid(s_bvalid), .bready(s_bready), .arid(s_arid), .araddr(s_araddr), .arlen(s_arlen), .arsize(s_arsize), .arburst(s_arburst), .arlock(s_arlock), .arvalid(s_arvalid), .arready(s_arready), .rid(s_rid), .rdata(s_rdata), .rresp(s_rresp), .rlast(s_rlast), .rvalid(s_rvalid), .rready(s_rready), .awcache(4'b0), .awprot(3'b0), .arcache(4'b0), .arprot(3'b0));
  `define AXI_MEM mem
  // no checker in this bench: the only lines are the stimulus's own
  `include "axi_tasks.svh"
  int s_len = -1, s_size = -1, s_beats = 0;
  always @(posedge aclk) begin
    if (s_arvalid && s_arready) begin s_len = s_arlen; s_size = s_arsize; end
    if (s_rvalid && s_rready) s_beats++;
  end
  initial begin

    repeat (2) @(posedge aclk); #1 aresetn = 1;   // reset released after edge 1
    @(posedge aclk); #1;                          // the first request may start after edge 2
    quiet = 1;
    axi_read(1, 32'h0300, 3, 3, INCR);
    $display("the memory saw ARLEN %0d and ARSIZE %0d, and sent %0d beats", s_len, s_size, s_beats);
    repeat (3) @(posedge aclk);
    $finish;
  end
endmodule
Read included file: axi_pkg.sv
`timescale 1ns/1ns
// axi_pkg.sv: the arithmetic of a burst (read-only).
// Every transfer n of a burst has an address and a set of byte lanes, computed from the start
// address, the burst length, the transfer size and the burst type exactly as the AXI specification
// defines them. The memory, the manager tasks and the checker all use these functions, so they
// never disagree about where a byte lands.
package axi_pkg;
  localparam logic [1:0] FIXED = 2'b00, INCR = 2'b01, WRAP = 2'b10;
  localparam logic [1:0] OKAY = 2'b00, EXOKAY = 2'b01, SLVERR = 2'b10, DECERR = 2'b11;

  function automatic string burst_name(input logic [1:0] b);
    case (b) FIXED: return "FIXED"; INCR: return "INCR"; WRAP: return "WRAP"; default: return "RESERVED"; endcase
  endfunction
  function automatic string resp_name(input logic [1:0] r);
    case (r) OKAY: return "OKAY"; EXOKAY: return "EXOKAY"; SLVERR: return "SLVERR"; default: return "DECERR"; endcase
  endfunction

  // Bytes in one transfer: 1, 2, 4, ... 128.
  function automatic int bytes_of(input logic [2:0] size);
    return 1 << size;
  endfunction

  // The address of transfer n (n counts from 0).
  //   transfer 0 uses the start address as given, aligned or not;
  //   later transfers use the start address aligned down to the transfer size, plus n transfers;
  //   a WRAP burst returns to its wrap boundary (the start aligned down to the whole burst) when
  //   it reaches the end of that window; a FIXED burst repeats the start address.
  function automatic int unsigned beat_addr(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n);
    int unsigned nb = 1 << size;
    int unsigned aligned = (start / nb) * nb;
    int unsigned window = nb * (len + 1);
    int unsigned boundary = (start / window) * window;
    int unsigned a;
    if (burst == FIXED || n == 0) return start;
    a = aligned + n * nb;
    // Unsigned offset also works when the window ends at 2**32.
    if (burst == WRAP && (a - boundary) >= window) a = a - window;
    return a;
  endfunction

  // The byte lanes transfer n uses on a bus of bus_bytes bytes, packed as {upper, lower}.
  // Transfer 0 of an unaligned burst (and every transfer of a FIXED burst) uses only the lanes from
  // its address up to the end of its aligned transfer; every other transfer uses all the lanes of
  // its size.
  function automatic logic [15:0] beat_lanes(input int unsigned start, input int len, input logic [2:0] size,
                                             input logic [1:0] burst, input int n, input int bus_bytes);
    int unsigned nb = 1 << size;
    int unsigned a = beat_addr(start, len, size, burst, n);
    int unsigned aligned = (a / nb) * nb;
    int unsigned word = (a / bus_bytes) * bus_bytes;
    int lower = a - word;
    int upper = (n == 0 || burst == FIXED) ? (aligned + nb - 1 - word) : (lower + nb - 1);
    return {upper[7:0], lower[7:0]};
  endfunction

  // The strobe of transfer n: a 1 for every lane it uses (bit l is lane l).
  function automatic logic [63:0] beat_strb(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n, input int bus_bytes);
    logic [15:0] lanes = beat_lanes(start, len, size, burst, n, bus_bytes);
    logic [63:0] s = 0;
    for (int l = lanes[7:0]; l <= lanes[15:8]; l++) s[l] = 1'b1;
    return s;
  endfunction

  // True when the burst crosses a 4 KB boundary (only an INCR burst can).
  function automatic bit crosses_4k(input int unsigned start, input int len, input logic [2:0] size, input logic [1:0] burst);
    if (burst != INCR) return 0;
    return (beat_addr(start, len, size, burst, 0) / 4096) != ((beat_addr(start, len, size, burst, len) + (1 << size) - 1) / 4096);
  endfunction
endpackage
Read included file: axi_mem.sv
`timescale 1ns/1ns
// axi_mem.sv: an AXI4 subordinate with a byte-addressed memory behind it (read-only in this lesson).
// It accepts requests on AW and AR, write beats on W (before or after their AW), writes the bytes a
// burst addresses using the strobes, and answers on B and R after a latency. The switches below are
// plain variables: the stimulus sets them by name (mem.reorder = 1;) before it starts.
//   rd_latency, wr_latency   cycles from a request (or its last write beat) to its first response
//   slow_latency, slow_above addresses at or above slow_above answer after slow_latency instead
//   err_above                addresses at or above err_above get SLVERR (and are not written)
//   reorder                  answer transactions with DIFFERENT IDs as soon as each is ready;
//                            transactions with the same ID still answer in order
//   interleave               interleave the read data beats of ready transactions with different IDs
//   excl_on                  support exclusive access (one monitor per ID), else answer OKAY
//   posted                   apply a write to the memory only when its response is sent, so a read
//                            that arrives between the last beat and B still sees the old bytes
//   trace                    print every byte the memory writes
// Broken twins, each off by default: early_b (B before the last write beat and before AW),
// ignore_strobes (write every lane of the bus word), drop_hold (RDATA changes while RVALID waits
// for RREADY), reorder_same_id (a later transaction with the same ID may answer first),
// wrap_bug (a WRAP burst addressed like INCR).
module axi_mem #(parameter int DATA_W = 32, parameter int ID_W = 4, parameter int DEPTH = 65536) (
  input  logic              aclk,
  input  logic              aresetn,
  input  logic [ID_W-1:0]   awid,
  input  logic [31:0]       awaddr,
  input  logic [7:0]        awlen,
  input  logic [2:0]        awsize,
  input  logic [1:0]        awburst,
  input  logic              awlock,
  input  logic [3:0]        awcache,
  input  logic [2:0]        awprot,
  input  logic              awvalid,
  output logic              awready,
  input  logic [DATA_W-1:0] wdata,
  input  logic [DATA_W/8-1:0] wstrb,
  input  logic              wlast,
  input  logic              wvalid,
  output logic              wready,
  output logic [ID_W-1:0]   bid,
  output logic [1:0]        bresp,
  output logic              bvalid,
  input  logic              bready,
  input  logic [ID_W-1:0]   arid,
  input  logic [31:0]       araddr,
  input  logic [7:0]        arlen,
  input  logic [2:0]        arsize,
  input  logic [1:0]        arburst,
  input  logic              arlock,
  input  logic [3:0]        arcache,
  input  logic [2:0]        arprot,
  input  logic              arvalid,
  output logic              arready,
  output logic [ID_W-1:0]   rid,
  output logic [DATA_W-1:0] rdata,
  output logic [1:0]        rresp,
  output logic              rlast,
  output logic              rvalid,
  input  logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int N = 16;                      // transactions in flight per direction

  // ---- switches ----
  int rd_latency = 2, wr_latency = 2, slow_latency = 8;
  int unsigned slow_above = 32'hffff_ffff, err_above = 32'hffff_ffff;
  bit reorder = 0, interleave = 0, excl_on = 0, posted = 0, trace = 0;
  bit early_b = 0, ignore_strobes = 0, drop_hold = 0, reorder_same_id = 0, wrap_bug = 0;

  // ---- the memory ----
  logic [7:0] mem [0:DEPTH-1];
  initial for (int i = 0; i < DEPTH; i++) mem[i] = 8'h00;

  int cycle = -1;
  int seq = 0;                                // every request gets a sequence number: issue order

  // ---- write side: accepted AW requests (a ring) and write beats (a ring) ----
  logic [ID_W-1:0] aw_id [0:N-1];
  int unsigned     aw_addr [0:N-1];
  int              aw_len [0:N-1];
  logic [2:0]      aw_size [0:N-1];
  logic [1:0]      aw_burst [0:N-1];
  logic            aw_lock [0:N-1];
  int aw_head = 0, aw_tail = 0, aw_count = 0;
  localparam int WQ = 1024;
  logic [DATA_W-1:0] w_data [0:WQ-1];
  logic [BUS-1:0]    w_strb [0:WQ-1];
  logic              w_last [0:WQ-1];
  int w_head = 0, w_tail = 0, w_count = 0, w_bursts = 0;   // w_bursts: complete bursts in the ring

  // ---- write responses waiting for their latency ----
  logic            b_use [0:N-1];
  logic [ID_W-1:0] b_id [0:N-1];
  logic [1:0]      b_rsp [0:N-1];
  int              b_at [0:N-1], b_seq [0:N-1];
  logic            b_driving = 0;
  logic            early_done = 0;            // the early_b twin answers once per burst
  // posted writes: the beats of a write kept until its response goes out
  logic [DATA_W-1:0] p_data [0:N-1][0:255];
  logic [BUS-1:0]    p_strb [0:N-1][0:255];
  int unsigned       p_addr [0:N-1];
  int                p_len [0:N-1];
  logic [2:0]        p_size [0:N-1];
  logic [1:0]        p_burst [0:N-1];
  logic              p_pending [0:N-1];

  // ---- read side: accepted AR requests with their progress ----
  logic            r_use [0:N-1];
  logic [ID_W-1:0] r_id [0:N-1];
  int unsigned     r_addr [0:N-1];
  int              r_len [0:N-1];
  logic [2:0]      r_size [0:N-1];
  logic [1:0]      r_burst [0:N-1];
  logic            r_lock [0:N-1];
  int              r_at [0:N-1], r_seq [0:N-1], r_beat [0:N-1], r_served [0:N-1];
  int              r_cur = -1;                // the transaction whose beat is on the wires
  logic            r_driving = 0;

  // ---- exclusive monitors, one per ID ----
  logic        mon_use [0:(1<<ID_W)-1];
  int unsigned mon_addr [0:(1<<ID_W)-1];
  int unsigned mon_bytes [0:(1<<ID_W)-1];

  initial begin
    for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; p_pending[i] = 0; end
    for (int i = 0; i < (1 << ID_W); i++) mon_use[i] = 0;
    awready = 0; wready = 0; arready = 0; bvalid = 0; rvalid = 0; bid = 0; bresp = 0; rid = 0; rresp = 0; rlast = 0; rdata = 0;
  end

  function automatic int latency_of(input int unsigned a, input int base);
    return (a >= slow_above) ? slow_latency : base;
  endfunction
  function automatic logic [1:0] burst_used(input logic [1:0] b);
    return (wrap_bug && b == WRAP) ? INCR : b;
  endfunction

  // ---- selection policies ----
  // The oldest of all pending entries, or the oldest of its ID: the in-order rule of the protocol.
  function automatic bit b_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (b_use[j] && j != i && b_seq[j] < b_seq[i] && (!same_id_only || b_id[j] == b_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit r_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (r_use[j] && j != i && r_seq[j] < r_seq[i] && (!same_id_only || r_id[j] == r_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit b_eligible(input int i);
    if (!b_use[i] || b_at[i] > cycle) return 0;
    if (!reorder) return b_oldest(i, 0);
    return reorder_same_id ? 1 : b_oldest(i, 1);
  endfunction
  function automatic bit r_eligible(input int i);
    if (!r_use[i] || r_at[i] > cycle) return 0;
    if (!reorder) return r_oldest(i, 0);
    return reorder_same_id ? 1 : r_oldest(i, 1);
  endfunction
  function automatic int free_b();
    for (int i = 0; i < N; i++) if (!b_use[i]) return i;
    return -1;
  endfunction
  function automatic int free_r();
    for (int i = 0; i < N; i++) if (!r_use[i]) return i;
    return -1;
  endfunction
  function automatic int pick_b();
    int best = -1;
    for (int i = 0; i < N; i++) if (b_eligible(i) && (best < 0 || b_seq[i] < b_seq[best])) best = i;
    return best;
  endfunction
  function automatic int pick_r();
    int best = -1;
    for (int i = 0; i < N; i++) if (r_eligible(i)) begin
      if (best < 0) best = i;
      else if (interleave ? (r_served[i] < r_served[best]) : (r_seq[i] < r_seq[best])) best = i;
    end
    return best;
  endfunction

  // ---- the bytes of one read beat, as the bus word that holds them ----
  function automatic logic [DATA_W-1:0] read_word(input int unsigned a);
    logic [DATA_W-1:0] d = 0;
    int unsigned word = (a / BUS) * BUS;
    for (int l = 0; l < BUS; l++) d[8*l +: 8] = (word + l < DEPTH) ? mem[word + l] : 8'h00;
    return d;
  endfunction

  // ---- the write of one complete burst into the memory ----
  task automatic write_burst(input int e);
    logic [1:0]  rsp = OKAY;
    logic        do_write = 1, ended = 0;
    int unsigned a, word;
    logic [15:0] lanes;
    int          n = 0, slot;
    int unsigned total = (1 << aw_size[e]) * (aw_len[e] + 1);
    slot = free_b();
    if (aw_lock[e] && excl_on) begin
      if (mon_use[aw_id[e]] && mon_addr[aw_id[e]] == aw_addr[e]) begin
        rsp = EXOKAY;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: the monitor matched, EXOKAY", cycle, aw_id[e], aw_addr[e]);
      end else begin
        do_write = 0;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: no monitor, OKAY and nothing written", cycle, aw_id[e], aw_addr[e]);
      end
    end
    while (!ended && n <= aw_len[e]) begin
      a = beat_addr(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n);
      lanes = beat_lanes(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n, BUS);
      word = (a / BUS) * BUS;
      if (a >= err_above) rsp = SLVERR;
      else if (do_write && posted && slot >= 0) begin
        p_data[slot][n] = w_data[w_head]; p_strb[slot][n] = w_strb[w_head];
      end else if (do_write) begin
        for (int l = 0; l < BUS; l++)
          if ((w_strb[w_head][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = w_data[w_head][8*l +: 8];
            if (trace) $display("mem e%0d: beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, w_data[w_head][8*l +: 8], word + l, l);
          end
      end
      ended = w_last[w_head];                      // a burst ends at its WLAST, whatever AWLEN said
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
      n = n + 1;
    end
    while (!ended) begin                           // beats past AWLEN (a broken manager) are dropped
      ended = w_last[w_head];
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
    end
    // A write clears every monitor that watches a byte it touched.
    if (do_write)
      for (int i = 0; i < (1 << ID_W); i++)
        if (mon_use[i] && mon_addr[i] < aw_addr[e] + total && aw_addr[e] < mon_addr[i] + mon_bytes[i]) mon_use[i] = 0;
    if (slot >= 0) begin
      b_use[slot] = 1; b_id[slot] = aw_id[e]; b_rsp[slot] = rsp; b_seq[slot] = seq; seq = seq + 1;
      b_at[slot] = cycle + latency_of(aw_addr[e], wr_latency);
      if (posted && do_write) begin
        p_pending[slot] = 1; p_addr[slot] = aw_addr[e]; p_len[slot] = n - 1; p_size[slot] = aw_size[e]; p_burst[slot] = aw_burst[e];
      end
    end
  endtask

  // A posted write reaches the memory when its response goes out.
  task automatic apply_posted(input int i);
    int unsigned a, word;
    for (int n = 0; n <= p_len[i]; n++) begin
      a = beat_addr(p_addr[i], p_len[i], p_size[i], burst_used(p_burst[i]), n);
      word = (a / BUS) * BUS;
      if (a < err_above)
        for (int l = 0; l < BUS; l++)
          if ((p_strb[i][n][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = p_data[i][n][8*l +: 8];
            if (trace) $display("mem e%0d: posted beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, p_data[i][n][8*l +: 8], word + l, l);
          end
    end
    p_pending[i] = 0;
  endtask

  int pick, extra;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      aw_head = 0; aw_tail = 0; aw_count = 0; w_head = 0; w_tail = 0; w_count = 0; w_bursts = 0;
      for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; end
      b_driving = 0; r_driving = 0; r_cur = -1;
      awready <= 0; wready <= 0; arready <= 0; bvalid <= 0; rvalid <= 0;
    end else begin
      // -- AW: take a request while there is room --
      if (awvalid && awready) begin
        aw_id[aw_tail] = awid; aw_addr[aw_tail] = awaddr; aw_len[aw_tail] = awlen; aw_size[aw_tail] = awsize;
        aw_burst[aw_tail] = awburst; aw_lock[aw_tail] = awlock;
        aw_tail = (aw_tail + 1) % N; aw_count = aw_count + 1;
      end
      // -- W: take a beat while there is room --
      if (wvalid && wready) begin
        w_data[w_tail] = wdata; w_strb[w_tail] = wstrb; w_last[w_tail] = wlast;
        w_tail = (w_tail + 1) % WQ; w_count = w_count + 1;
        if (wlast) w_bursts = w_bursts + 1;
      end
      // -- a complete burst with its request: write it and schedule B --
      if (aw_count > 0 && w_bursts > 0) begin
        write_burst(aw_head);
        aw_head = (aw_head + 1) % N; aw_count = aw_count - 1; w_bursts = w_bursts - 1;
        early_done = 0;
      end else if (early_b && !early_done && w_count > 0 && w_bursts == 0) begin
        // The broken twin: a response as soon as the first write beat arrived, before WLAST and,
        // when the data came first, before the address.
        pick = free_b();
        if (pick >= 0) begin
          b_use[pick] = 1; b_id[pick] = (aw_count > 0) ? aw_id[aw_head] : awid; b_rsp[pick] = OKAY; b_seq[pick] = seq; seq = seq + 1; b_at[pick] = cycle;
          early_done = 1;
        end
      end
      // -- B: finish a handshake, then put the next response on the wires --
      if (b_driving && bready) b_driving = 0;
      if (!b_driving) begin
        pick = pick_b();
        if (pick >= 0) begin
          if (p_pending[pick]) apply_posted(pick);
          b_driving = 1; bid <= b_id[pick]; bresp <= b_rsp[pick]; b_use[pick] = 0;
        end
      end
      bvalid <= b_driving;
      // -- AR: take a request while there is room --
      if (arvalid && arready) begin
        pick = free_r();
        if (pick >= 0) begin
          r_use[pick] = 1; r_id[pick] = arid; r_addr[pick] = araddr; r_len[pick] = arlen; r_size[pick] = arsize; r_burst[pick] = arburst;
          r_lock[pick] = arlock; r_beat[pick] = 0; r_seq[pick] = seq; seq = seq + 1; r_served[pick] = -1;
          r_at[pick] = cycle + latency_of(araddr, rd_latency);
          if (arlock && excl_on) begin
            mon_use[arid] = 1; mon_addr[arid] = araddr; mon_bytes[arid] = (1 << arsize) * (arlen + 1);
            $display("mem e%0d: exclusive read id=%0d at 0x%0h: monitor set", cycle, arid, araddr);
          end
        end
      end
      // -- R: finish a handshake, then put the next beat on the wires --
      if (r_driving && !rready && drop_hold) rdata <= rdata + 1;   // the broken twin: data not held
      if (r_driving && rready) begin
        r_driving = 0;
        if (r_beat[r_cur] > r_len[r_cur]) begin r_use[r_cur] = 0; r_cur = -1; end
        else if (interleave) r_cur = -1;
      end
      if (!r_driving) begin
        pick = (r_cur >= 0) ? r_cur : pick_r();
        if (pick >= 0) begin
          r_cur = pick; r_driving = 1; r_served[pick] = cycle;
          extra = r_beat[pick];
          rid <= r_id[pick];
          rdata <= read_word(beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra));
          rresp <= (beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra) >= err_above) ? SLVERR
                 : ((r_lock[pick] && excl_on) ? EXOKAY : OKAY);
          rlast <= (extra == r_len[pick]);
          r_beat[pick] = extra + 1;
        end
      end
      rvalid <= r_driving;
      awready <= (aw_count < N - 1);
      wready  <= (w_count < WQ - 2);
      arready <= 1;
    end
  end
endmodule
Read included file: axi_checker.sv
`timescale 1ns/1ns
// axi_checker.sv: the rules of an AXI4 interface, checked at every rising edge (read-only).
// Each broken rule is named with the channel and the edge where it was seen:
//   reset      a VALID is 1 while reset is active;
//   hold       a VALID dropped before its READY: the offer was withdrawn;
//   stable     a channel's payload changed while its offer waited;
//   known      a payload is x while its VALID is 1;
//   len        a FIXED or WRAP burst longer than 16 beats;
//   wrap       a WRAP burst whose length is not 2, 4, 8 or 16 beats or whose address is not aligned;
//   boundary   a burst that crosses a 4 KB boundary;
//   size       a transfer wider than the data bus;
//   strobe     a write strobe on a lane the beat does not address;
//   wlast      WLAST on the wrong beat (not AWLEN), or missing after it;
//   rlast      RLAST on the wrong beat of the oldest read with that ID, or missing after it;
//   border     BVALID before any outstanding write has its last beat, or before its AW;
//   bid, rid   a response ID with no outstanding request of that ID;
//   exokay     EXOKAY for a request that was not exclusive;
//   exclusive  an exclusive request whose bytes are not a power of two up to 128, or not aligned to them.
// The rules no checker can see on the wires (VALID must not wait for READY; same-ID responses
// in the order of their requests) are checked by the data the tasks compare (lessons P2.2, P2.10).
module axi_checker #(parameter int DATA_W = 32, parameter int ID_W = 4) (
  input logic              aclk,
  input logic              aresetn,
  input logic [ID_W-1:0]   awid,
  input logic [31:0]       awaddr,
  input logic [7:0]        awlen,
  input logic [2:0]        awsize,
  input logic [1:0]        awburst,
  input logic              awlock,
  input logic              awvalid,
  input logic              awready,
  input logic [DATA_W-1:0] wdata,
  input logic [DATA_W/8-1:0] wstrb,
  input logic              wlast,
  input logic              wvalid,
  input logic              wready,
  input logic [ID_W-1:0]   bid,
  input logic [1:0]        bresp,
  input logic              bvalid,
  input logic              bready,
  input logic [ID_W-1:0]   arid,
  input logic [31:0]       araddr,
  input logic [7:0]        arlen,
  input logic [2:0]        arsize,
  input logic [1:0]        arburst,
  input logic              arlock,
  input logic              arvalid,
  input logic              arready,
  input logic [ID_W-1:0]   rid,
  input logic [DATA_W-1:0] rdata,
  input logic [1:0]        rresp,
  input logic              rlast,
  input logic              rvalid,
  input logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int Q = 64;
  int cycle = -1, writes = 0, reads = 0, stalls = 0, broken = 0;
  logic [DATA_W-1:0] used;

  function void report(input string rule, input string what);
    broken++;
    $display("RULE %s broken at edge %0d: %s", rule, cycle, what);
  endfunction

  // Previous values of every channel, for hold and stable.
  logic p_awv = 0, p_awr = 0, p_wv = 0, p_wr = 0, p_bv = 0, p_br = 0, p_arv = 0, p_arr = 0, p_rv = 0, p_rr = 0;
  logic [31:0] p_awaddr, p_araddr;
  logic [7:0] p_awlen, p_arlen;
  logic [2:0] p_awsize, p_arsize;
  logic [1:0] p_awburst, p_arburst, p_bresp, p_rresp;
  logic [ID_W-1:0] p_awid, p_arid, p_bid, p_rid;
  logic [DATA_W-1:0] p_wdata, p_rdata;
  logic [BUS-1:0] p_wstrb;
  logic p_wlast, p_rlast, p_awlock, p_arlock;

  // Write requests in order (AXI4 write data follows the order of the addresses).
  int unsigned q_addr [0:Q-1];
  int q_len [0:Q-1];
  logic [2:0] q_size [0:Q-1];
  logic [1:0] q_burst [0:Q-1];
  int aw_n = 0;                 // requests accepted
  int wb_n = 0;                 // write bursts started
  int wb_done = 0;              // write bursts ended (WLAST seen)
  int w_beat = 0;               // beats so far in the current burst
  int b_n = 0;                  // responses given
  // Beats recorded for bursts that ran ahead of their AW: strobes and count, checked when AW arrives.
  logic [BUS-1:0] rec_strb [0:Q-1][0:255];
  int rec_beats [0:Q-1];
  logic rec_open [0:Q-1];
  // Outstanding requests per ID, and the read requests per ID in order.
  int aw_out [0:(1<<ID_W)-1], ar_out [0:(1<<ID_W)-1], aw_excl [0:(1<<ID_W)-1], ar_excl [0:(1<<ID_W)-1];
  int rq_len [0:(1<<ID_W)-1][0:15];
  int rq_head [0:(1<<ID_W)-1], rq_tail [0:(1<<ID_W)-1], r_beat [0:(1<<ID_W)-1];
  initial for (int i = 0; i < (1 << ID_W); i++) begin aw_out[i] = 0; ar_out[i] = 0; aw_excl[i] = 0; ar_excl[i] = 0; rq_head[i] = 0; rq_tail[i] = 0; r_beat[i] = 0; end
  initial for (int i = 0; i < Q; i++) begin rec_beats[i] = 0; rec_open[i] = 0; end

  function automatic bit pow2_le128(input int unsigned n);
    return (n == 1 || n == 2 || n == 4 || n == 8 || n == 16 || n == 32 || n == 64 || n == 128);
  endfunction

  task automatic check_request(input string ch, input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input logic lock);
    int unsigned bytes = (1 << size) * (len + 1);
    if ((burst == FIXED || burst == WRAP) && len > 15) report("len", $sformatf("%s: a %s burst of %0d beats (16 at most)", ch, burst_name(burst), len + 1));
    if (burst == WRAP && !(len == 1 || len == 3 || len == 7 || len == 15)) report("wrap", $sformatf("%s: a WRAP burst of %0d beats (2, 4, 8 or 16)", ch, len + 1));
    if (burst == WRAP && (addr % (1 << size)) != 0) report("wrap", $sformatf("%s: WRAP burst at 0x%0h is not aligned to its %0d-byte transfers", ch, addr, 1 << size));
    if (burst == 2'b11) report("len", $sformatf("%s: burst type 2'b11 is reserved", ch));
    if ((1 << size) > BUS) report("size", $sformatf("%s: %0d-byte transfers on a %0d-byte bus", ch, 1 << size, BUS));
    if (crosses_4k(addr, len, size, burst)) report("boundary", $sformatf("%s: burst at 0x%0h, %0d beats of %0d bytes, crosses a 4 KB boundary", ch, addr, len + 1, 1 << size));
    if (lock && (!pow2_le128(bytes) || (addr % bytes) != 0)) report("exclusive", $sformatf("%s: exclusive access of %0d bytes at 0x%0h (a power of two up to 128, aligned)", ch, bytes, addr));
  endtask

  task automatic check_strobe(input int k, input int n, input logic [BUS-1:0] strb);
    logic [63:0] allowed = beat_strb(q_addr[k % Q], q_len[k % Q], q_size[k % Q], q_burst[k % Q], n, BUS);
    if ((strb & ~allowed[BUS-1:0]) != 0)
      report("strobe", $sformatf("W beat %0d of write %0d: strobe %b on lanes outside %b", n, k, strb, allowed[BUS-1:0]));
  endtask

  always @(posedge aclk) begin
    cycle++;
    if (!aresetn) begin
      if (awvalid === 1 || wvalid === 1 || arvalid === 1) report("reset", "a manager VALID is 1 during reset");
      if (bvalid === 1 || rvalid === 1) report("reset", "a subordinate VALID is 1 during reset");
    end else begin
      // hold, stable and known, per channel
      if (p_awv && !p_awr && awvalid !== 1) report("hold", "AWVALID dropped before AWREADY");
      if (p_awv && !p_awr && awvalid === 1 && (awaddr !== p_awaddr || awlen !== p_awlen || awsize !== p_awsize || awburst !== p_awburst || awid !== p_awid || awlock !== p_awlock)) report("stable", "AW payload changed while the request waited");
      if (p_wv && !p_wr && wvalid !== 1) report("hold", "WVALID dropped before WREADY");
      if (p_wv && !p_wr && wvalid === 1 && (wdata !== p_wdata || wstrb !== p_wstrb || wlast !== p_wlast)) report("stable", "W payload changed while the beat waited");
      if (p_bv && !p_br && bvalid !== 1) report("hold", "BVALID dropped before BREADY");
      if (p_bv && !p_br && bvalid === 1 && (bresp !== p_bresp || bid !== p_bid)) report("stable", "B payload changed while the response waited");
      if (p_arv && !p_arr && arvalid !== 1) report("hold", "ARVALID dropped before ARREADY");
      if (p_arv && !p_arr && arvalid === 1 && (araddr !== p_araddr || arlen !== p_arlen || arsize !== p_arsize || arburst !== p_arburst || arid !== p_arid || arlock !== p_arlock)) report("stable", "AR payload changed while the request waited");
      if (p_rv && !p_rr && rvalid !== 1) report("hold", "RVALID dropped before RREADY");
      if (p_rv && !p_rr && rvalid === 1 && (rdata !== p_rdata || rresp !== p_rresp || rid !== p_rid || rlast !== p_rlast)) report("stable", "R payload changed while the beat waited");
      if (awvalid === 1 && ($isunknown(awaddr) || $isunknown(awlen) || $isunknown(awsize) || $isunknown(awburst) || $isunknown(awid))) report("known", "AW payload is x while AWVALID is 1");
      if (wvalid === 1 && ($isunknown(wstrb) || $isunknown(wlast))) report("known", "W strobe or last is x while WVALID is 1");
      else if (wvalid === 1) begin
        used = '0;
        for (int l = 0; l < BUS; l++) if (wstrb[l] === 1) used[8*l +: 8] = 8'hff;
        if ($isunknown(wdata & used)) report("known", "W data is x on a strobed lane while WVALID is 1");
      end
      if (arvalid === 1 && ($isunknown(araddr) || $isunknown(arlen) || $isunknown(arsize) || $isunknown(arburst) || $isunknown(arid))) report("known", "AR payload is x while ARVALID is 1");
      if (bvalid === 1 && ($isunknown(bresp) || $isunknown(bid))) report("known", "B payload is x while BVALID is 1");
      if (rvalid === 1 && ($isunknown(rresp) || $isunknown(rid) || $isunknown(rlast))) report("known", "R payload is x while RVALID is 1");
      if ((awvalid === 1 && awready !== 1) || (wvalid === 1 && wready !== 1) || (arvalid === 1 && arready !== 1) ||
          (bvalid === 1 && bready !== 1) || (rvalid === 1 && rready !== 1)) stalls++;
      // AW accepted
      if (awvalid === 1 && awready === 1) begin
        check_request("AW", awaddr, awlen, awsize, awburst, awlock);
        q_addr[aw_n % Q] = awaddr; q_len[aw_n % Q] = awlen; q_size[aw_n % Q] = awsize; q_burst[aw_n % Q] = awburst;
        aw_out[awid]++; if (awlock) aw_excl[awid]++;
        // beats of this write that arrived before its address: check them now
        if (rec_beats[aw_n % Q] > 0) begin
          for (int n = 0; n < rec_beats[aw_n % Q]; n++) check_strobe(aw_n, n, rec_strb[aw_n % Q][n]);
          if (!rec_open[aw_n % Q] && rec_beats[aw_n % Q] != awlen + 1)
            report("wlast", $sformatf("write %0d sent %0d beats before its AW said AWLEN=%0d", aw_n, rec_beats[aw_n % Q], awlen));
          if (!rec_open[aw_n % Q]) rec_beats[aw_n % Q] = 0;
        end
        aw_n++;
      end
      // W beat accepted
      if (wvalid === 1 && wready === 1) begin
        if (w_beat == 0) begin wb_n++; rec_beats[(wb_n - 1) % Q] = 0; rec_open[(wb_n - 1) % Q] = 1; end
        if (wb_n <= aw_n) begin
          check_strobe(wb_n - 1, w_beat, wstrb);
          if (wlast === 1 && w_beat != q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("WLAST on beat %0d of write %0d, AWLEN=%0d", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
          if (wlast !== 1 && w_beat == q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("beat %0d of write %0d is AWLEN=%0d but WLAST is 0", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
        end else begin
          rec_strb[(wb_n - 1) % Q][w_beat] = wstrb;
        end
        rec_beats[(wb_n - 1) % Q] = w_beat + 1;
        w_beat++;
        if (wlast === 1) begin w_beat = 0; wb_done++; rec_open[(wb_n - 1) % Q] = 0; if (wb_n <= aw_n) rec_beats[(wb_n - 1) % Q] = 0; end
      end
      // B offered or accepted
      if (bvalid === 1 && !p_bv) begin
        if (b_n >= aw_n && b_n >= wb_done) report("border", "BVALID with no write to answer: neither an AW nor a WLAST is outstanding");
        else if (b_n >= wb_done) report("border", "BVALID before the last beat of the write it answers");
        else if (b_n >= aw_n) report("border", "BVALID before the AW of the write it answers was accepted");
      end
      if (bvalid === 1 && bready === 1) begin
        if (aw_out[bid] == 0) report("bid", $sformatf("B with id %0d, which has no outstanding write", bid));
        else begin
          aw_out[bid]--; writes++;
          if (bresp === EXOKAY && aw_excl[bid] == 0) report("exokay", $sformatf("EXOKAY for write id %0d, which was not exclusive", bid));
          if (aw_excl[bid] > 0 && aw_excl[bid] > aw_out[bid]) aw_excl[bid] = aw_out[bid];
        end
        b_n++;
      end
      // AR accepted
      if (arvalid === 1 && arready === 1) begin
        check_request("AR", araddr, arlen, arsize, arburst, arlock);
        rq_len[arid][rq_tail[arid]] = arlen; rq_tail[arid] = (rq_tail[arid] + 1) % 16;
        ar_out[arid]++; if (arlock) ar_excl[arid]++;
      end
      // R beat accepted
      if (rvalid === 1 && rready === 1) begin
        if (ar_out[rid] == 0) report("rid", $sformatf("R with id %0d, which has no outstanding read", rid));
        else begin
          if (rlast === 1 && r_beat[rid] != rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("RLAST on beat %0d of the oldest read with id %0d, whose ARLEN is %0d", r_beat[rid], rid, rq_len[rid][rq_head[rid]]));
          if (rlast !== 1 && r_beat[rid] == rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("beat %0d of the oldest read with id %0d is its ARLEN but RLAST is 0", r_beat[rid], rid));
          if (rresp === EXOKAY && ar_excl[rid] == 0) report("exokay", $sformatf("EXOKAY for read id %0d, which was not exclusive", rid));
          r_beat[rid]++;
          if (rlast === 1) begin
            r_beat[rid] = 0; rq_head[rid] = (rq_head[rid] + 1) % 16; ar_out[rid]--; reads++;
            if (ar_excl[rid] > ar_out[rid]) ar_excl[rid] = ar_out[rid];
          end
        end
      end
    end
    p_awv = (awvalid === 1); p_awr = (awready === 1); p_wv = (wvalid === 1); p_wr = (wready === 1);
    p_bv = (bvalid === 1); p_br = (bready === 1); p_arv = (arvalid === 1); p_arr = (arready === 1);
    p_rv = (rvalid === 1); p_rr = (rready === 1);
    p_awaddr = awaddr; p_awlen = awlen; p_awsize = awsize; p_awburst = awburst; p_awid = awid; p_awlock = awlock;
    p_wdata = wdata; p_wstrb = wstrb; p_wlast = wlast; p_bresp = bresp; p_bid = bid;
    p_araddr = araddr; p_arlen = arlen; p_arsize = arsize; p_arburst = arburst; p_arid = arid; p_arlock = arlock;
    p_rdata = rdata; p_rresp = rresp; p_rid = rid; p_rlast = rlast;
  end
  final $display("checker: %0d writes, %0d reads, %0d stalled edges, %0d rules broken", writes, reads, stalls, broken);
endmodule
Read included file: axi_tasks.svh
// axi_tasks.svh: the manager side of the bench, as tasks for the stimulus (read-only).
// Data for a write burst goes in wd[0], wd[1], ... (one entry per beat, the lowest byte at the
// lowest address); the data of a read comes back in rd[0], rd[1], ... with its responses in rr[].
// Every task prints the beat log: one line per handshake, with the edge where it happened.
// `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge aclk) cycle = cycle + 1;

logic [63:0] wd [0:255];
logic [63:0] rd [0:255];
logic [1:0]  rr [0:255];
logic [63:0] rdq [0:15][0:255];     // read data per ID, for reads collected out of order
logic [1:0]  rrq [0:15][0:255];
int          rdn [0:15];            // beats received per ID
logic [1:0]  last_bresp = 0;
int          last_beats = 0;
// What the task is driving right now, for the waveform scenes: the address and lanes of the beat.
int unsigned beat_a = 0;
logic [7:0]  beat_m = 0;
// quiet = 1 silences the beat log (a predict item can then ask for a dump line instead).
bit          quiet = 0;
// Strobe override: when strb_force is 1, every write beat uses strb_val as it is.
bit          strb_force = 0;
logic [7:0]  strb_val = 8'hff;
// Outstanding read requests per ID, so the tasks know the lanes of the beats that come back.
int unsigned arq_addr [0:15][0:7];
int          arq_len [0:15][0:7];
logic [2:0]  arq_size [0:15][0:7];
logic [1:0]  arq_burst [0:15][0:7];
int          arq_head [0:15], arq_tail [0:15];
initial for (int i = 0; i < 16; i++) begin arq_head[i] = 0; arq_tail[i] = 0; rdn[i] = 0; end
// READY patterns for the response channels: bit (cycle % 16) of the pattern drives the signal.
bit          rpat_on = 0, bpat_on = 0;
logic [15:0] rpat = 16'hffff, bpat = 16'hffff;
always @(posedge aclk) begin
  #1;
  if (rpat_on) rready = rpat[cycle % 16];
  if (bpat_on) bready = bpat[cycle % 16];
end

// A text waveform for the lesson's trace blocks: with watch = 1, one line per rising edge with the
// values sampled at that edge (cycle k of a trace is what edge k sees).
bit watch = 0;
int wave_edge = -1;
always @(posedge aclk) begin
  wave_edge = wave_edge + 1;
  if (watch) $display("wave e%0d: aw=%b%b w=%b%b b=%b%b ar=%b%b r=%b%b awaddr=%h wdata=%h wstrb=%b wlast=%b bid=%h bresp=%b araddr=%h rid=%h rdata=%h rresp=%b rlast=%b",
                      wave_edge, awvalid, awready, wvalid, wready, bvalid, bready, arvalid, arready, rvalid, rready,
                      awaddr, wdata, wstrb, wlast, bid, bresp, araddr, rid, rdata, rresp, rlast);
end

// Drive RREADY (ch = 0) or BREADY (ch = 1) from a 16-bit pattern; 16'hffff restores always ready.
task automatic ready_pattern(input int ch, input logic [15:0] pat);
  if (ch == 0) begin rpat = pat; rpat_on = 1; rready = pat[cycle % 16]; end
  else begin bpat = pat; bpat_on = 1; bready = pat[cycle % 16]; end
endtask

// The write address channel: offer the request and hold it until it is taken.
task automatic aw_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  awid = id; awaddr = addr; awlen = len[7:0]; awsize = size; awburst = burst; awlock = lock; awvalid = 1;
  do @(posedge aclk); while (!awready);
  #1 if (!quiet) $display("e%0d AW id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  awvalid = 0; awaddr = 'x; awlen = 'x; awsize = 'x; awburst = 'x; awid = 'x; awlock = 0;
endtask

// The write data channel: the beats of one burst from wd[first..], each placed in its lanes.
task automatic w_burst(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input int first = 0);
  logic [15:0] lanes;
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    beat_a = beat_addr(addr, len, size, burst, n);
    beat_m = strb_force ? strb_val : beat_strb(addr, len, size, burst, n, BUS_BYTES);
    wdata = wd[first + n] << (8 * lanes[7:0]);
    wstrb = beat_m[BUS_BYTES-1:0];
    wlast = (n == len);
    wvalid = 1;
    do @(posedge aclk); while (!wready);
    #1 if (!quiet) $display("e%0d W  beat %0d data=0x%0h strb=%b last=%0d  addr 0x%0h lanes %0d-%0d", cycle, n, wdata, wstrb, wlast, beat_a, lanes[7:0], lanes[15:8]);
  end
  wvalid = 0; wdata = 'x; wstrb = 'x; wlast = 0; beat_m = 0;
endtask

// Wait for the write response of one transaction with this ID.
task automatic b_wait(input logic [ID_W-1:0] id);
  do @(posedge aclk); while (!(bvalid && bready && bid == id));
  last_bresp = bresp;                       // sampled at the edge, before the subordinate moves on
  #1 if (!quiet) $display("e%0d B  id=%0d %0s", cycle, id, resp_name(last_bresp));
endtask

// A complete write. order 0 offers the address, then the first beat one cycle later whether or
// not the address has been taken yet (a manager must never make WVALID wait for AWREADY); 1 offers
// the beats first and the address after beat 0; 2 offers the address and beat 0 in the same cycle.
// Returns after B, with the response in last_bresp.
task automatic axi_write(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                         input logic [1:0] burst, input int order = 0, input logic lock = 0);
  case (order)
    1: fork
         w_burst(addr, len, size, burst);
         begin @(posedge aclk); #1 aw_issue(id, addr, len, size, burst, lock); end
       join
    2: fork
         aw_issue(id, addr, len, size, burst, lock);
         w_burst(addr, len, size, burst);
       join
    default: fork
         aw_issue(id, addr, len, size, burst, lock);
         begin @(posedge aclk); #1 w_burst(addr, len, size, burst); end
       join
  endcase
  b_wait(id);
endtask

// The read address channel: offer the request and remember it for the beats that come back.
task automatic ar_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  arq_addr[id][arq_tail[id]] = addr; arq_len[id][arq_tail[id]] = len; arq_size[id][arq_tail[id]] = size;
  arq_burst[id][arq_tail[id]] = burst; arq_tail[id] = (arq_tail[id] + 1) % 8;
  arid = id; araddr = addr; arlen = len[7:0]; arsize = size; arburst = burst; arlock = lock; arvalid = 1;
  do @(posedge aclk); while (!arready);
  #1 if (!quiet) $display("e%0d AR id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  arvalid = 0; araddr = 'x; arlen = 'x; arsize = 'x; arburst = 'x; arid = 'x; arlock = 0;
endtask

// Collect read beats until n transactions have ended (their RLAST). Each beat lands in rdq[rid][k]
// with only the bytes of the transfer (lane-shifted down), and rd[] holds the last transaction.
task automatic r_collect(input int n);
  int done = 0, h;
  logic [15:0] lanes;
  logic [63:0] bytes;
  logic [ID_W-1:0] id;
  logic [DATA_W-1:0] data;
  logic [1:0] resp;
  logic last;
  while (done < n) begin
    do @(posedge aclk); while (!(rvalid && rready));
    id = rid; data = rdata; resp = rresp; last = rlast;   // sampled at the edge, before the subordinate moves on
    h = arq_head[id];
    lanes = beat_lanes(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    beat_a = beat_addr(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id]);
    beat_m = beat_strb(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    bytes = (data >> (8 * lanes[7:0])) & ((64'h1 << (8 * (lanes[15:8] - lanes[7:0] + 1))) - 1);
    rdq[id][rdn[id]] = bytes; rrq[id][rdn[id]] = resp;
    #1 if (!quiet) $display("e%0d R  id=%0d beat %0d data=0x%0h %0s%0s  addr 0x%0h lanes %0d-%0d", cycle, id, rdn[id], bytes, resp_name(resp),
                last ? " last" : "", beat_a, lanes[7:0], lanes[15:8]);
    rdn[id] = rdn[id] + 1;
    if (last) begin
      for (int k = 0; k < rdn[id]; k++) begin rd[k] = rdq[id][k]; rr[k] = rrq[id][k]; end
      last_beats = rdn[id]; rdn[id] = 0; arq_head[id] = (h + 1) % 8; done = done + 1;
    end
  end
  beat_m = 0;
endtask

// A complete read: AR, then every beat, into rd[] and rr[].
task automatic axi_read(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  ar_issue(id, addr, len, size, burst, lock);
  r_collect(1);
endtask

// The table of a burst before it runs: the address, lanes and strobe of every beat.
task automatic beat_table(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst);
  logic [15:0] lanes;
  logic [63:0] s;
  int unsigned a;
  $display("burst at 0x%0h: %0d beat%0s of %0d byte%0s, %0s, bus %0d bytes", addr, len + 1, len ? "s" : "", 1 << size, size ? "s" : "",
           burst_name(burst), BUS_BYTES);
  $display("  beat  address  lanes  strobe");
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    s = beat_strb(addr, len, size, burst, n, BUS_BYTES);
    a = beat_addr(addr, len, size, burst, n);
    $display("  %4d  0x%05h  %0d-%0d    %b", n, a[19:0], lanes[7:0], lanes[15:8], s[BUS_BYTES-1:0]);
  end
  if (crosses_4k(addr, len, size, burst)) $display("  this burst crosses a 4 KB boundary");
endtask

// One byte of the memory that owns an address (the fabric's second memory above 0x8000).
function automatic logic [7:0] mem_byte(input int unsigned a);
`ifdef AXI_MEM1
  if (a >= 32'h8000) return `AXI_MEM1.mem[a];
`endif
  return `AXI_MEM.mem[a];
endfunction
task automatic set_byte(input int unsigned a, input logic [7:0] v);
`ifdef AXI_MEM1
  if (a >= 32'h8000) `AXI_MEM1.mem[a] = v;
  else `AXI_MEM.mem[a] = v;
`else
  `AXI_MEM.mem[a] = v;
`endif
endtask

// A big-endian manager's view of a value: the most significant byte goes to the lowest address.
// Byte-invariant lanes never swap anything; the manager does, before the value reaches wd[].
function automatic logic [15:0] be16(input logic [15:0] v);
  return {v[7:0], v[15:8]};
endfunction
function automatic logic [31:0] be32(input logic [31:0] v);
  return {v[7:0], v[15:8], v[23:16], v[31:24]};
endfunction

// The memory, n bytes from addr, one bus word per group.
task automatic dump(input int unsigned addr, input int n);
  string line;
  int unsigned a = (addr / 16) * 16;
  while (a < addr + n) begin
    line = $sformatf("0x%05h ", a[19:0]);
    for (int i = 0; i < 16; i++) begin
      if (i % BUS_BYTES == 0) line = {line, " "};
      line = {line, $sformatf(" %02h", mem_byte(a + i))};
    end
    $display("%s", line);
    a = a + 16;
  end
endtask

// Fill n bytes from addr with first, first+1, ... so untouched bytes stay recognisable.
task automatic mem_fill(input int unsigned addr, input int n, input logic [7:0] first = 8'h00);
  for (int i = 0; i < n; i++) set_byte(addr + i, first + i[7:0]);
endtask

// Drive nothing for n cycles.
task automatic idle(input int n);
  repeat (n) @(posedge aclk);
  #1;
endtask
Read included file: axi_down.sv
`timescale 1ns/1ns
// axi_down.sv: a downsizer from a 64-bit manager port to a 32-bit subordinate port (read-only).
// One write and one read at a time, INCR bursts. A full-width request (AxSIZE = 3, eight bytes per
// beat) cannot fit the narrow bus, so it is modified whatever its AxCACHE: AxSIZE becomes 2, AxLEN
// becomes 2 x (AxLEN + 1) - 1, the address is kept, and every write beat leaves as two halves,
// lanes 0-3 first. Two read beats are merged into one, and the merged beat carries the worse of
// the two responses. A narrow request (AxSIZE 2 or less) already fits and passes unchanged, with
// its data moved between the half of the 64-bit word its address names and the 32-bit lanes.
// Limits: a full-width request must start 8-byte aligned (an unaligned start would send its lower
// lanes to the wrong word) and have AxLEN up to 127; WRAP and FIXED bursts are not converted.
// Switches: trace prints every conversion; no_merge_resp (the broken twin) gives a merged read
// beat the response of its first half only.
module axi_down #(parameter int ID_W = 4) (
  input  logic            aclk,
  input  logic            aresetn,
  // the 64-bit manager side
  input  logic [ID_W-1:0] awid,
  input  logic [31:0]     awaddr,
  input  logic [7:0]      awlen,
  input  logic [2:0]      awsize,
  input  logic [1:0]      awburst,
  input  logic            awlock,
  input  logic            awvalid,
  output logic            awready,
  input  logic [63:0]     wdata,
  input  logic [7:0]      wstrb,
  input  logic            wlast,
  input  logic            wvalid,
  output logic            wready,
  output logic [ID_W-1:0] bid,
  output logic [1:0]      bresp,
  output logic            bvalid,
  input  logic            bready,
  input  logic [ID_W-1:0] arid,
  input  logic [31:0]     araddr,
  input  logic [7:0]      arlen,
  input  logic [2:0]      arsize,
  input  logic [1:0]      arburst,
  input  logic            arlock,
  input  logic            arvalid,
  output logic            arready,
  output logic [ID_W-1:0] rid,
  output logic [63:0]     rdata,
  output logic [1:0]      rresp,
  output logic            rlast,
  output logic            rvalid,
  input  logic            rready,
  // the 32-bit subordinate side
  output logic [ID_W-1:0] s_awid,
  output logic [31:0]     s_awaddr,
  output logic [7:0]      s_awlen,
  output logic [2:0]      s_awsize,
  output logic [1:0]      s_awburst,
  output logic            s_awlock,
  output logic            s_awvalid,
  input  logic            s_awready,
  output logic [31:0]     s_wdata,
  output logic [3:0]      s_wstrb,
  output logic            s_wlast,
  output logic            s_wvalid,
  input  logic            s_wready,
  input  logic [ID_W-1:0] s_bid,
  input  logic [1:0]      s_bresp,
  input  logic            s_bvalid,
  output logic            s_bready,
  output logic [ID_W-1:0] s_arid,
  output logic [31:0]     s_araddr,
  output logic [7:0]      s_arlen,
  output logic [2:0]      s_arsize,
  output logic [1:0]      s_arburst,
  output logic            s_arlock,
  output logic            s_arvalid,
  input  logic            s_arready,
  input  logic [ID_W-1:0] s_rid,
  input  logic [31:0]     s_rdata,
  input  logic [1:0]      s_rresp,
  input  logic            s_rlast,
  input  logic            s_rvalid,
  output logic            s_rready
);
  import axi_pkg::*;
  bit trace = 0, no_merge_resp = 0;
  int cycle = -1;
  function automatic logic [1:0] worse(input logic [1:0] a, input logic [1:0] b);
    if (a == DECERR || b == DECERR) return DECERR;
    if (a == SLVERR || b == SLVERR) return SLVERR;
    return a;
  endfunction

  // ---- writes ----
  logic        w_on = 0, w_full = 0, w_half = 0, w_hold = 0;
  logic [31:0] w_addr;
  int          w_len = 0, w_beat = 0;
  logic [2:0]  w_size;
  logic [1:0]  w_burst;
  logic [63:0] w_d;
  logic [7:0]  w_s;
  logic        w_l;
  logic        aw_sent = 0;
  assign awready  = !w_on;
  assign wready   = w_on && !w_hold;
  assign bid      = s_bid;
  assign bresp    = s_bresp;
  assign bvalid   = s_bvalid;
  assign s_bready = bready;
  initial begin s_awvalid = 0; s_wvalid = 0; s_arvalid = 0; rvalid = 0; end

  // ---- reads ----
  logic        r_on = 0, r_full = 0, r_have_low = 0;
  logic [31:0] r_addr;
  int          r_len = 0, r_beat = 0;
  logic [2:0]  r_size;
  logic [1:0]  r_burst;
  logic [31:0] r_low;
  logic [1:0]  r_low_resp;
  assign arready  = !r_on;
  assign s_rready = r_on && (!rvalid || rready);

  int unsigned a;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      w_on <= 0; w_hold <= 0; w_half <= 0; aw_sent <= 0; s_awvalid <= 0; s_wvalid <= 0;
      r_on <= 0; r_have_low <= 0; s_arvalid <= 0; rvalid <= 0;
    end else begin
      // ---------------- writes ----------------
      if (awvalid && awready) begin
        w_on <= 1; w_full <= (awsize == 3); w_addr <= awaddr; w_len <= awlen; w_size <= awsize; w_burst <= awburst; w_beat <= 0;
        s_awvalid <= 1; s_awid <= awid; s_awaddr <= awaddr; s_awburst <= awburst; s_awlock <= awlock;
        s_awsize <= (awsize == 3) ? 3'd2 : awsize;
        s_awlen  <= (awsize == 3) ? 8'(2 * (int'(awlen) + 1) - 1) : awlen;
        if (trace) begin
          if (awsize == 3) $display("down e%0d: AW 0x%0h size 3 len %0d -> size 2 len %0d", cycle, awaddr, awlen, 2 * (int'(awlen) + 1) - 1);
          else $display("down e%0d: AW 0x%0h size %0d len %0d fits: passed unchanged", cycle, awaddr, awsize, awlen);
        end
      end
      if (s_awvalid && s_awready) s_awvalid <= 0;
      // a beat from the manager: hold it, then send one or two 32-bit beats
      if (s_wvalid && s_wready) begin
        if (w_full && !w_half) begin                     // the lower half went; now the upper half
          w_half <= 1; s_wdata <= w_d[63:32]; s_wstrb <= w_s[7:4]; s_wlast <= w_l;
        end else begin
          s_wvalid <= 0; w_hold <= 0; w_half <= 0;
        end
      end
      if (wvalid && wready) begin
        w_d <= wdata; w_s <= wstrb; w_l <= wlast; w_hold <= 1; s_wvalid <= 1; w_half <= 0;
        if (w_full) begin
          s_wdata <= wdata[31:0]; s_wstrb <= wstrb[3:0]; s_wlast <= 0;
          if (trace) $display("down e%0d: W beat %0d split: lanes 0-3 now, lanes 4-7 next", cycle, w_beat);
        end else begin
          a = beat_addr(w_addr, w_len, w_size, w_burst, w_beat);
          s_wdata <= a[2] ? wdata[63:32] : wdata[31:0]; s_wstrb <= a[2] ? wstrb[7:4] : wstrb[3:0]; s_wlast <= wlast;
        end
        w_beat <= w_beat + 1;
      end
      if (bvalid && bready) w_on <= 0;
      // ---------------- reads ----------------
      if (arvalid && arready) begin
        r_on <= 1; r_full <= (arsize == 3); r_addr <= araddr; r_len <= arlen; r_size <= arsize; r_burst <= arburst; r_beat <= 0; r_have_low <= 0;
        s_arvalid <= 1; s_arid <= arid; s_araddr <= araddr; s_arburst <= arburst; s_arlock <= arlock;
        s_arsize <= (arsize == 3) ? 3'd2 : arsize;
        s_arlen  <= (arsize == 3) ? 8'(2 * (int'(arlen) + 1) - 1) : arlen;
        if (trace) begin
          if (arsize == 3) $display("down e%0d: AR 0x%0h size 3 len %0d -> size 2 len %0d", cycle, araddr, arlen, 2 * (int'(arlen) + 1) - 1);
          else $display("down e%0d: AR 0x%0h size %0d len %0d fits: passed unchanged", cycle, araddr, arsize, arlen);
        end
      end
      if (s_arvalid && s_arready) s_arvalid <= 0;
      if (rvalid && rready) begin
        rvalid <= 0;
        if (rlast) r_on <= 0;
      end
      if (s_rvalid && s_rready) begin
        if (r_full && !r_have_low) begin
          r_low <= s_rdata; r_low_resp <= s_rresp; r_have_low <= 1;
        end else if (r_full) begin
          rvalid <= 1; rid <= s_rid; rdata <= {s_rdata, r_low}; rlast <= s_rlast; r_have_low <= 0;
          rresp <= no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp);
          if (trace) $display("down e%0d: R beat %0d merged from two halves: %0s + %0s -> %0s", cycle, r_beat, resp_name(r_low_resp), resp_name(s_rresp),
                              resp_name(no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp)));
          r_beat <= r_beat + 1;
        end else begin
          a = beat_addr(r_addr, r_len, r_size, r_burst, r_beat);
          rvalid <= 1; rid <= s_rid; rdata <= a[2] ? {s_rdata, 32'h0} : {32'h0, s_rdata}; rresp <= s_rresp; rlast <= s_rlast;
          r_beat <= r_beat + 1;
        end
      end
    end
  end
endmodule
Spot the bugEach option sends one write through the downsizer. Which one does the 32-bit memory receive with a different AxLEN or AxSIZE, so that the harness prints FAIL?
Read included file: axi_pkg.sv
`timescale 1ns/1ns
// axi_pkg.sv: the arithmetic of a burst (read-only).
// Every transfer n of a burst has an address and a set of byte lanes, computed from the start
// address, the burst length, the transfer size and the burst type exactly as the AXI specification
// defines them. The memory, the manager tasks and the checker all use these functions, so they
// never disagree about where a byte lands.
package axi_pkg;
  localparam logic [1:0] FIXED = 2'b00, INCR = 2'b01, WRAP = 2'b10;
  localparam logic [1:0] OKAY = 2'b00, EXOKAY = 2'b01, SLVERR = 2'b10, DECERR = 2'b11;

  function automatic string burst_name(input logic [1:0] b);
    case (b) FIXED: return "FIXED"; INCR: return "INCR"; WRAP: return "WRAP"; default: return "RESERVED"; endcase
  endfunction
  function automatic string resp_name(input logic [1:0] r);
    case (r) OKAY: return "OKAY"; EXOKAY: return "EXOKAY"; SLVERR: return "SLVERR"; default: return "DECERR"; endcase
  endfunction

  // Bytes in one transfer: 1, 2, 4, ... 128.
  function automatic int bytes_of(input logic [2:0] size);
    return 1 << size;
  endfunction

  // The address of transfer n (n counts from 0).
  //   transfer 0 uses the start address as given, aligned or not;
  //   later transfers use the start address aligned down to the transfer size, plus n transfers;
  //   a WRAP burst returns to its wrap boundary (the start aligned down to the whole burst) when
  //   it reaches the end of that window; a FIXED burst repeats the start address.
  function automatic int unsigned beat_addr(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n);
    int unsigned nb = 1 << size;
    int unsigned aligned = (start / nb) * nb;
    int unsigned window = nb * (len + 1);
    int unsigned boundary = (start / window) * window;
    int unsigned a;
    if (burst == FIXED || n == 0) return start;
    a = aligned + n * nb;
    // Unsigned offset also works when the window ends at 2**32.
    if (burst == WRAP && (a - boundary) >= window) a = a - window;
    return a;
  endfunction

  // The byte lanes transfer n uses on a bus of bus_bytes bytes, packed as {upper, lower}.
  // Transfer 0 of an unaligned burst (and every transfer of a FIXED burst) uses only the lanes from
  // its address up to the end of its aligned transfer; every other transfer uses all the lanes of
  // its size.
  function automatic logic [15:0] beat_lanes(input int unsigned start, input int len, input logic [2:0] size,
                                             input logic [1:0] burst, input int n, input int bus_bytes);
    int unsigned nb = 1 << size;
    int unsigned a = beat_addr(start, len, size, burst, n);
    int unsigned aligned = (a / nb) * nb;
    int unsigned word = (a / bus_bytes) * bus_bytes;
    int lower = a - word;
    int upper = (n == 0 || burst == FIXED) ? (aligned + nb - 1 - word) : (lower + nb - 1);
    return {upper[7:0], lower[7:0]};
  endfunction

  // The strobe of transfer n: a 1 for every lane it uses (bit l is lane l).
  function automatic logic [63:0] beat_strb(input int unsigned start, input int len, input logic [2:0] size,
                                            input logic [1:0] burst, input int n, input int bus_bytes);
    logic [15:0] lanes = beat_lanes(start, len, size, burst, n, bus_bytes);
    logic [63:0] s = 0;
    for (int l = lanes[7:0]; l <= lanes[15:8]; l++) s[l] = 1'b1;
    return s;
  endfunction

  // True when the burst crosses a 4 KB boundary (only an INCR burst can).
  function automatic bit crosses_4k(input int unsigned start, input int len, input logic [2:0] size, input logic [1:0] burst);
    if (burst != INCR) return 0;
    return (beat_addr(start, len, size, burst, 0) / 4096) != ((beat_addr(start, len, size, burst, len) + (1 << size) - 1) / 4096);
  endfunction
endpackage
Read included file: axi_mem.sv
`timescale 1ns/1ns
// axi_mem.sv: an AXI4 subordinate with a byte-addressed memory behind it (read-only in this lesson).
// It accepts requests on AW and AR, write beats on W (before or after their AW), writes the bytes a
// burst addresses using the strobes, and answers on B and R after a latency. The switches below are
// plain variables: the stimulus sets them by name (mem.reorder = 1;) before it starts.
//   rd_latency, wr_latency   cycles from a request (or its last write beat) to its first response
//   slow_latency, slow_above addresses at or above slow_above answer after slow_latency instead
//   err_above                addresses at or above err_above get SLVERR (and are not written)
//   reorder                  answer transactions with DIFFERENT IDs as soon as each is ready;
//                            transactions with the same ID still answer in order
//   interleave               interleave the read data beats of ready transactions with different IDs
//   excl_on                  support exclusive access (one monitor per ID), else answer OKAY
//   posted                   apply a write to the memory only when its response is sent, so a read
//                            that arrives between the last beat and B still sees the old bytes
//   trace                    print every byte the memory writes
// Broken twins, each off by default: early_b (B before the last write beat and before AW),
// ignore_strobes (write every lane of the bus word), drop_hold (RDATA changes while RVALID waits
// for RREADY), reorder_same_id (a later transaction with the same ID may answer first),
// wrap_bug (a WRAP burst addressed like INCR).
module axi_mem #(parameter int DATA_W = 32, parameter int ID_W = 4, parameter int DEPTH = 65536) (
  input  logic              aclk,
  input  logic              aresetn,
  input  logic [ID_W-1:0]   awid,
  input  logic [31:0]       awaddr,
  input  logic [7:0]        awlen,
  input  logic [2:0]        awsize,
  input  logic [1:0]        awburst,
  input  logic              awlock,
  input  logic [3:0]        awcache,
  input  logic [2:0]        awprot,
  input  logic              awvalid,
  output logic              awready,
  input  logic [DATA_W-1:0] wdata,
  input  logic [DATA_W/8-1:0] wstrb,
  input  logic              wlast,
  input  logic              wvalid,
  output logic              wready,
  output logic [ID_W-1:0]   bid,
  output logic [1:0]        bresp,
  output logic              bvalid,
  input  logic              bready,
  input  logic [ID_W-1:0]   arid,
  input  logic [31:0]       araddr,
  input  logic [7:0]        arlen,
  input  logic [2:0]        arsize,
  input  logic [1:0]        arburst,
  input  logic              arlock,
  input  logic [3:0]        arcache,
  input  logic [2:0]        arprot,
  input  logic              arvalid,
  output logic              arready,
  output logic [ID_W-1:0]   rid,
  output logic [DATA_W-1:0] rdata,
  output logic [1:0]        rresp,
  output logic              rlast,
  output logic              rvalid,
  input  logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int N = 16;                      // transactions in flight per direction

  // ---- switches ----
  int rd_latency = 2, wr_latency = 2, slow_latency = 8;
  int unsigned slow_above = 32'hffff_ffff, err_above = 32'hffff_ffff;
  bit reorder = 0, interleave = 0, excl_on = 0, posted = 0, trace = 0;
  bit early_b = 0, ignore_strobes = 0, drop_hold = 0, reorder_same_id = 0, wrap_bug = 0;

  // ---- the memory ----
  logic [7:0] mem [0:DEPTH-1];
  initial for (int i = 0; i < DEPTH; i++) mem[i] = 8'h00;

  int cycle = -1;
  int seq = 0;                                // every request gets a sequence number: issue order

  // ---- write side: accepted AW requests (a ring) and write beats (a ring) ----
  logic [ID_W-1:0] aw_id [0:N-1];
  int unsigned     aw_addr [0:N-1];
  int              aw_len [0:N-1];
  logic [2:0]      aw_size [0:N-1];
  logic [1:0]      aw_burst [0:N-1];
  logic            aw_lock [0:N-1];
  int aw_head = 0, aw_tail = 0, aw_count = 0;
  localparam int WQ = 1024;
  logic [DATA_W-1:0] w_data [0:WQ-1];
  logic [BUS-1:0]    w_strb [0:WQ-1];
  logic              w_last [0:WQ-1];
  int w_head = 0, w_tail = 0, w_count = 0, w_bursts = 0;   // w_bursts: complete bursts in the ring

  // ---- write responses waiting for their latency ----
  logic            b_use [0:N-1];
  logic [ID_W-1:0] b_id [0:N-1];
  logic [1:0]      b_rsp [0:N-1];
  int              b_at [0:N-1], b_seq [0:N-1];
  logic            b_driving = 0;
  logic            early_done = 0;            // the early_b twin answers once per burst
  // posted writes: the beats of a write kept until its response goes out
  logic [DATA_W-1:0] p_data [0:N-1][0:255];
  logic [BUS-1:0]    p_strb [0:N-1][0:255];
  int unsigned       p_addr [0:N-1];
  int                p_len [0:N-1];
  logic [2:0]        p_size [0:N-1];
  logic [1:0]        p_burst [0:N-1];
  logic              p_pending [0:N-1];

  // ---- read side: accepted AR requests with their progress ----
  logic            r_use [0:N-1];
  logic [ID_W-1:0] r_id [0:N-1];
  int unsigned     r_addr [0:N-1];
  int              r_len [0:N-1];
  logic [2:0]      r_size [0:N-1];
  logic [1:0]      r_burst [0:N-1];
  logic            r_lock [0:N-1];
  int              r_at [0:N-1], r_seq [0:N-1], r_beat [0:N-1], r_served [0:N-1];
  int              r_cur = -1;                // the transaction whose beat is on the wires
  logic            r_driving = 0;

  // ---- exclusive monitors, one per ID ----
  logic        mon_use [0:(1<<ID_W)-1];
  int unsigned mon_addr [0:(1<<ID_W)-1];
  int unsigned mon_bytes [0:(1<<ID_W)-1];

  initial begin
    for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; p_pending[i] = 0; end
    for (int i = 0; i < (1 << ID_W); i++) mon_use[i] = 0;
    awready = 0; wready = 0; arready = 0; bvalid = 0; rvalid = 0; bid = 0; bresp = 0; rid = 0; rresp = 0; rlast = 0; rdata = 0;
  end

  function automatic int latency_of(input int unsigned a, input int base);
    return (a >= slow_above) ? slow_latency : base;
  endfunction
  function automatic logic [1:0] burst_used(input logic [1:0] b);
    return (wrap_bug && b == WRAP) ? INCR : b;
  endfunction

  // ---- selection policies ----
  // The oldest of all pending entries, or the oldest of its ID: the in-order rule of the protocol.
  function automatic bit b_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (b_use[j] && j != i && b_seq[j] < b_seq[i] && (!same_id_only || b_id[j] == b_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit r_oldest(input int i, input bit same_id_only);
    for (int j = 0; j < N; j++)
      if (r_use[j] && j != i && r_seq[j] < r_seq[i] && (!same_id_only || r_id[j] == r_id[i])) return 0;
    return 1;
  endfunction
  function automatic bit b_eligible(input int i);
    if (!b_use[i] || b_at[i] > cycle) return 0;
    if (!reorder) return b_oldest(i, 0);
    return reorder_same_id ? 1 : b_oldest(i, 1);
  endfunction
  function automatic bit r_eligible(input int i);
    if (!r_use[i] || r_at[i] > cycle) return 0;
    if (!reorder) return r_oldest(i, 0);
    return reorder_same_id ? 1 : r_oldest(i, 1);
  endfunction
  function automatic int free_b();
    for (int i = 0; i < N; i++) if (!b_use[i]) return i;
    return -1;
  endfunction
  function automatic int free_r();
    for (int i = 0; i < N; i++) if (!r_use[i]) return i;
    return -1;
  endfunction
  function automatic int pick_b();
    int best = -1;
    for (int i = 0; i < N; i++) if (b_eligible(i) && (best < 0 || b_seq[i] < b_seq[best])) best = i;
    return best;
  endfunction
  function automatic int pick_r();
    int best = -1;
    for (int i = 0; i < N; i++) if (r_eligible(i)) begin
      if (best < 0) best = i;
      else if (interleave ? (r_served[i] < r_served[best]) : (r_seq[i] < r_seq[best])) best = i;
    end
    return best;
  endfunction

  // ---- the bytes of one read beat, as the bus word that holds them ----
  function automatic logic [DATA_W-1:0] read_word(input int unsigned a);
    logic [DATA_W-1:0] d = 0;
    int unsigned word = (a / BUS) * BUS;
    for (int l = 0; l < BUS; l++) d[8*l +: 8] = (word + l < DEPTH) ? mem[word + l] : 8'h00;
    return d;
  endfunction

  // ---- the write of one complete burst into the memory ----
  task automatic write_burst(input int e);
    logic [1:0]  rsp = OKAY;
    logic        do_write = 1, ended = 0;
    int unsigned a, word;
    logic [15:0] lanes;
    int          n = 0, slot;
    int unsigned total = (1 << aw_size[e]) * (aw_len[e] + 1);
    slot = free_b();
    if (aw_lock[e] && excl_on) begin
      if (mon_use[aw_id[e]] && mon_addr[aw_id[e]] == aw_addr[e]) begin
        rsp = EXOKAY;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: the monitor matched, EXOKAY", cycle, aw_id[e], aw_addr[e]);
      end else begin
        do_write = 0;
        $display("mem e%0d: exclusive write id=%0d at 0x%0h: no monitor, OKAY and nothing written", cycle, aw_id[e], aw_addr[e]);
      end
    end
    while (!ended && n <= aw_len[e]) begin
      a = beat_addr(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n);
      lanes = beat_lanes(aw_addr[e], aw_len[e], aw_size[e], burst_used(aw_burst[e]), n, BUS);
      word = (a / BUS) * BUS;
      if (a >= err_above) rsp = SLVERR;
      else if (do_write && posted && slot >= 0) begin
        p_data[slot][n] = w_data[w_head]; p_strb[slot][n] = w_strb[w_head];
      end else if (do_write) begin
        for (int l = 0; l < BUS; l++)
          if ((w_strb[w_head][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = w_data[w_head][8*l +: 8];
            if (trace) $display("mem e%0d: beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, w_data[w_head][8*l +: 8], word + l, l);
          end
      end
      ended = w_last[w_head];                      // a burst ends at its WLAST, whatever AWLEN said
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
      n = n + 1;
    end
    while (!ended) begin                           // beats past AWLEN (a broken manager) are dropped
      ended = w_last[w_head];
      w_head = (w_head + 1) % WQ; w_count = w_count - 1;
    end
    // A write clears every monitor that watches a byte it touched.
    if (do_write)
      for (int i = 0; i < (1 << ID_W); i++)
        if (mon_use[i] && mon_addr[i] < aw_addr[e] + total && aw_addr[e] < mon_addr[i] + mon_bytes[i]) mon_use[i] = 0;
    if (slot >= 0) begin
      b_use[slot] = 1; b_id[slot] = aw_id[e]; b_rsp[slot] = rsp; b_seq[slot] = seq; seq = seq + 1;
      b_at[slot] = cycle + latency_of(aw_addr[e], wr_latency);
      if (posted && do_write) begin
        p_pending[slot] = 1; p_addr[slot] = aw_addr[e]; p_len[slot] = n - 1; p_size[slot] = aw_size[e]; p_burst[slot] = aw_burst[e];
      end
    end
  endtask

  // A posted write reaches the memory when its response goes out.
  task automatic apply_posted(input int i);
    int unsigned a, word;
    for (int n = 0; n <= p_len[i]; n++) begin
      a = beat_addr(p_addr[i], p_len[i], p_size[i], burst_used(p_burst[i]), n);
      word = (a / BUS) * BUS;
      if (a < err_above)
        for (int l = 0; l < BUS; l++)
          if ((p_strb[i][n][l] || ignore_strobes) && word + l < DEPTH) begin
            mem[word + l] = p_data[i][n][8*l +: 8];
            if (trace) $display("mem e%0d: posted beat %0d writes 0x%02h to 0x%0h (lane %0d)", cycle, n, p_data[i][n][8*l +: 8], word + l, l);
          end
    end
    p_pending[i] = 0;
  endtask

  int pick, extra;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      aw_head = 0; aw_tail = 0; aw_count = 0; w_head = 0; w_tail = 0; w_count = 0; w_bursts = 0;
      for (int i = 0; i < N; i++) begin b_use[i] = 0; r_use[i] = 0; end
      b_driving = 0; r_driving = 0; r_cur = -1;
      awready <= 0; wready <= 0; arready <= 0; bvalid <= 0; rvalid <= 0;
    end else begin
      // -- AW: take a request while there is room --
      if (awvalid && awready) begin
        aw_id[aw_tail] = awid; aw_addr[aw_tail] = awaddr; aw_len[aw_tail] = awlen; aw_size[aw_tail] = awsize;
        aw_burst[aw_tail] = awburst; aw_lock[aw_tail] = awlock;
        aw_tail = (aw_tail + 1) % N; aw_count = aw_count + 1;
      end
      // -- W: take a beat while there is room --
      if (wvalid && wready) begin
        w_data[w_tail] = wdata; w_strb[w_tail] = wstrb; w_last[w_tail] = wlast;
        w_tail = (w_tail + 1) % WQ; w_count = w_count + 1;
        if (wlast) w_bursts = w_bursts + 1;
      end
      // -- a complete burst with its request: write it and schedule B --
      if (aw_count > 0 && w_bursts > 0) begin
        write_burst(aw_head);
        aw_head = (aw_head + 1) % N; aw_count = aw_count - 1; w_bursts = w_bursts - 1;
        early_done = 0;
      end else if (early_b && !early_done && w_count > 0 && w_bursts == 0) begin
        // The broken twin: a response as soon as the first write beat arrived, before WLAST and,
        // when the data came first, before the address.
        pick = free_b();
        if (pick >= 0) begin
          b_use[pick] = 1; b_id[pick] = (aw_count > 0) ? aw_id[aw_head] : awid; b_rsp[pick] = OKAY; b_seq[pick] = seq; seq = seq + 1; b_at[pick] = cycle;
          early_done = 1;
        end
      end
      // -- B: finish a handshake, then put the next response on the wires --
      if (b_driving && bready) b_driving = 0;
      if (!b_driving) begin
        pick = pick_b();
        if (pick >= 0) begin
          if (p_pending[pick]) apply_posted(pick);
          b_driving = 1; bid <= b_id[pick]; bresp <= b_rsp[pick]; b_use[pick] = 0;
        end
      end
      bvalid <= b_driving;
      // -- AR: take a request while there is room --
      if (arvalid && arready) begin
        pick = free_r();
        if (pick >= 0) begin
          r_use[pick] = 1; r_id[pick] = arid; r_addr[pick] = araddr; r_len[pick] = arlen; r_size[pick] = arsize; r_burst[pick] = arburst;
          r_lock[pick] = arlock; r_beat[pick] = 0; r_seq[pick] = seq; seq = seq + 1; r_served[pick] = -1;
          r_at[pick] = cycle + latency_of(araddr, rd_latency);
          if (arlock && excl_on) begin
            mon_use[arid] = 1; mon_addr[arid] = araddr; mon_bytes[arid] = (1 << arsize) * (arlen + 1);
            $display("mem e%0d: exclusive read id=%0d at 0x%0h: monitor set", cycle, arid, araddr);
          end
        end
      end
      // -- R: finish a handshake, then put the next beat on the wires --
      if (r_driving && !rready && drop_hold) rdata <= rdata + 1;   // the broken twin: data not held
      if (r_driving && rready) begin
        r_driving = 0;
        if (r_beat[r_cur] > r_len[r_cur]) begin r_use[r_cur] = 0; r_cur = -1; end
        else if (interleave) r_cur = -1;
      end
      if (!r_driving) begin
        pick = (r_cur >= 0) ? r_cur : pick_r();
        if (pick >= 0) begin
          r_cur = pick; r_driving = 1; r_served[pick] = cycle;
          extra = r_beat[pick];
          rid <= r_id[pick];
          rdata <= read_word(beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra));
          rresp <= (beat_addr(r_addr[pick], r_len[pick], r_size[pick], burst_used(r_burst[pick]), extra) >= err_above) ? SLVERR
                 : ((r_lock[pick] && excl_on) ? EXOKAY : OKAY);
          rlast <= (extra == r_len[pick]);
          r_beat[pick] = extra + 1;
        end
      end
      rvalid <= r_driving;
      awready <= (aw_count < N - 1);
      wready  <= (w_count < WQ - 2);
      arready <= 1;
    end
  end
endmodule
Read included file: axi_checker.sv
`timescale 1ns/1ns
// axi_checker.sv: the rules of an AXI4 interface, checked at every rising edge (read-only).
// Each broken rule is named with the channel and the edge where it was seen:
//   reset      a VALID is 1 while reset is active;
//   hold       a VALID dropped before its READY: the offer was withdrawn;
//   stable     a channel's payload changed while its offer waited;
//   known      a payload is x while its VALID is 1;
//   len        a FIXED or WRAP burst longer than 16 beats;
//   wrap       a WRAP burst whose length is not 2, 4, 8 or 16 beats or whose address is not aligned;
//   boundary   a burst that crosses a 4 KB boundary;
//   size       a transfer wider than the data bus;
//   strobe     a write strobe on a lane the beat does not address;
//   wlast      WLAST on the wrong beat (not AWLEN), or missing after it;
//   rlast      RLAST on the wrong beat of the oldest read with that ID, or missing after it;
//   border     BVALID before any outstanding write has its last beat, or before its AW;
//   bid, rid   a response ID with no outstanding request of that ID;
//   exokay     EXOKAY for a request that was not exclusive;
//   exclusive  an exclusive request whose bytes are not a power of two up to 128, or not aligned to them.
// The rules no checker can see on the wires (VALID must not wait for READY; same-ID responses
// in the order of their requests) are checked by the data the tasks compare (lessons P2.2, P2.10).
module axi_checker #(parameter int DATA_W = 32, parameter int ID_W = 4) (
  input logic              aclk,
  input logic              aresetn,
  input logic [ID_W-1:0]   awid,
  input logic [31:0]       awaddr,
  input logic [7:0]        awlen,
  input logic [2:0]        awsize,
  input logic [1:0]        awburst,
  input logic              awlock,
  input logic              awvalid,
  input logic              awready,
  input logic [DATA_W-1:0] wdata,
  input logic [DATA_W/8-1:0] wstrb,
  input logic              wlast,
  input logic              wvalid,
  input logic              wready,
  input logic [ID_W-1:0]   bid,
  input logic [1:0]        bresp,
  input logic              bvalid,
  input logic              bready,
  input logic [ID_W-1:0]   arid,
  input logic [31:0]       araddr,
  input logic [7:0]        arlen,
  input logic [2:0]        arsize,
  input logic [1:0]        arburst,
  input logic              arlock,
  input logic              arvalid,
  input logic              arready,
  input logic [ID_W-1:0]   rid,
  input logic [DATA_W-1:0] rdata,
  input logic [1:0]        rresp,
  input logic              rlast,
  input logic              rvalid,
  input logic              rready
);
  import axi_pkg::*;
  localparam int BUS = DATA_W / 8;
  localparam int Q = 64;
  int cycle = -1, writes = 0, reads = 0, stalls = 0, broken = 0;
  logic [DATA_W-1:0] used;

  function void report(input string rule, input string what);
    broken++;
    $display("RULE %s broken at edge %0d: %s", rule, cycle, what);
  endfunction

  // Previous values of every channel, for hold and stable.
  logic p_awv = 0, p_awr = 0, p_wv = 0, p_wr = 0, p_bv = 0, p_br = 0, p_arv = 0, p_arr = 0, p_rv = 0, p_rr = 0;
  logic [31:0] p_awaddr, p_araddr;
  logic [7:0] p_awlen, p_arlen;
  logic [2:0] p_awsize, p_arsize;
  logic [1:0] p_awburst, p_arburst, p_bresp, p_rresp;
  logic [ID_W-1:0] p_awid, p_arid, p_bid, p_rid;
  logic [DATA_W-1:0] p_wdata, p_rdata;
  logic [BUS-1:0] p_wstrb;
  logic p_wlast, p_rlast, p_awlock, p_arlock;

  // Write requests in order (AXI4 write data follows the order of the addresses).
  int unsigned q_addr [0:Q-1];
  int q_len [0:Q-1];
  logic [2:0] q_size [0:Q-1];
  logic [1:0] q_burst [0:Q-1];
  int aw_n = 0;                 // requests accepted
  int wb_n = 0;                 // write bursts started
  int wb_done = 0;              // write bursts ended (WLAST seen)
  int w_beat = 0;               // beats so far in the current burst
  int b_n = 0;                  // responses given
  // Beats recorded for bursts that ran ahead of their AW: strobes and count, checked when AW arrives.
  logic [BUS-1:0] rec_strb [0:Q-1][0:255];
  int rec_beats [0:Q-1];
  logic rec_open [0:Q-1];
  // Outstanding requests per ID, and the read requests per ID in order.
  int aw_out [0:(1<<ID_W)-1], ar_out [0:(1<<ID_W)-1], aw_excl [0:(1<<ID_W)-1], ar_excl [0:(1<<ID_W)-1];
  int rq_len [0:(1<<ID_W)-1][0:15];
  int rq_head [0:(1<<ID_W)-1], rq_tail [0:(1<<ID_W)-1], r_beat [0:(1<<ID_W)-1];
  initial for (int i = 0; i < (1 << ID_W); i++) begin aw_out[i] = 0; ar_out[i] = 0; aw_excl[i] = 0; ar_excl[i] = 0; rq_head[i] = 0; rq_tail[i] = 0; r_beat[i] = 0; end
  initial for (int i = 0; i < Q; i++) begin rec_beats[i] = 0; rec_open[i] = 0; end

  function automatic bit pow2_le128(input int unsigned n);
    return (n == 1 || n == 2 || n == 4 || n == 8 || n == 16 || n == 32 || n == 64 || n == 128);
  endfunction

  task automatic check_request(input string ch, input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input logic lock);
    int unsigned bytes = (1 << size) * (len + 1);
    if ((burst == FIXED || burst == WRAP) && len > 15) report("len", $sformatf("%s: a %s burst of %0d beats (16 at most)", ch, burst_name(burst), len + 1));
    if (burst == WRAP && !(len == 1 || len == 3 || len == 7 || len == 15)) report("wrap", $sformatf("%s: a WRAP burst of %0d beats (2, 4, 8 or 16)", ch, len + 1));
    if (burst == WRAP && (addr % (1 << size)) != 0) report("wrap", $sformatf("%s: WRAP burst at 0x%0h is not aligned to its %0d-byte transfers", ch, addr, 1 << size));
    if (burst == 2'b11) report("len", $sformatf("%s: burst type 2'b11 is reserved", ch));
    if ((1 << size) > BUS) report("size", $sformatf("%s: %0d-byte transfers on a %0d-byte bus", ch, 1 << size, BUS));
    if (crosses_4k(addr, len, size, burst)) report("boundary", $sformatf("%s: burst at 0x%0h, %0d beats of %0d bytes, crosses a 4 KB boundary", ch, addr, len + 1, 1 << size));
    if (lock && (!pow2_le128(bytes) || (addr % bytes) != 0)) report("exclusive", $sformatf("%s: exclusive access of %0d bytes at 0x%0h (a power of two up to 128, aligned)", ch, bytes, addr));
  endtask

  task automatic check_strobe(input int k, input int n, input logic [BUS-1:0] strb);
    logic [63:0] allowed = beat_strb(q_addr[k % Q], q_len[k % Q], q_size[k % Q], q_burst[k % Q], n, BUS);
    if ((strb & ~allowed[BUS-1:0]) != 0)
      report("strobe", $sformatf("W beat %0d of write %0d: strobe %b on lanes outside %b", n, k, strb, allowed[BUS-1:0]));
  endtask

  always @(posedge aclk) begin
    cycle++;
    if (!aresetn) begin
      if (awvalid === 1 || wvalid === 1 || arvalid === 1) report("reset", "a manager VALID is 1 during reset");
      if (bvalid === 1 || rvalid === 1) report("reset", "a subordinate VALID is 1 during reset");
    end else begin
      // hold, stable and known, per channel
      if (p_awv && !p_awr && awvalid !== 1) report("hold", "AWVALID dropped before AWREADY");
      if (p_awv && !p_awr && awvalid === 1 && (awaddr !== p_awaddr || awlen !== p_awlen || awsize !== p_awsize || awburst !== p_awburst || awid !== p_awid || awlock !== p_awlock)) report("stable", "AW payload changed while the request waited");
      if (p_wv && !p_wr && wvalid !== 1) report("hold", "WVALID dropped before WREADY");
      if (p_wv && !p_wr && wvalid === 1 && (wdata !== p_wdata || wstrb !== p_wstrb || wlast !== p_wlast)) report("stable", "W payload changed while the beat waited");
      if (p_bv && !p_br && bvalid !== 1) report("hold", "BVALID dropped before BREADY");
      if (p_bv && !p_br && bvalid === 1 && (bresp !== p_bresp || bid !== p_bid)) report("stable", "B payload changed while the response waited");
      if (p_arv && !p_arr && arvalid !== 1) report("hold", "ARVALID dropped before ARREADY");
      if (p_arv && !p_arr && arvalid === 1 && (araddr !== p_araddr || arlen !== p_arlen || arsize !== p_arsize || arburst !== p_arburst || arid !== p_arid || arlock !== p_arlock)) report("stable", "AR payload changed while the request waited");
      if (p_rv && !p_rr && rvalid !== 1) report("hold", "RVALID dropped before RREADY");
      if (p_rv && !p_rr && rvalid === 1 && (rdata !== p_rdata || rresp !== p_rresp || rid !== p_rid || rlast !== p_rlast)) report("stable", "R payload changed while the beat waited");
      if (awvalid === 1 && ($isunknown(awaddr) || $isunknown(awlen) || $isunknown(awsize) || $isunknown(awburst) || $isunknown(awid))) report("known", "AW payload is x while AWVALID is 1");
      if (wvalid === 1 && ($isunknown(wstrb) || $isunknown(wlast))) report("known", "W strobe or last is x while WVALID is 1");
      else if (wvalid === 1) begin
        used = '0;
        for (int l = 0; l < BUS; l++) if (wstrb[l] === 1) used[8*l +: 8] = 8'hff;
        if ($isunknown(wdata & used)) report("known", "W data is x on a strobed lane while WVALID is 1");
      end
      if (arvalid === 1 && ($isunknown(araddr) || $isunknown(arlen) || $isunknown(arsize) || $isunknown(arburst) || $isunknown(arid))) report("known", "AR payload is x while ARVALID is 1");
      if (bvalid === 1 && ($isunknown(bresp) || $isunknown(bid))) report("known", "B payload is x while BVALID is 1");
      if (rvalid === 1 && ($isunknown(rresp) || $isunknown(rid) || $isunknown(rlast))) report("known", "R payload is x while RVALID is 1");
      if ((awvalid === 1 && awready !== 1) || (wvalid === 1 && wready !== 1) || (arvalid === 1 && arready !== 1) ||
          (bvalid === 1 && bready !== 1) || (rvalid === 1 && rready !== 1)) stalls++;
      // AW accepted
      if (awvalid === 1 && awready === 1) begin
        check_request("AW", awaddr, awlen, awsize, awburst, awlock);
        q_addr[aw_n % Q] = awaddr; q_len[aw_n % Q] = awlen; q_size[aw_n % Q] = awsize; q_burst[aw_n % Q] = awburst;
        aw_out[awid]++; if (awlock) aw_excl[awid]++;
        // beats of this write that arrived before its address: check them now
        if (rec_beats[aw_n % Q] > 0) begin
          for (int n = 0; n < rec_beats[aw_n % Q]; n++) check_strobe(aw_n, n, rec_strb[aw_n % Q][n]);
          if (!rec_open[aw_n % Q] && rec_beats[aw_n % Q] != awlen + 1)
            report("wlast", $sformatf("write %0d sent %0d beats before its AW said AWLEN=%0d", aw_n, rec_beats[aw_n % Q], awlen));
          if (!rec_open[aw_n % Q]) rec_beats[aw_n % Q] = 0;
        end
        aw_n++;
      end
      // W beat accepted
      if (wvalid === 1 && wready === 1) begin
        if (w_beat == 0) begin wb_n++; rec_beats[(wb_n - 1) % Q] = 0; rec_open[(wb_n - 1) % Q] = 1; end
        if (wb_n <= aw_n) begin
          check_strobe(wb_n - 1, w_beat, wstrb);
          if (wlast === 1 && w_beat != q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("WLAST on beat %0d of write %0d, AWLEN=%0d", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
          if (wlast !== 1 && w_beat == q_len[(wb_n - 1) % Q]) report("wlast", $sformatf("beat %0d of write %0d is AWLEN=%0d but WLAST is 0", w_beat, wb_n - 1, q_len[(wb_n - 1) % Q]));
        end else begin
          rec_strb[(wb_n - 1) % Q][w_beat] = wstrb;
        end
        rec_beats[(wb_n - 1) % Q] = w_beat + 1;
        w_beat++;
        if (wlast === 1) begin w_beat = 0; wb_done++; rec_open[(wb_n - 1) % Q] = 0; if (wb_n <= aw_n) rec_beats[(wb_n - 1) % Q] = 0; end
      end
      // B offered or accepted
      if (bvalid === 1 && !p_bv) begin
        if (b_n >= aw_n && b_n >= wb_done) report("border", "BVALID with no write to answer: neither an AW nor a WLAST is outstanding");
        else if (b_n >= wb_done) report("border", "BVALID before the last beat of the write it answers");
        else if (b_n >= aw_n) report("border", "BVALID before the AW of the write it answers was accepted");
      end
      if (bvalid === 1 && bready === 1) begin
        if (aw_out[bid] == 0) report("bid", $sformatf("B with id %0d, which has no outstanding write", bid));
        else begin
          aw_out[bid]--; writes++;
          if (bresp === EXOKAY && aw_excl[bid] == 0) report("exokay", $sformatf("EXOKAY for write id %0d, which was not exclusive", bid));
          if (aw_excl[bid] > 0 && aw_excl[bid] > aw_out[bid]) aw_excl[bid] = aw_out[bid];
        end
        b_n++;
      end
      // AR accepted
      if (arvalid === 1 && arready === 1) begin
        check_request("AR", araddr, arlen, arsize, arburst, arlock);
        rq_len[arid][rq_tail[arid]] = arlen; rq_tail[arid] = (rq_tail[arid] + 1) % 16;
        ar_out[arid]++; if (arlock) ar_excl[arid]++;
      end
      // R beat accepted
      if (rvalid === 1 && rready === 1) begin
        if (ar_out[rid] == 0) report("rid", $sformatf("R with id %0d, which has no outstanding read", rid));
        else begin
          if (rlast === 1 && r_beat[rid] != rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("RLAST on beat %0d of the oldest read with id %0d, whose ARLEN is %0d", r_beat[rid], rid, rq_len[rid][rq_head[rid]]));
          if (rlast !== 1 && r_beat[rid] == rq_len[rid][rq_head[rid]])
            report("rlast", $sformatf("beat %0d of the oldest read with id %0d is its ARLEN but RLAST is 0", r_beat[rid], rid));
          if (rresp === EXOKAY && ar_excl[rid] == 0) report("exokay", $sformatf("EXOKAY for read id %0d, which was not exclusive", rid));
          r_beat[rid]++;
          if (rlast === 1) begin
            r_beat[rid] = 0; rq_head[rid] = (rq_head[rid] + 1) % 16; ar_out[rid]--; reads++;
            if (ar_excl[rid] > ar_out[rid]) ar_excl[rid] = ar_out[rid];
          end
        end
      end
    end
    p_awv = (awvalid === 1); p_awr = (awready === 1); p_wv = (wvalid === 1); p_wr = (wready === 1);
    p_bv = (bvalid === 1); p_br = (bready === 1); p_arv = (arvalid === 1); p_arr = (arready === 1);
    p_rv = (rvalid === 1); p_rr = (rready === 1);
    p_awaddr = awaddr; p_awlen = awlen; p_awsize = awsize; p_awburst = awburst; p_awid = awid; p_awlock = awlock;
    p_wdata = wdata; p_wstrb = wstrb; p_wlast = wlast; p_bresp = bresp; p_bid = bid;
    p_araddr = araddr; p_arlen = arlen; p_arsize = arsize; p_arburst = arburst; p_arid = arid; p_arlock = arlock;
    p_rdata = rdata; p_rresp = rresp; p_rid = rid; p_rlast = rlast;
  end
  final $display("checker: %0d writes, %0d reads, %0d stalled edges, %0d rules broken", writes, reads, stalls, broken);
endmodule
Read included file: axi_tasks.svh
// axi_tasks.svh: the manager side of the bench, as tasks for the stimulus (read-only).
// Data for a write burst goes in wd[0], wd[1], ... (one entry per beat, the lowest byte at the
// lowest address); the data of a read comes back in rd[0], rd[1], ... with its responses in rr[].
// Every task prints the beat log: one line per handshake, with the edge where it happened.
// `cycle` counts rising edges from 0.
int cycle = -1;
always @(posedge aclk) cycle = cycle + 1;

logic [63:0] wd [0:255];
logic [63:0] rd [0:255];
logic [1:0]  rr [0:255];
logic [63:0] rdq [0:15][0:255];     // read data per ID, for reads collected out of order
logic [1:0]  rrq [0:15][0:255];
int          rdn [0:15];            // beats received per ID
logic [1:0]  last_bresp = 0;
int          last_beats = 0;
// What the task is driving right now, for the waveform scenes: the address and lanes of the beat.
int unsigned beat_a = 0;
logic [7:0]  beat_m = 0;
// quiet = 1 silences the beat log (a predict item can then ask for a dump line instead).
bit          quiet = 0;
// Strobe override: when strb_force is 1, every write beat uses strb_val as it is.
bit          strb_force = 0;
logic [7:0]  strb_val = 8'hff;
// Outstanding read requests per ID, so the tasks know the lanes of the beats that come back.
int unsigned arq_addr [0:15][0:7];
int          arq_len [0:15][0:7];
logic [2:0]  arq_size [0:15][0:7];
logic [1:0]  arq_burst [0:15][0:7];
int          arq_head [0:15], arq_tail [0:15];
initial for (int i = 0; i < 16; i++) begin arq_head[i] = 0; arq_tail[i] = 0; rdn[i] = 0; end
// READY patterns for the response channels: bit (cycle % 16) of the pattern drives the signal.
bit          rpat_on = 0, bpat_on = 0;
logic [15:0] rpat = 16'hffff, bpat = 16'hffff;
always @(posedge aclk) begin
  #1;
  if (rpat_on) rready = rpat[cycle % 16];
  if (bpat_on) bready = bpat[cycle % 16];
end

// A text waveform for the lesson's trace blocks: with watch = 1, one line per rising edge with the
// values sampled at that edge (cycle k of a trace is what edge k sees).
bit watch = 0;
int wave_edge = -1;
always @(posedge aclk) begin
  wave_edge = wave_edge + 1;
  if (watch) $display("wave e%0d: aw=%b%b w=%b%b b=%b%b ar=%b%b r=%b%b awaddr=%h wdata=%h wstrb=%b wlast=%b bid=%h bresp=%b araddr=%h rid=%h rdata=%h rresp=%b rlast=%b",
                      wave_edge, awvalid, awready, wvalid, wready, bvalid, bready, arvalid, arready, rvalid, rready,
                      awaddr, wdata, wstrb, wlast, bid, bresp, araddr, rid, rdata, rresp, rlast);
end

// Drive RREADY (ch = 0) or BREADY (ch = 1) from a 16-bit pattern; 16'hffff restores always ready.
task automatic ready_pattern(input int ch, input logic [15:0] pat);
  if (ch == 0) begin rpat = pat; rpat_on = 1; rready = pat[cycle % 16]; end
  else begin bpat = pat; bpat_on = 1; bready = pat[cycle % 16]; end
endtask

// The write address channel: offer the request and hold it until it is taken.
task automatic aw_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  awid = id; awaddr = addr; awlen = len[7:0]; awsize = size; awburst = burst; awlock = lock; awvalid = 1;
  do @(posedge aclk); while (!awready);
  #1 if (!quiet) $display("e%0d AW id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  awvalid = 0; awaddr = 'x; awlen = 'x; awsize = 'x; awburst = 'x; awid = 'x; awlock = 0;
endtask

// The write data channel: the beats of one burst from wd[first..], each placed in its lanes.
task automatic w_burst(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst, input int first = 0);
  logic [15:0] lanes;
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    beat_a = beat_addr(addr, len, size, burst, n);
    beat_m = strb_force ? strb_val : beat_strb(addr, len, size, burst, n, BUS_BYTES);
    wdata = wd[first + n] << (8 * lanes[7:0]);
    wstrb = beat_m[BUS_BYTES-1:0];
    wlast = (n == len);
    wvalid = 1;
    do @(posedge aclk); while (!wready);
    #1 if (!quiet) $display("e%0d W  beat %0d data=0x%0h strb=%b last=%0d  addr 0x%0h lanes %0d-%0d", cycle, n, wdata, wstrb, wlast, beat_a, lanes[7:0], lanes[15:8]);
  end
  wvalid = 0; wdata = 'x; wstrb = 'x; wlast = 0; beat_m = 0;
endtask

// Wait for the write response of one transaction with this ID.
task automatic b_wait(input logic [ID_W-1:0] id);
  do @(posedge aclk); while (!(bvalid && bready && bid == id));
  last_bresp = bresp;                       // sampled at the edge, before the subordinate moves on
  #1 if (!quiet) $display("e%0d B  id=%0d %0s", cycle, id, resp_name(last_bresp));
endtask

// A complete write. order 0 offers the address, then the first beat one cycle later whether or
// not the address has been taken yet (a manager must never make WVALID wait for AWREADY); 1 offers
// the beats first and the address after beat 0; 2 offers the address and beat 0 in the same cycle.
// Returns after B, with the response in last_bresp.
task automatic axi_write(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                         input logic [1:0] burst, input int order = 0, input logic lock = 0);
  case (order)
    1: fork
         w_burst(addr, len, size, burst);
         begin @(posedge aclk); #1 aw_issue(id, addr, len, size, burst, lock); end
       join
    2: fork
         aw_issue(id, addr, len, size, burst, lock);
         w_burst(addr, len, size, burst);
       join
    default: fork
         aw_issue(id, addr, len, size, burst, lock);
         begin @(posedge aclk); #1 w_burst(addr, len, size, burst); end
       join
  endcase
  b_wait(id);
endtask

// The read address channel: offer the request and remember it for the beats that come back.
task automatic ar_issue(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  arq_addr[id][arq_tail[id]] = addr; arq_len[id][arq_tail[id]] = len; arq_size[id][arq_tail[id]] = size;
  arq_burst[id][arq_tail[id]] = burst; arq_tail[id] = (arq_tail[id] + 1) % 8;
  arid = id; araddr = addr; arlen = len[7:0]; arsize = size; arburst = burst; arlock = lock; arvalid = 1;
  do @(posedge aclk); while (!arready);
  #1 if (!quiet) $display("e%0d AR id=%0d addr=0x%0h len=%0d size=%0d %0s%0s", cycle, id, addr, len, size, burst_name(burst), lock ? " exclusive" : "");
  arvalid = 0; araddr = 'x; arlen = 'x; arsize = 'x; arburst = 'x; arid = 'x; arlock = 0;
endtask

// Collect read beats until n transactions have ended (their RLAST). Each beat lands in rdq[rid][k]
// with only the bytes of the transfer (lane-shifted down), and rd[] holds the last transaction.
task automatic r_collect(input int n);
  int done = 0, h;
  logic [15:0] lanes;
  logic [63:0] bytes;
  logic [ID_W-1:0] id;
  logic [DATA_W-1:0] data;
  logic [1:0] resp;
  logic last;
  while (done < n) begin
    do @(posedge aclk); while (!(rvalid && rready));
    id = rid; data = rdata; resp = rresp; last = rlast;   // sampled at the edge, before the subordinate moves on
    h = arq_head[id];
    lanes = beat_lanes(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    beat_a = beat_addr(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id]);
    beat_m = beat_strb(arq_addr[id][h], arq_len[id][h], arq_size[id][h], arq_burst[id][h], rdn[id], BUS_BYTES);
    bytes = (data >> (8 * lanes[7:0])) & ((64'h1 << (8 * (lanes[15:8] - lanes[7:0] + 1))) - 1);
    rdq[id][rdn[id]] = bytes; rrq[id][rdn[id]] = resp;
    #1 if (!quiet) $display("e%0d R  id=%0d beat %0d data=0x%0h %0s%0s  addr 0x%0h lanes %0d-%0d", cycle, id, rdn[id], bytes, resp_name(resp),
                last ? " last" : "", beat_a, lanes[7:0], lanes[15:8]);
    rdn[id] = rdn[id] + 1;
    if (last) begin
      for (int k = 0; k < rdn[id]; k++) begin rd[k] = rdq[id][k]; rr[k] = rrq[id][k]; end
      last_beats = rdn[id]; rdn[id] = 0; arq_head[id] = (h + 1) % 8; done = done + 1;
    end
  end
  beat_m = 0;
endtask

// A complete read: AR, then every beat, into rd[] and rr[].
task automatic axi_read(input logic [ID_W-1:0] id, input int unsigned addr, input int len, input logic [2:0] size,
                        input logic [1:0] burst, input logic lock = 0);
  ar_issue(id, addr, len, size, burst, lock);
  r_collect(1);
endtask

// The table of a burst before it runs: the address, lanes and strobe of every beat.
task automatic beat_table(input int unsigned addr, input int len, input logic [2:0] size, input logic [1:0] burst);
  logic [15:0] lanes;
  logic [63:0] s;
  int unsigned a;
  $display("burst at 0x%0h: %0d beat%0s of %0d byte%0s, %0s, bus %0d bytes", addr, len + 1, len ? "s" : "", 1 << size, size ? "s" : "",
           burst_name(burst), BUS_BYTES);
  $display("  beat  address  lanes  strobe");
  for (int n = 0; n <= len; n++) begin
    lanes = beat_lanes(addr, len, size, burst, n, BUS_BYTES);
    s = beat_strb(addr, len, size, burst, n, BUS_BYTES);
    a = beat_addr(addr, len, size, burst, n);
    $display("  %4d  0x%05h  %0d-%0d    %b", n, a[19:0], lanes[7:0], lanes[15:8], s[BUS_BYTES-1:0]);
  end
  if (crosses_4k(addr, len, size, burst)) $display("  this burst crosses a 4 KB boundary");
endtask

// One byte of the memory that owns an address (the fabric's second memory above 0x8000).
function automatic logic [7:0] mem_byte(input int unsigned a);
`ifdef AXI_MEM1
  if (a >= 32'h8000) return `AXI_MEM1.mem[a];
`endif
  return `AXI_MEM.mem[a];
endfunction
task automatic set_byte(input int unsigned a, input logic [7:0] v);
`ifdef AXI_MEM1
  if (a >= 32'h8000) `AXI_MEM1.mem[a] = v;
  else `AXI_MEM.mem[a] = v;
`else
  `AXI_MEM.mem[a] = v;
`endif
endtask

// A big-endian manager's view of a value: the most significant byte goes to the lowest address.
// Byte-invariant lanes never swap anything; the manager does, before the value reaches wd[].
function automatic logic [15:0] be16(input logic [15:0] v);
  return {v[7:0], v[15:8]};
endfunction
function automatic logic [31:0] be32(input logic [31:0] v);
  return {v[7:0], v[15:8], v[23:16], v[31:24]};
endfunction

// The memory, n bytes from addr, one bus word per group.
task automatic dump(input int unsigned addr, input int n);
  string line;
  int unsigned a = (addr / 16) * 16;
  while (a < addr + n) begin
    line = $sformatf("0x%05h ", a[19:0]);
    for (int i = 0; i < 16; i++) begin
      if (i % BUS_BYTES == 0) line = {line, " "};
      line = {line, $sformatf(" %02h", mem_byte(a + i))};
    end
    $display("%s", line);
    a = a + 16;
  end
endtask

// Fill n bytes from addr with first, first+1, ... so untouched bytes stay recognisable.
task automatic mem_fill(input int unsigned addr, input int n, input logic [7:0] first = 8'h00);
  for (int i = 0; i < n; i++) set_byte(addr + i, first + i[7:0]);
endtask

// Drive nothing for n cycles.
task automatic idle(input int n);
  repeat (n) @(posedge aclk);
  #1;
endtask
Read included file: axi_down.sv
`timescale 1ns/1ns
// axi_down.sv: a downsizer from a 64-bit manager port to a 32-bit subordinate port (read-only).
// One write and one read at a time, INCR bursts. A full-width request (AxSIZE = 3, eight bytes per
// beat) cannot fit the narrow bus, so it is modified whatever its AxCACHE: AxSIZE becomes 2, AxLEN
// becomes 2 x (AxLEN + 1) - 1, the address is kept, and every write beat leaves as two halves,
// lanes 0-3 first. Two read beats are merged into one, and the merged beat carries the worse of
// the two responses. A narrow request (AxSIZE 2 or less) already fits and passes unchanged, with
// its data moved between the half of the 64-bit word its address names and the 32-bit lanes.
// Limits: a full-width request must start 8-byte aligned (an unaligned start would send its lower
// lanes to the wrong word) and have AxLEN up to 127; WRAP and FIXED bursts are not converted.
// Switches: trace prints every conversion; no_merge_resp (the broken twin) gives a merged read
// beat the response of its first half only.
module axi_down #(parameter int ID_W = 4) (
  input  logic            aclk,
  input  logic            aresetn,
  // the 64-bit manager side
  input  logic [ID_W-1:0] awid,
  input  logic [31:0]     awaddr,
  input  logic [7:0]      awlen,
  input  logic [2:0]      awsize,
  input  logic [1:0]      awburst,
  input  logic            awlock,
  input  logic            awvalid,
  output logic            awready,
  input  logic [63:0]     wdata,
  input  logic [7:0]      wstrb,
  input  logic            wlast,
  input  logic            wvalid,
  output logic            wready,
  output logic [ID_W-1:0] bid,
  output logic [1:0]      bresp,
  output logic            bvalid,
  input  logic            bready,
  input  logic [ID_W-1:0] arid,
  input  logic [31:0]     araddr,
  input  logic [7:0]      arlen,
  input  logic [2:0]      arsize,
  input  logic [1:0]      arburst,
  input  logic            arlock,
  input  logic            arvalid,
  output logic            arready,
  output logic [ID_W-1:0] rid,
  output logic [63:0]     rdata,
  output logic [1:0]      rresp,
  output logic            rlast,
  output logic            rvalid,
  input  logic            rready,
  // the 32-bit subordinate side
  output logic [ID_W-1:0] s_awid,
  output logic [31:0]     s_awaddr,
  output logic [7:0]      s_awlen,
  output logic [2:0]      s_awsize,
  output logic [1:0]      s_awburst,
  output logic            s_awlock,
  output logic            s_awvalid,
  input  logic            s_awready,
  output logic [31:0]     s_wdata,
  output logic [3:0]      s_wstrb,
  output logic            s_wlast,
  output logic            s_wvalid,
  input  logic            s_wready,
  input  logic [ID_W-1:0] s_bid,
  input  logic [1:0]      s_bresp,
  input  logic            s_bvalid,
  output logic            s_bready,
  output logic [ID_W-1:0] s_arid,
  output logic [31:0]     s_araddr,
  output logic [7:0]      s_arlen,
  output logic [2:0]      s_arsize,
  output logic [1:0]      s_arburst,
  output logic            s_arlock,
  output logic            s_arvalid,
  input  logic            s_arready,
  input  logic [ID_W-1:0] s_rid,
  input  logic [31:0]     s_rdata,
  input  logic [1:0]      s_rresp,
  input  logic            s_rlast,
  input  logic            s_rvalid,
  output logic            s_rready
);
  import axi_pkg::*;
  bit trace = 0, no_merge_resp = 0;
  int cycle = -1;
  function automatic logic [1:0] worse(input logic [1:0] a, input logic [1:0] b);
    if (a == DECERR || b == DECERR) return DECERR;
    if (a == SLVERR || b == SLVERR) return SLVERR;
    return a;
  endfunction

  // ---- writes ----
  logic        w_on = 0, w_full = 0, w_half = 0, w_hold = 0;
  logic [31:0] w_addr;
  int          w_len = 0, w_beat = 0;
  logic [2:0]  w_size;
  logic [1:0]  w_burst;
  logic [63:0] w_d;
  logic [7:0]  w_s;
  logic        w_l;
  logic        aw_sent = 0;
  assign awready  = !w_on;
  assign wready   = w_on && !w_hold;
  assign bid      = s_bid;
  assign bresp    = s_bresp;
  assign bvalid   = s_bvalid;
  assign s_bready = bready;
  initial begin s_awvalid = 0; s_wvalid = 0; s_arvalid = 0; rvalid = 0; end

  // ---- reads ----
  logic        r_on = 0, r_full = 0, r_have_low = 0;
  logic [31:0] r_addr;
  int          r_len = 0, r_beat = 0;
  logic [2:0]  r_size;
  logic [1:0]  r_burst;
  logic [31:0] r_low;
  logic [1:0]  r_low_resp;
  assign arready  = !r_on;
  assign s_rready = r_on && (!rvalid || rready);

  int unsigned a;
  always @(posedge aclk) begin
    cycle = cycle + 1;
    if (!aresetn) begin
      w_on <= 0; w_hold <= 0; w_half <= 0; aw_sent <= 0; s_awvalid <= 0; s_wvalid <= 0;
      r_on <= 0; r_have_low <= 0; s_arvalid <= 0; rvalid <= 0;
    end else begin
      // ---------------- writes ----------------
      if (awvalid && awready) begin
        w_on <= 1; w_full <= (awsize == 3); w_addr <= awaddr; w_len <= awlen; w_size <= awsize; w_burst <= awburst; w_beat <= 0;
        s_awvalid <= 1; s_awid <= awid; s_awaddr <= awaddr; s_awburst <= awburst; s_awlock <= awlock;
        s_awsize <= (awsize == 3) ? 3'd2 : awsize;
        s_awlen  <= (awsize == 3) ? 8'(2 * (int'(awlen) + 1) - 1) : awlen;
        if (trace) begin
          if (awsize == 3) $display("down e%0d: AW 0x%0h size 3 len %0d -> size 2 len %0d", cycle, awaddr, awlen, 2 * (int'(awlen) + 1) - 1);
          else $display("down e%0d: AW 0x%0h size %0d len %0d fits: passed unchanged", cycle, awaddr, awsize, awlen);
        end
      end
      if (s_awvalid && s_awready) s_awvalid <= 0;
      // a beat from the manager: hold it, then send one or two 32-bit beats
      if (s_wvalid && s_wready) begin
        if (w_full && !w_half) begin                     // the lower half went; now the upper half
          w_half <= 1; s_wdata <= w_d[63:32]; s_wstrb <= w_s[7:4]; s_wlast <= w_l;
        end else begin
          s_wvalid <= 0; w_hold <= 0; w_half <= 0;
        end
      end
      if (wvalid && wready) begin
        w_d <= wdata; w_s <= wstrb; w_l <= wlast; w_hold <= 1; s_wvalid <= 1; w_half <= 0;
        if (w_full) begin
          s_wdata <= wdata[31:0]; s_wstrb <= wstrb[3:0]; s_wlast <= 0;
          if (trace) $display("down e%0d: W beat %0d split: lanes 0-3 now, lanes 4-7 next", cycle, w_beat);
        end else begin
          a = beat_addr(w_addr, w_len, w_size, w_burst, w_beat);
          s_wdata <= a[2] ? wdata[63:32] : wdata[31:0]; s_wstrb <= a[2] ? wstrb[7:4] : wstrb[3:0]; s_wlast <= wlast;
        end
        w_beat <= w_beat + 1;
      end
      if (bvalid && bready) w_on <= 0;
      // ---------------- reads ----------------
      if (arvalid && arready) begin
        r_on <= 1; r_full <= (arsize == 3); r_addr <= araddr; r_len <= arlen; r_size <= arsize; r_burst <= arburst; r_beat <= 0; r_have_low <= 0;
        s_arvalid <= 1; s_arid <= arid; s_araddr <= araddr; s_arburst <= arburst; s_arlock <= arlock;
        s_arsize <= (arsize == 3) ? 3'd2 : arsize;
        s_arlen  <= (arsize == 3) ? 8'(2 * (int'(arlen) + 1) - 1) : arlen;
        if (trace) begin
          if (arsize == 3) $display("down e%0d: AR 0x%0h size 3 len %0d -> size 2 len %0d", cycle, araddr, arlen, 2 * (int'(arlen) + 1) - 1);
          else $display("down e%0d: AR 0x%0h size %0d len %0d fits: passed unchanged", cycle, araddr, arsize, arlen);
        end
      end
      if (s_arvalid && s_arready) s_arvalid <= 0;
      if (rvalid && rready) begin
        rvalid <= 0;
        if (rlast) r_on <= 0;
      end
      if (s_rvalid && s_rready) begin
        if (r_full && !r_have_low) begin
          r_low <= s_rdata; r_low_resp <= s_rresp; r_have_low <= 1;
        end else if (r_full) begin
          rvalid <= 1; rid <= s_rid; rdata <= {s_rdata, r_low}; rlast <= s_rlast; r_have_low <= 0;
          rresp <= no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp);
          if (trace) $display("down e%0d: R beat %0d merged from two halves: %0s + %0s -> %0s", cycle, r_beat, resp_name(r_low_resp), resp_name(s_rresp),
                              resp_name(no_merge_resp ? r_low_resp : worse(r_low_resp, s_rresp)));
          r_beat <= r_beat + 1;
        end else begin
          a = beat_addr(r_addr, r_len, r_size, r_burst, r_beat);
          rvalid <= 1; rid <= s_rid; rdata <= a[2] ? {s_rdata, 32'h0} : {32'h0, s_rdata}; rresp <= s_rresp; rlast <= s_rlast;
          r_beat <= r_beat + 1;
        end
      end
    end
  end
endmodule
ConceptA Non-modifiable write of two 8-byte beats reaches a 64-to-32-bit downsizer. What may the downsizer do?
ConceptAn upsizer between a 32-bit manager and a 64-bit memory receives a 4-beat INCR write of 4-byte beats with AWCACHE 0b0000. What must it do?
ConceptWhy does the downsizer send lanes 0 to 3 of a 64-bit write beat before lanes 4 to 7?

Common Mistakes

Wrong Keep AxSIZE on a downsizer because the request is Non-modifiable.

A size larger than the bus is illegal, so the request cannot reach the memory unchanged.

Fix Halve AxSIZE and double AxLEN. The specification allows this change even for Non-modifiable requests.

Wrong Give a merged read beat the response of one of its halves.

An error in the other half disappears, and the manager uses invalid data.

Fix Give the merged beat the worse of the two responses.

Before
rresp <= s_rresp;          // the half that arrived last
After
rresp <= worse(low_resp, s_rresp);

Wrong Pack narrow beats in an upsizer whenever the wide bus is free.

Packing changes AxSIZE and AxLEN, which is forbidden for a Non-modifiable request.

Fix Steer lanes for every request; pack only when AxCACHE[1] is 1.

Remember

  • An upsizer steers lanes and strobes and passes AxSIZE and AxLEN unchanged; it may pack beats only for a Modifiable request.
  • A downsizer must modify a full-width request, whatever its AxCACHE: AxSIZE halves, AxLEN doubles, the address stays.
  • Each write beat splits into two halves, lower addresses first, and WLAST moves to the last half.
  • Two read halves merge into one beat with the worse of their two responses, so no error is hidden.
  • A request that already fits the narrow bus passes unchanged; only its data moves between lanes.

Practice

Report a problem with this page