HSPLIT & HLOCK

This chapter covers two arbiter-facing signals from full multi-master AHB: HSPLIT and HLOCK. HSPLIT belongs to the SPLIT mechanism — a clever (and complex) legacy feature that let a slow subordinate temporarily free the shared bus for other masters instead of stalling everyone, then resume later. HLOCK is the master's lock request, the request side of the HMASTLOCK locking we met in chapter 3.11. Both are full-AHB multi-master signals, and SPLIT (with HSPLIT) was removed in AHB5 as bus matrices solved the same problem more cleanly. We cover the SPLIT flow, HLOCK's role, and why SPLIT was retired — useful both for legacy work and for understanding the evolution to modern AHB.

1. What Is It?

These are two signals that masters and subordinates use to talk to the arbiter:

• HSPLIT is a bus from a split-capable subordinate to the arbiter, with one bit per master. When a subordinate has SPLIT a master's transfer (deferred it and freed the bus), it later asserts that master's HSPLIT bit to tell the arbiter "I can resume this master's transfer now."
• HLOCK is a master's lock request to the arbiter: the master asserts it (with its bus request) to say "the upcoming sequence must be locked." The arbiter responds by driving HMASTLOCK (chapter 3.11) and holding the grant on that master for the locked sequence.

The framing: both are arbiter-facing signals that adjust arbitration. HSPLIT lets a subordinate un-defer a master it previously SPLIT — feedback into the arbiter to re-grant that master. HLOCK lets a master demand atomicity — input to the arbiter to hold the grant. They are distinct mechanisms (SPLIT-resume vs lock-request) that share the property of being how subordinates and masters influence the arbiter beyond the basic request/grant. Both are full multi-master AHB; AHB-Lite has neither.

2. Why Does It Exist?

The two signals solve two different multi-master problems, both involving the arbiter.

Why HSPLIT (the SPLIT mechanism). On a single shared bus, a very slow subordinate is a problem: if it just inserts wait states (HREADY low), it stalls the entire bus for its whole long latency, blocking every other master. SPLIT was AHB's clever answer: instead of stalling everyone, a slow subordinate could respond SPLIT, which tells the arbiter to defer that master's transfer, free the bus for other masters to use productively, and mask the deferred master off. Later, when the slow subordinate has the data ready, it asserts the master's HSPLIT bit, the arbiter un-masks and re-grants that master, and the transfer completes. So HSPLIT exists to let a high-latency subordinate release the shared bus during its long latency rather than monopolizing it — a real utilization win on a single shared bus with a slow responder.

Why HLOCK. As covered in chapter 3.11, multi-master systems need atomic read-modify-write sequences (semaphores). A master signals its intent to perform such a sequence with HLOCK — the request for a lock — and the arbiter honours it by asserting HMASTLOCK and not regranting the bus until the lock releases. HLOCK exists as the master's way to ask for atomicity; it is the request side of the locking mechanism whose grant-side reflection is HMASTLOCK. Without HLOCK, a master would have no way to tell the arbiter "do not let anyone interrupt my next sequence."

Why SPLIT was removed. SPLIT/HSPLIT achieved its goal but at a steep complexity cost: the arbiter had to track split masters and masks, subordinates had to remember which master to resume (via HMASTER), and the interaction of SPLIT with the pipeline and other responses was notoriously hard to verify. AHB5 removed SPLIT (and RETRY) because the same problem — keeping the system productive despite a slow subordinate — is solved more cleanly by a bus matrix: with parallel paths, a master waiting on a slow subordinate on one layer does not block masters using other subordinates on other layers, so there is no need for the slow subordinate to explicitly free a shared bus. So HSPLIT exists in legacy AHB to work around the single-shared-bus limitation, and it was retired once interconnect topologies made it unnecessary.

So HSPLIT exists to free a shared bus from a slow slave (legacy), and HLOCK exists to request atomicity. Both shape arbitration; HSPLIT's whole reason for being was superseded by the bus matrix.

