Packet Switching vs Circuit Switching

A network core is the set of interconnected switches or routers that carries traffic between edge hosts. Any core must decide, link by link, how to allocate the capacity of that link among competing users. There are exactly two dominant strategies for doing this, and understanding both precisely is the goal here.

Circuit switching reserves resources for a connection along its entire path before any data is sent, during a call setup phase. The classic realizations are Frequency-Division Multiplexing (FDM), where each circuit gets a fixed slice of the link's frequency spectrum for its entire duration, and Time-Division Multiplexing (TDM), where time is divided into repeating frames of fixed-length slots, and each circuit gets the same slot number in every frame. Once established, the circuit behaves like a dedicated wire with a guaranteed, constant transmission rate, regardless of whether the users are actively sending data. This reservation is what the classical telephone network (PSTN) uses: dialing a number and hearing "connecting" is literally the network setting up a circuit end to end.

Packet switching instead breaks a message into smaller units called packets, each carrying a header with addressing and control information. Packets are sent into the network with no advance reservation. Each router along the path uses store-and-forward transmission: it must receive the entire packet, check it, and only then begin transmitting it in full on the next outgoing link. Because no bandwidth is pre-reserved, packets from many different flows can be interleaved on a shared link in whatever order they arrive — this on-demand sharing is called statistical multiplexing, deliberately named in contrast to the fixed multiplexing (FDM/TDM) used by circuits. If two packets destined for the same outgoing link arrive close together, one waits in a router's output queue — the router's buffer memory — while the other is transmitted. The essential distinction is when the sharing decision is made. Circuit switching commits resources at connection-setup time, based on anticipated demand. Packet switching commits nothing in advance and instead multiplexes actual, instantaneous demand link-by-link, packet-by-packet, at transmission time.

Circuit switching, step by step

1. Call setup: The source signals a request to the network. Switches along a path reserve a fixed amount of bandwidth (an FDM frequency band or a TDM slot) for this call, end to end. 2. Data transfer: The source transmits at a constant, guaranteed rate. No queuing, no contention with other calls — the resource is exclusively assigned. 3. Teardown: When the call ends, an explicit signal releases the reserved resource so it can be reused by a future call. If any switch along the path cannot find a free slot/band, the call is blocked — this is why an overloaded phone network gives busy signals instead of degraded quality.

Packet switching, step by step

Each router independently performs the same store-and-forward procedure for every arriving packet: ``` function ROUTER_FORWARD(incoming_link, packet):

# 1. STORE: receive the packet fully before acting buffer = receive_entire_packet(incoming_link, packet.length_bits)

# 2. Look up next hop using the packet's destination address output_link = FORWARDING_TABLE.lookup(packet.destination) if output_link is None: drop(packet) # unreachable destination return

# 3. Enqueue on the chosen output link's queue (finite buffer!) if OUTPUT_QUEUE[output_link].is_full(): drop(packet) # buffer overflow -> packet loss return OUTPUT_QUEUE[output_link].enqueue(packet)

# 4. FORWARD: transmit only after the whole packet is stored,

# and only when it reaches the head of the queue schedule_transmission(output_link) ``` ``` function TRANSMIT_LOOP(output_link): while True: if OUTPUT_QUEUE[output_link].not_empty(): packet = OUTPUT_QUEUE[output_link].dequeue() transmit_bit_by_bit(packet, output_link.rate_bps)

# this takes packet.length_bits / output_link.rate_bps seconds ``` No step above involves reserving capacity ahead of time. Every router makes an independent, local, per-packet decision based only on the packet's header and the current state of its queues. This locality is precisely why packet networks scale to millions of independent flows without any global setup handshake — there is no call-setup analog at all in ordinary packet forwarding (though virtual-circuit variants exist as a hybrid, briefly noted below). The following figure lays both mechanisms side by side across the same physical link, showing why circuits waste capacity that packets do not.

A hybrid worth naming: virtual circuits

Some packet networks (e.g., ATM, MPLS-based paths) use virtual-circuit switching: a setup phase establishes a fixed path through the network and installs forwarding-table entries at each router, but bandwidth itself is still shared statistically, not reserved. This gives packets a consistent path (useful for ordering and fast forwarding-table lookups) while retaining the efficiency of statistical multiplexing. It sits conceptually between the two poles described above, and is worth knowing exists, but the datagram-style forwarding shown in the pseudocode above is what ordinary IP routers do.

Circuit switching resource accounting. If a link has capacity $C$ and each circuit needs a fixed rate $r$, the link supports at most

simultaneous calls, guaranteed, with zero probability of degradation once admitted — but call $N_{\text{circuit}}+1$ is blocked outright even if every existing user is momentarily silent. Setup and teardown require a round trip of signaling over the whole path, an $O(d)$ operation in the number of hops $d$, executed once per call, independent of call duration.

