Bus hierarchy and bus arbitration

Bus hierarchy

A bus hierarchy uses several buses at different speeds, joined by bridges, instead of one shared bus.

 +-----+  Local bus  +-------+
 | CPU |-------------| Cache |
 +-----+             +---+---+
                         |
 ===+====================+=======+==== System bus
    |                            |
 +--+-----+          +-----------+--------+
 | Main   |          | Expansion bus      |
 | memory |          | interface (bridge) |
 +--------+          +-----------+--------+
                                 |
 ====+==========+===========+====+==== Expansion bus
     |          |           |
  +--+--+   +---+--+   +----+---+
  | LAN |   | SCSI |   | Serial |
  +-----+   +------+   +--------+

• Local bus: connects the CPU, the cache and sometimes memory. It is the fastest.
• System bus: connects the cache to main memory and to the expansion bus interface.
• Expansion bus: connects I/O devices such as the network, SCSI and serial ports.

Why it is needed: a single bus becomes a bottleneck with many devices; fast CPU and memory traffic is kept separate from slow I/O; devices of different speeds can work at their own speeds; each bus is shorter, so delay is less; and the CPU can work from the cache while I/O goes on.

Bus arbitration

Several modules (masters) may want the bus at once, but only one can control it. Arbitration is the method of choosing which one gets it.

• Centralised arbitration: one arbiter (bus controller) decides. Methods: daisy chaining, polling and independent requests.
  • Daisy chaining: a Bus Grant signal passes through the devices in order; the first requesting device takes it. Priority depends on position in the chain.
  • Polling: the controller polls the devices in turn using a counter; the requesting device whose number matches gets the bus.
  • Independent requests: each device has its own request and grant lines; the arbiter picks one by priority.
• Distributed arbitration: there is no central controller. Each module has its own arbitration logic; each requesting module puts its priority number on shared lines, and the highest one wins.