3. Mental Model

Model SPLIT as a deli counter where a customer with a special order steps aside so the line keeps moving, and is called back when their order is ready.

At a deli with one counter (shared bus), a customer (master) places an order with a slow station (slow subordinate) that will take a while. Instead of making the whole line wait, the clerk says "step aside, I'll call you when it's ready" (SPLIT) — the customer is set aside (masked off), and the line keeps moving (other masters use the bus). When the slow station finishes the order, it signals the clerk "customer N's order is ready" (HSPLIT bit for master N), and the clerk calls that customer back (re-grants master N) to complete. The line stayed productive instead of stalling behind one slow order.

HLOCK, by contrast, is a customer telling the clerk "I have a two-part order that must be done together — don't serve anyone else in between" (lock request), and the clerk honouring it (HMASTLOCK) by not calling the next customer until the two-part order is done.

Watch an HLOCK request turning into a lock:

The model's lesson: SPLIT (HSPLIT) sets a slow order aside so the line keeps moving and calls it back when ready; HLOCK is a customer demanding an uninterrupted two-part order. Both are how the counter (arbiter) is told to adjust who it serves and when.

4. Real Hardware Perspective

In hardware, HSPLIT is a per-master bus from split-capable subordinates to the arbiter, and HLOCK is a master output the arbiter consumes.

The SPLIT flow works like this in hardware: a split-capable subordinate that cannot complete a transfer responds SPLIT (on the legacy 2-bit HRESP). The arbiter, seeing SPLIT, masks off the requesting master (stops granting it) and frees the bus for other masters, remembering which master was split (it knows from HMASTER). The subordinate, meanwhile, latched HMASTER so it knows which master to resume. When the subordinate has the data ready, it asserts that master's bit on the HSPLIT bus to the arbiter; the arbiter un-masks the master, re-grants it, and the deferred transfer completes. So HSPLIT is the subordinate→arbiter feedback that re-enables a split master — one bit per master so the subordinate can name exactly who to resume.

HLOCK is simpler: a master drives HLOCK to the arbiter (typically asserted with its HBUSREQ, ahead of the locked transfers) to request that the sequence be locked. The arbiter consumes HLOCK and, while honouring it, asserts HMASTLOCK (visible to subordinates) and holds the grant on that master — refusing to grant another master — until the lock releases. So HLOCK→arbiter→HMASTLOCK is the request-to-effect chain for locking. The master controls the lock's duration by how long it asserts HLOCK across its sequence.

The hardware complexity of SPLIT is worth appreciating, because it explains the retirement. The arbiter must maintain per-master split state (which masters are split and masked), correctly handle the masking and un-masking, and interact with the rest of arbitration; subordinates must track HMASTER and drive HSPLIT correctly; and all of this must compose with the pipeline and other responses. This is a lot of state and corner cases — a verification burden. By contrast, HLOCK/HMASTLOCK is much simpler (hold the grant), which is why locking survived in some form while SPLIT did not. AHB5 removed SPLIT/HSPLIT, leaving the cleaner OKAY/ERROR response model and relying on bus matrices for slow-subordinate utilization.

5. System Architecture Perspective

At the system level, HSPLIT and HLOCK reflect two system needs — utilization despite slow subordinates and atomic synchronization — and HSPLIT's story is a case study in how interconnect evolution retires protocol features.

HSPLIT and slow-subordinate utilization. On a single shared bus, a high-latency subordinate (say an off-chip memory behind a slow interface) is a system problem: stalling the whole bus for its latency wastes enormous bandwidth. SPLIT was the system-level answer — let that subordinate free the bus during its latency so other masters stay productive. So at the system level, HSPLIT addressed the slow-subordinate-on-a-shared-bus problem, which mattered greatly when the single shared bus was the only topology. It is a window into the constraints designers worked under before multi-layer interconnects.

