Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Paths
  • Concept Map
  • How to Read the Diagrams
  • Part 0: What Is a Protocol?10
  • Part 1: Timing and Clocking11
  • Part 2: Encoding and Framing12
  • Part 3: Handshakes13
  • Part 4: Flow Control17
  • Part 5: Transactions19
  • Part 6: Concurrency and Performance17
  • Part 7: Ordering13
  • Part 8: Sharing and Arbitration12
    • Shared Media and Topologies
    • Arbitration Policies
    • Fairness and Starvation
    • Priority Inversion
    • Arbitration Granularity
    • Distributed Arbitration
    • Quality of Service
    • Virtual Channels
    • Routing
    • Multicast and Broadcast
    • Protocols Compared: Sharing and Arbitration
    • Drills: Sharing and Arbitration
  • Part 9: Deadlock and Liveness13
  • Part 10: Reliability and Recovery20
  • Part 11: Bring-Up and Link Management10
  • Part 12: Power8
  • Part 13: Shared State and Coherence9
  • Part 14: Security and Isolation7
  • Part 15: Specifying and Verifying11
  • Part 16: Protocols Dissected17
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 8: Sharing and Arbitration
  1. Topics
  2. First Principles of Hardware Protocols
  3. Part 8: Sharing and Arbitration
  4. Shared Media and Topologies

Part 8 · Sharing and Arbitration · Working (W)

Shared Media and Topologies

Bus, crossbar, ring, mesh and tree: how each connects many agents, and how area, bandwidth, latency and scaling trade off as the number of agents grows.

On this page

    Note

    Level: Working (W) · Answers: Who gets the wire?

    Before this: Topologies and Duplex

    An interconnect with 8 agents is a crossbar: any agent can reach any other in one hop, several pairs at once. The next chip has 64 agents. The same crossbar would need 4,096 crosspoints and wires that cross the whole die, and it no longer closes timing. The designers switch to a mesh, accept a few more hops of latency, and gain a fabric that grows one tile at a time.

    How should many agents share the wires between them, and how does the answer change as their number grows?

    The obvious answer, and why it breaks

    The obvious answer for a few agents is one shared bus: everyone on the same wires, one transfer at a time. It is cheap and simple, and its bandwidth is fixed however many agents join, so each agent's share shrinks as the count grows. The opposite extreme, a dedicated path between every pair, gives everyone full bandwidth and costs wires and switches that grow with the square of the count. Every real topology sits somewhere between.

    The idea: five shapes

    Five ways to connect agents: one shared bus, a crossbar with a switch at every input-output crossing, a ring, a two-dimensional mesh and a tree.

    Topology

    Bandwidth as agents grow

    Latency

    Cost grows as

    Typical use

    Bus

    Fixed total, shared by all

    One hop, plus waiting for the bus

    N (taps on one wire)

    Few agents, low traffic: peripheral buses

    Crossbar

    Up to N transfers at once

    One hop

    N² crosspoints, long wires

    Up to a few tens of agents

    Ring

    Grows with N, but traffic shares segments

    Up to N/2 hops

    N links

    Moderate counts, simple layout

    Mesh

    Grows with N (many parallel links)

    About √N hops across

    N routers, short local links

    Many agents on a large die

    Tree

    Limited near the root

    log N hops

    N switches

    Hierarchies, aggregation of traffic

    Worked numbers

    Diagram
    Agents:                      8          64
    Crossbar crosspoints (N x N):   64      4,096
    Mesh routers (one per agent):    8         64   (a 2x4 grid, then 8x8)
    Mesh worst-case hops (corner to corner, 8x8): 7 + 7 = 14
    Bus: one transfer at a time whether 8 or 64 agents share it

    The crossbar's cost grows 64 times for 8 times as many agents; the mesh's grows 8 times, paid for in hops. That trade, area and wire length against latency, is the core of the choice.

    What every shared topology needs

    • Arbitration wherever two transfers want the same wire or output (lessons 8.2 to 8.6).

    • Routing wherever there is more than one way to get somewhere (lesson 8.9).

    • Flow control on every link, so shared buffers do not overflow (Part 4).

    • A deadlock argument wherever paths can form cycles: rings and meshes (Part 9).

    What breaks

    A design (illustrative) kept growing a crossbar from 12 to 32 ports to avoid changing its software model. The crossbar met its bandwidth target on paper but its wires spanned the die, it needed extra pipeline stages that added latency to every access, and its area doubled twice. A two-level design, small crossbars joined by a ring, delivered the bandwidth with a fraction of the wiring.

    Why this matters

    Senior lens. Choose a topology from the agent count, the traffic pattern (all-to-all, or mostly to memory) and the floorplan, not from habit. Check bandwidth per agent at the expected load, worst-case hop count against the latency budget, and wire length against timing. Then budget for what every shared fabric needs: arbitration, routing, flow control and a deadlock argument.

    Interview

    Asked: "When does a crossbar stop being sensible?"

    Weak answer: When it gets too slow.

    Strong answer: When its N-squared growth in crosspoints and its long wires outrun the area and timing budget, usually somewhere in the tens of ports. Every input needs a path to every output, so doubling the ports quadruples the switch, and the wires span the whole die, adding pipeline stages and latency. Past that point a mesh or a hierarchy of small crossbars gives more bandwidth per unit area, at the cost of a few extra hops and a routing and deadlock design.

    Follow-ups: (1) How does a mesh's latency grow with agent count? (2) Why do buses survive for peripherals?

    Check yourself A crossbar grows from 16 to 32 ports. By what factor do its crosspoints grow?

    From 256 to 1,024: four times.

    Check yourself Why does a bus's bandwidth per agent fall as agents are added?

    The bus carries one transfer at a time; its total bandwidth is fixed and is shared among more agents.

    Key takeaways

    • Bus, crossbar, ring, mesh and tree trade area and wire length against bandwidth and hop count.

    • Crossbars grow as N² and suit tens of agents; meshes grow as N and suit many, at about √N hops.

    • Every shared topology needs arbitration, routing, flow control and a deadlock argument.

    Keep going

    Next: Lesson 8.2, Arbitration Policies. Fixed priority, round-robin, weighted: how an arbiter chooses, and a round-robin arbiter to build.

    Related topics

    • Part 8 overview: Sharing and Arbitration

    • Architecture course: Topology Families

    Previous

    117 / 234

    Next: Arbitration Policies

    Up next

    Up nextArbitration Policies

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Fairness and Starvation
    • Priority Inversion
    • Arbitration Granularity