When N masters share a resource — a memory port, a bus, a crossbar output — an arbiter picks the winner every cycle. A fixed-priority arbiter is trivial (whoever has the lowest index wins), but it starves low-priority requesters when high-priority ones are always active. A round-robin arbiter fixes this by rotating who gets priority, so every requester is guaranteed service within N cycles.

The naive implementation: keep a pointer p to "who won last time." Next cycle, start scanning from (p+1) mod N and pick the first requester found. Update p to the winner. This works but the mod-N wrap-around is expensive — you need a wide priority encoder that "starts from the middle."

The classic trick: the mask-based round-robin arbiter. Keep an N-bit mask register where bit i is 1 if requester i is eligible this round (i.e., hasn't won yet in the current rotation). Each cycle:

• Compute masked_req = req & mask. If non-zero, pick the lowest bit of masked_req using a plain priority encoder — no rotation needed.
• If masked_req == 0, refill the mask (all ones except bits already served) and pick from req directly.
• Clear the winner's bit in the mask.

This reduces to two ordinary priority encoders running in parallel plus a mux — much faster than a rotating encoder, and it maps to a clean two-level circuit.

Concrete example: a DRAM controller with 4 requesters (CPU cores 0–3). All four are hammering the memory port. A fixed-priority arbiter would let core 0 monopolize; the tail cores would see infinite latency. A round-robin arbiter guarantees each core one grant per 4 cycles — worst-case latency is bounded at N × T_serve. For a 4-cycle memory access, that's a 16-cycle upper bound on request-to-grant. This bound is what makes the design analyzable for real-time systems.

Rule of thumb: a mask-based round-robin arbiter for N requesters costs roughly 2× the area of a fixed-priority arbiter of the same width. That's the fairness tax, and it's almost always worth paying anywhere you can't tolerate starvation.

Variants worth knowing: weighted round-robin (each requester gets a quota — bit i stays set in the mask for w_i grants before clearing); deficit round-robin (used in packet schedulers where request sizes vary); and matrix arbiters, which store an N×N "who-beat-whom-most-recently" matrix — same fairness guarantee, different timing/area tradeoff, favored in high-radix on-chip networks.