HLOCK and synchronization. As with HMASTLOCK (chapter 3.11), HLOCK connects the bus to system-level synchronization — semaphores and mutexes built on atomic read-modify-write. The master requests atomicity with HLOCK; the system guarantees it via the arbiter holding the grant. So HLOCK is part of how a multi-master system coordinates shared-resource access at the bus level.

The evolution lesson. The removal of SPLIT in AHB5 is a clear example of a protocol feature being retired because a topology change made it unnecessary. SPLIT solved "slow subordinate stalls the shared bus" by adding protocol machinery; the bus matrix solved the same problem structurally — with parallel paths, a master waiting on a slow subordinate on one layer does not block masters using other subordinates on other layers, so the slow subordinate's latency is naturally isolated without any explicit bus-freeing. Once the matrix made slow-subordinate latency a non-issue for other masters, SPLIT's complex machinery was pure cost, and AHB5 removed it. So at the system level, HSPLIT teaches that protocol features are contingent on the topology of their era — and that better topology can make clever protocol features obsolete. This mirrors the broader theme (chapter 2.7): AHB-Lite-plus-matrix replaced full AHB's in-protocol multi-master machinery, of which SPLIT was a part.

So these signals are full-AHB's answers to slow-subordinate utilization (HSPLIT) and atomicity (HLOCK), and HSPLIT especially is a lesson in how interconnect evolution retires protocol complexity.

6. Engineering Tradeoffs

The signals embody tradeoffs around complexity versus the problems they solve.

• SPLIT utilization vs complexity. SPLIT improves shared-bus utilization with a slow subordinate (other masters run during its latency) at a large cost in arbiter, subordinate, and verification complexity (per-master masks, HMASTER coupling, resume logic). On a single shared bus with slow slaves, the utilization gain could justify it; once matrices existed, the complexity was not worth it. AHB5 resolved this by removing SPLIT.
• In-protocol slow-slave handling (SPLIT) vs structural (matrix). SPLIT handles slow subordinates in the protocol; a bus matrix handles them structurally (parallel paths isolate latency). The structural solution is cleaner — no protocol machinery, and it also provides concurrency — so the trade resolved toward the matrix, retiring SPLIT.
• HLOCK simplicity vs SPLIT complexity. HLOCK/HMASTLOCK (hold the grant) is simple and survived in some form; SPLIT (defer, mask, resume) was complex and did not. The contrast shows that the locking mechanism's simplicity was a survival trait, while SPLIT's complexity was fatal once an alternative existed.
• Bus-holding lock (HLOCK) vs exclusive monitors. As noted in chapter 3.11, even HLOCK-style bus-holding locks have largely given way to exclusive-access monitors (AHB5, chapter 3.14) that achieve atomicity without holding the bus. So HLOCK too is partly superseded, though by a different mechanism than SPLIT.

The through-line: HSPLIT and HLOCK are full-AHB mechanisms whose complexity was weighed against the problems they solved, and both were largely superseded — SPLIT by the bus matrix (structural), bus-holding locks by exclusive monitors. They are important for legacy understanding and as a lesson in how topology and newer mechanisms retire protocol features.

7. Industry Example

Trace a slow-subordinate scenario the legacy way (SPLIT) and the modern way (matrix), plus an HLOCK use.

Legacy: a slow memory using SPLIT. A multi-master system on a single shared AHB has a slow off-chip memory (a split-capable subordinate). A processor accesses it; the memory cannot complete quickly, so it responds SPLIT. The arbiter masks the processor off and frees the bus; meanwhile a DMA engine uses the bus productively for other accesses. When the slow memory has the processor's data ready, it asserts the processor's HSPLIT bit; the arbiter re-grants the processor, and its access completes. The bus stayed busy with the DMA during the memory's latency instead of stalling — SPLIT's utilization win.

