The interconnect isn't just wires and a decoder. It's a piece of logic in its own right - it arbitrates between masters that want the bus at the same time, it holds many transactions in flight at once, and it has to hand every response back in an order the protocol actually allows. Get any of that wrong, and every block attached to the fabric can be perfectly correct while the chip still hangs or corrupts data.
10 min read | Intermediate Level
What You'll Learn
- What the interconnect is actually responsible for, beyond routing an address to the right slave
- Why same-ID transactions must come back in order, and how to check the interconnect actually preserves that
- How to verify arbitration is fair, and that QoS settings actually change who wins
- Why outstanding-transaction capacity is a real hardware limit that needs its own tests
- Why deadlock in an interconnect is a system-level bug that simulation is bad at finding
What the Interconnect Is Actually Responsible For
Decode - working out which slave an address belongs to - is the easy part, and it's a single lookup. The harder job is everything that happens once several masters want the fabric at the same moment: deciding whose request goes first, holding each master's requests until their slaves respond, and routing every response back to the master that issued it, in an order the protocol permits.
That scheduling and bookkeeping logic is where interconnect-specific bugs live, and none of it shows up by testing one master against one slave in isolation.
Same-ID Ordering: The Rule the Interconnect Must Preserve
AXI allows a master to have several transactions outstanding at once, tagged with a transaction ID. The protocol's ordering rule is specific: responses for the same ID have to come back in the order the requests were issued, but responses for different IDs can come back in any order, including out of the order they were sent.
An interconnect that reorders two same-ID transactions, even correctly on every other count, has broken the protocol.
Verifying this means issuing several transactions on the same ID, from the same master, deliberately to a slave that responds slowly first and quickly second - the exact case that tempts an interconnect to let the faster response through ahead of the slower one:
class id_order_checker extends uvm_subscriber #(axi_bus_item);
`uvm_component_utils(id_order_checker)
// One FIFO of expected responses per ID, in issue order
uvm_tlm_analysis_fifo #(axi_bus_item) exp_q[bit [3:0]];
virtual function void write(axi_bus_item rsp);
axi_bus_item exp;
if (!exp_q.exists(rsp.id) || !exp_q[rsp.id].try_get(exp))
`uvm_error("ORDER", $sformatf("Unexpected response on ID %0d", rsp.id))
else if (exp.addr !== rsp.addr)
`uvm_error("ORDER",
$sformatf("ID %0d returned out of order: expected addr 0x%0h, got 0x%0h",
rsp.id, exp.addr, rsp.addr))
endfunction
endclass
This checker only tracks order within one ID - it says nothing about how IDs interleave with each other, which is legal by design. Reusing the same passive-agent monitor setup from earlier in this series to feed both an ordering checker like this one and a data-integrity scoreboard is a normal pattern, not a special case.
Arbitration Fairness and QoS
Most interconnects arbitrate with something like round-robin by default, and add priority levels or an AXI QoS signal on top so latency-sensitive masters - a display controller close to underrun, for instance - can jump ahead of less urgent traffic like a background DMA copy. Two different things need checking here, and they're easy to conflate.
Fairness verification confirms a low-priority master isn't starved forever just because a high-priority one keeps the bus busy. QoS verification confirms the priority signal actually changes arbitration outcomes - that a transaction marked high-QoS measurably gets better latency or bandwidth than the same transaction marked low-QoS, not just that the signal is wired somewhere.
A useful test pattern for both: run two masters continuously contending for the same slave, one at each priority level, and measure each one's actual grant rate over a long window. Fairness looks like every master's rate staying above zero. QoS looks like the high-priority master's rate changing measurably when its QoS field changes, with everything else held constant.
How Many Transactions Can Be In Flight at Once
An interconnect can only hold so many outstanding transactions before it has to push back - a fixed number of buffer entries per ID, per master port, or for the fabric overall. That limit is a real hardware constraint, and it needs verifying from both directions.
Under the limit, a master issuing right up to its maximum outstanding count has to get every response back correctly, with nothing dropped or corrupted because the buffers were nearly full. At the limit, the interconnect has to apply backpressure - stall the master, not silently drop a request or return a bogus response - the moment its capacity for that ID or port is exhausted.
Mistake: Only testing typical outstanding counts, never the fabric's actual maximum.
Buffer-boundary bugs, by definition, only show up at the boundary. A regression that never pushes a master to its real maximum outstanding count leaves the code path that handles a full buffer completely unverified.
Deadlock: When Legal Local Behavior Creates a Global Stall
A deadlock in an interconnect rarely comes from one block doing something illegal. It comes from several blocks each behaving correctly on their own, in a combination that adds up to no forward progress anywhere - one path waiting on a buffer that can't drain because draining it depends on a resource held by a second path that's waiting on the first.
Every individual step in that chain can look like ordinary legal traffic; the bug only exists in how the pieces compose.
That compositional nature is exactly why simulation struggles here. The state combination that triggers a real deadlock usually needs a very specific mix of arbitration decisions, buffer occupancy, and timing alignment across multiple masters at once - the kind of coincidence random stimulus rarely reproduces, and a directed test can't target without already knowing where the deadlock is.
Formal tools built for this ask a different question than a simulation test does: not "did this scenario complete," but "can this fabric reach a state with a pending transaction and no way to make progress, under any legal sequence of events at all." One published case study using this kind of architectural formal analysis found nine deadlock bugs that had gone undetected through simulation-based verification.
Exclusive Access Across a Shared Fabric
AXI's exclusive access mechanism lets a master read a location, do some work, and write it back only if nothing else touched that location in between - the basis for lock-free synchronization primitives software relies on. The AXI spec assigns the monitoring itself to the slave: it's the slave that's supposed to track which address is reserved for which master's ID, and fail the follow-up exclusive write if another master wrote there first.
In practice, on an SoC where several masters reach a plain memory controller through a shared fabric, that memory controller often doesn't implement exclusive monitoring itself - so the interconnect ends up hosting an exclusive monitor of its own, sitting at the port facing the slave, since it's the only place that can see every master's writes headed at that address.
Verifying this means deliberately racing a second master's write against the first master's exclusive read-modify-write, timed to land in the window between the two, and confirming the exclusive write correctly reports failure - and separately, confirming it correctly succeeds when nothing else touches that address in between. Missing either direction leaves a synchronization primitive that either falsely succeeds under contention or needlessly fails when there was no contention at all.
Common Mistakes
Mistake: Verifying ordering and QoS with only one master active at a time.
Ordering violations, unfair arbitration, and QoS effects all depend on genuine contention. A single active master never exercises the arbitration logic at all - it always wins by default.
Mistake: Assuming a passing directed regression means the interconnect can't deadlock.
A deadlock is a property of state combinations a directed test wasn't written to hit. Passing regression proves the tested scenarios complete; it says nothing about the scenarios nobody thought to write.
Mistake: Testing exclusive access with only one master, never a real intervening write from another.
An exclusive access sequence run alone always succeeds, whether or not the interconnect actually tracks anything. The mechanism is only proven by racing a real second-master write into the window and confirming the failure case is caught too.
Summary
In this article, you learned:
- The interconnect arbitrates between contending masters, holds transactions in flight, and routes responses back correctly - a job with its own class of bugs beyond address decode
- AXI requires same-ID responses to return in issue order while different IDs can complete in any order, and that rule needs a dedicated per-ID ordering checker to verify
- Fairness and QoS are two different properties: fairness means no master is starved, QoS means the priority signal measurably changes arbitration outcomes
- Outstanding-transaction capacity is a real hardware limit, and both the in-capacity behavior and the backpressure at the limit need explicit tests
- Interconnect deadlock is usually a compositional bug from legal local behavior, which is exactly why simulation struggles to find it and formal analysis has been shown to catch what simulation missed
- The AXI spec assigns exclusive-access monitoring to the slave, but a shared fabric's memory controller often can't do it alone, so the interconnect commonly hosts the actual monitor - either way, verifying it means racing a real conflicting write into the window, not just running one master alone