Packet switching's statistical multiplexing gain. Suppose $N$ independent users share a link of capacity $C$, and each user is "active" (transmitting at rate $r$) only a fraction $p$ of the time, independently. Circuit switching must provision for the worst case and can host only $\lfloor C/r \rfloor$ users regardless of $p$. Packet switching can admit far more users, because the probability that more than $M = \lfloor C/r \rfloor$ of them are simultaneously active is small when $p$ is small. Formally, the number of simultaneously active users follows a Binomial$(N, p)$ distribution, and the probability the link is oversubscribed is:

Worked instance of the argument: let $C = 1\ \text{Mbps}$, per-user active rate $r = 100\ \text{kbps}$, so $M = 10$. A circuit-switched link can only ever host $10$ users. Suppose each user is active only $p = 0.1$ of the time (bursty, e.g., web browsing). With $N = 35$ packet-switched users sharing the link, the expected number active at once is $Np = 3.5$, comfortably under $M=10$, and the binomial tail probability of exceeding $10$ simultaneously active users out of $35$ is under $0.4\%$. Packet switching therefore supports 3.5× more users on the same link at a small, quantifiable, and tunable risk of momentary queuing — a risk circuit switching cannot even express, because it simply refuses users past $N_{\text{circuit}}$. This is the core correctness argument for statistical multiplexing: it is not "unreliable"; it is a probabilistic tradeoff that the network operator can dial by choosing $N$ relative to $p$ and $M$, accepting rare, small queuing delays in exchange for large gains in the number of supportable users. Circuit switching has zero variance in performance but a hard, low ceiling on utilization; packet switching has bounded, small variance in performance and a much higher ceiling.

Store-and-forward correctness invariant. A router must never begin transmitting any bit of a packet on an outgoing link before it has received all bits of that packet on the incoming link, and before it has completed its (fast, table-lookup based) forwarding decision. This is the defining invariant of store-and-forward switching, and it guarantees that a corrupted or truncated packet is never partially propagated — the router can validate a checksum over the complete packet before relaying anything. The cost of this invariant is exactly one packet-transmission-time delay per hop (derived precisely in the discussion of delay components that follows this topic).

Space complexity. A circuit-switched core needs no per-packet buffering — memory usage is $O(1)$ per active call (just the reservation state). A packet-switched router needs $O(B)$ buffer memory per output link, where $B$ is the provisioned queue capacity in bits; if the arrival rate of packets destined for a link exceeds its transmission rate for long enough, the queue fills and subsequent arrivals are dropped — this is the loss mechanism packet networks must tolerate and circuit networks structurally cannot experience (they block instead of losing in-progress data).

Consider a single 1.536 Mbps trunk link (a T1-class link) shared by candidate users who each need 128 kbps for a call.

Step 1 — circuit-switched capacity.

Exactly 12 calls can ever use this trunk simultaneously; a 13th caller is blocked with a busy signal, even if 11 of the 12 active calls are silent (e.g., during pauses in speech).

Step 2 — packet-switched capacity under the same load statistics. Suppose each user is active only $p = 0.2$ of the time (a fairly chatty user model). We ask: how many users $N$ can share the link such that the probability more than $12$ are simultaneously active stays below $1\%$?

Reading the table: at $N = 20$ packet-switched users, the risk of oversubscribing the trunk is negligible (0.03%), yet the link now serves 20 users instead of 12 — a 67% gain in served population for the same physical link, at a vanishingly small queuing risk. Push to $N=30$ and the risk climbs to 1.4%, a deliberate operating point a network engineer might choose to trade a small, rare queuing delay for 2.5× the circuit-switched population.

Step 3 — trace one packet's journey to make the mechanism concrete. Suppose user A's packet (1,000 bits) arrives at Router 1 destined for Router 3, and at the same instant user C's packet (also queued) is already transmitting on the shared outgoing link at 1.536 Mbps.

No bandwidth was reserved for A in advance; A simply queued behind whoever was ahead of it and got served in order — the essence of statistical multiplexing made concrete at the level of individual bits.

The public switched telephone network (PSTN) historically used circuit switching end to end (FDM originally, then TDM in digital trunks), which is exactly why old landline calls had rock-solid, unwavering audio quality but a hard call-capacity limit per trunk. The internet, Ethernet, Wi-Fi, and essentially all modern data networks use packet switching, which is why the internet can carry an unpredictable, wildly bursty mixture of web browsing, video streaming, gaming, and file transfer on shared infrastructure without pre-negotiating bandwidth for each. Cellular networks (4G/5G core networks) have migrated almost entirely to packet-switched, IP-based cores, even carrying voice as packetized data (VoIP), because packet efficiency outweighs the diminishing need for circuit-style guarantees given modern buffering and prioritization techniques. Data-center networks, content-delivery networks, and virtually every router, switch, and network interface card manufactured today implement store-and-forward packet switching as their fundamental operating principle. Understanding this contrast is the direct prerequisite for reasoning about Delay, Loss, and Throughput in Packet Networks, where the queuing behavior sketched here is analyzed hop by hop in full quantitative detail, and it also underlies why the Internet Protocol Stack was designed around independently routed datagrams rather than pre-established circuits.

Ask the tutor: How does queuing delay actually accumulate hop by hop across a real packet-switched path, and how do we compute end-to-end delay and throughput from it?