Modern: the same slow memory behind a bus matrix. The same system built with AHB-Lite managers and a bus matrix needs no SPLIT. The processor's access to the slow memory occupies one layer/path of the matrix; the DMA's accesses to other subordinates use other paths concurrently. The slow memory's latency only affects the processor (which is waiting on it anyway); the DMA is never blocked, because it is on a different path. The slow-subordinate problem is solved structurally — no SPLIT, no per-master masks, no HSPLIT. This is why AHB5 could remove SPLIT.

An HLOCK use (atomic semaphore). A master needs an atomic read-modify-write on a semaphore. It asserts HLOCK with its bus request; the arbiter asserts HMASTLOCK and holds the grant across the read and write, so no other master interleaves (chapter 3.11). The lock makes the sequence atomic. (In a fully modern system, this too might use an exclusive-access monitor instead — chapter 3.14.)

The two slow-memory approaches side by side show SPLIT's purpose and its replacement: HSPLIT solved slow-subordinate utilization with protocol machinery; the matrix solves it structurally and more cleanly. HLOCK shows the surviving (though also evolving) locking mechanism.

8. Common Mistakes

9. Interview Insight

These signals test legacy awareness and the evolution story.

The answer that lands explains both and the evolution: "HSPLIT is part of the legacy SPLIT mechanism — a slow split-capable subordinate responds SPLIT to free the shared bus for other masters instead of stalling everyone, and asserts a master's HSPLIT bit to the arbiter when it can resume that master. HLOCK is a master's lock request, which the arbiter reflects as HMASTLOCK to hold the grant for an atomic sequence. Both are full multi-master AHB; SPLIT was removed in AHB5 because a bus matrix solves slow-subordinate isolation more cleanly — with parallel paths, a slow subordinate doesn't block other masters anyway." The SPLIT-retirement-because-of-matrices point is the senior signal.

10. Practice Challenge

Reason from the SPLIT flow and the request-vs-effect distinction.

1. Define both. State what HSPLIT and HLOCK do and who drives each.
2. Trace SPLIT. Walk the SPLIT flow from a slow subordinate responding SPLIT to the transfer completing via HSPLIT.
3. Distinguish request vs effect. Contrast HLOCK and HMASTLOCK.
4. Explain the retirement. In three sentences, explain why AHB5 removed SPLIT and what replaced it.
5. Modern redesign. A new design has a slow subordinate that must not stall other masters. Explain why you would use a bus matrix rather than SPLIT.

11. Key Takeaways

• HSPLIT is a split-capable subordinate's per-master resume bus to the arbiter — it signals which master the subordinate can now complete after SPLIT-ing that master's transfer.
• HLOCK is a master's lock request to the arbiter; the arbiter reflects it as HMASTLOCK to hold the grant for an atomic sequence. HLOCK = request, HMASTLOCK = effect.
• SPLIT freed a shared bus from a slow subordinate by deferring the master and letting others run, improving utilization — but at heavy arbiter/subordinate/verification complexity, including coupling to HMASTER.
• SPLIT and HSPLIT were removed in AHB5 because the bus matrix solves slow-subordinate isolation structurally (parallel paths) and more cleanly.
• Both are full multi-master AHB signals; AHB-Lite has neither. Do not design new systems around SPLIT.
• The SPLIT story is a lesson in evolution: a clever protocol feature retired once a better topology (the matrix) made it unnecessary — mirroring AHB-Lite-plus-matrix superseding full AHB.

12. What Comes Next

One Module 3 chapter remains, covering the AHB5 additions:

• 3.14 — HNONSEC & HEXCL (Variants) (coming next) — the AHB5 security bit and the exclusive-access mechanism that provides atomicity without holding the bus, completing the signal module.

To revisit the locking and arbitration these signals interact with, see HMASTER & HMASTLOCK and HGRANT & HBUSREQ; for why the bus matrix replaced SPLIT, see Shared Bus vs Interconnect Thinking and AHB-Lite Overview. For the broader protocol map, see the AMBA family overview.