ALOHA Protocols Explained: Pure vs Slotted ALOHA, Throughput Numericals and Exam Traps
Build Pure and Slotted ALOHA from their vulnerable periods, then calculate throughput, useful bit rate, and peak load without mixing up G, probability, and S.
KnowledgeGate Team
Exam prep & CS education

Pure ALOHA and Slotted ALOHA look like two small formulas, yet most mistakes happen before either formula is used. Learners choose the wrong vulnerable period or treat offered load as successful throughput. Within CS Fundamentals, ALOHA connects shared-channel timelines to offered load, successful throughput, and formula choice.
What problem does ALOHA solve on a shared channel?
Suppose several independent stations share one broadcast medium without a central scheduler. A station sends a frame when the protocol permits. If transmissions overlap, every overlapping frame is unusable, so a station that receives no acknowledgement retries after a random waiting time. That random backoff reduces the chance of the same stations colliding together again.
The analysis uses the following symbols:
Lis frame length in bits.Ris channel rate in bits per second.T = L/Ris one-frame transmission time.Gis the aggregate offered load, measured in attempts per frame time.Sis successful throughput, measured in frames delivered per frame time.
G includes original transmissions and retransmissions. It is dimensionless, even though its description refers to a frame-time interval.
The ideal analysis assumes equal-duration frames, a Poisson model for aggregate attempts, and complete loss of every frame involved in a collision. These assumptions define the mathematical model. They do not describe every detail of every real network.
Pure ALOHA: transmit at any instant and face a 2T risk window
Pure ALOHA has no slots or shared clock boundaries. A station transmits immediately, waits for an acknowledgement or timeout, and chooses a random backoff before retrying after failure.
Take reference frame A, which starts at 0 ms and occupies [0, 1.0 ms]. Any other one-millisecond frame that starts after -1.0 ms and before 1.0 ms overlaps A. The vulnerable period is therefore 2T = 2.0 ms. Frame B starting at -0.8 ms overlaps the start of A, and frame C starting at 0.6 ms overlaps its end. Frame D starting at 1.1 ms does not overlap A.
The offered load is G attempts per frame time, so the mean number of competing attempts during 2T is 2G. Under the Poisson model, the probability of zero competing attempts is:
P(success) = e^(-2G)
Multiplying attempted load by its success probability gives:
S_pure = G e^(-2G)

Slotted ALOHA: one-frame slots halve the vulnerable period
Slotted ALOHA changes one rule. Time is divided into slots of length T, and a station may start only at a slot boundary. A frame arriving during a slot waits for the next boundary. This requires slot synchronisation and may add waiting time before transmission.
Two frames choosing the same slot collide. A frame beginning in the next slot cannot partially overlap the first, so the vulnerable period falls from 2T to T. With mean load G in one slot, the probability of no competing attempt is e^(-G). Thus:
P(success) = e^(-G)
S_slotted = G e^(-G)
Slot alignment improves throughput because it removes partial-overlap starts. It does not remove collisions.
Worked example: a 1 Mbps channel carrying 1000-bit frames
The inputs are R = 1,000,000 bits/s, L = 1000 bits, and aggregate attempt rate lambda = 400 attempts/s.
First find the frame time and normalised load:
T = L/R = 1000/1,000,000 s = 0.001 s = 1 ms
G = lambda T = 400 x 0.001 = 0.4 attempts per frame time
For Pure ALOHA:
P(success) = e^(-2 x 0.4) = e^(-0.8) = 0.4493S = 0.4 x 0.4493 = 0.1797 frames per frame timeSuccessful rate
= 0.1797/0.001 = 179.7 frames/sUseful bit rate
= 179.7 x 1000 = 179,700 bits/s, approximately179.7 kbps
For Slotted ALOHA:
P(success) = e^(-0.4) = 0.6703S = 0.4 x 0.6703 = 0.2681 frames per slotSuccessful rate
= 0.2681/0.001 = 268.1 frames/sUseful bit rate
= 268.1 x 1000 = 268,100 bits/s, approximately268.1 kbps
Protocol | Vulnerable period | Success probability | Normalised throughput | Useful rate |
|---|---|---|---|---|
Pure ALOHA |
|
|
|
|
Slotted ALOHA |
|
|
|
|
The stations attempt 400 frames/s, equivalent to 400 kbps of offered traffic. That is not the delivered throughput. Collisions explain the gap.
Maximum throughput: why 18.4% and 36.8% are peak values
For Pure ALOHA, differentiate S = G e^(-2G):
dS/dG = e^(-2G)(1 - 2G)
The derivative is zero at G = 0.5. Therefore S_max = 0.5e^(-1) = 1/(2e) = 0.1839, about 18.4% of the raw channel rate under this model.
For Slotted ALOHA:
dS/dG = e^(-G)(1 - G)
The peak occurs at G = 1, where S_max = e^(-1) = 0.3679, about 36.8%. On a 1 Mbps channel with the stated fixed-size-frame model, the peaks correspond to about 183.9 kbps and 367.9 kbps.
At small G, few attempts collide. Near the peak, extra attempts still add useful work. Beyond it, collisions grow faster than successful deliveries, so throughput falls even while offered load rises.

Common ALOHA traps and their corrections
Wrong vulnerable period: Do not use
Tfor Pure ALOHA or2Tfor Slotted ALOHA. Draw the possible start-time window around one reference frame. Arbitrary starts create2T; boundary-aligned starts restrict risk to one slot.Mixing up G, probability, and S:
Gis attempted load. The success probability ise^(-2G)ore^(-G). Successful throughput isS = G x P(success).Skipping load conversion: If attempts are given per second, calculate
G = lambda L/Rbefore applying a throughput formula.Using the peak for every load:
18.4%and36.8%apply only at their respective optimum loads under the model. For a givenG, calculate its correspondingS.Ignoring retries: When a problem gives aggregate offered load, include retransmissions as attempts.
How questions test ALOHA without naming the formula
A question may ask you to identify a vulnerable interval from a timeline, convert L, R, and attempts per second into T and G, compare both protocols at the same G, or work backwards from a maximum point.
Use this decision check: arbitrary start times mean Pure ALOHA and exponent -2G; slot-boundary starts mean Slotted ALOHA and exponent -G.
For a quick solved check at G = 1:
Pure ALOHA:
S = 1 x e^(-2) = 0.1353.Slotted ALOHA:
S = 1 x e^(-1) = 0.3679.
This also exposes a common trap: G = 1 is optimal only for Slotted ALOHA. Once the idea is clear, work through a focused set of ALOHA practice questions, then move on to broader Computer Networks MCQs.
ALOHA in one minute, then the next study step
Pure ALOHA transmits at any instant.
Slotted ALOHA waits for a slot boundary.
Their vulnerable periods are
2TandT.Their throughputs are
G e^(-2G)andG e^(-G).Their ideal maxima are
1/(2e)atG = 0.5and1/eatG = 1.
Choose Zero to Hero for a structured college-level CS fundamentals route. Choose Computer Science for placement-focused revision across Computer Networks and other core CS subjects.
For the next network-layer worked explainer, study Routing Algorithms: Distance Vector vs Link State. Transport-layer congestion control is another useful numerical topic after that. Before moving on, redraw the vulnerable window from memory, then recompute the 1 Mbps example without looking at the formulas.
Keep learning
ALOHA Protocols MCQs: 10 Solved Questions with Step-by-Step Explanations
Solve ten ALOHA questions covering formula choice, maximum throughput, offered load, one-transmitter probability, per-host throughput, and frame size.
CSMA/CD and ALOHA for GATE: Efficiency and Minimum Frame Size Numericals Solved
Separate one-way delay from round-trip delay, then solve the standard CSMA/CD frame-size and ALOHA throughput numericals step by step.
Channel Capacity Limits MCQs: 12 Solved PYQs on Nyquist, Shannon and Throughput
Solve 12 published-bank channel capacity PYQs covering formula selection, substitutions and unit traps. Each answer includes a concise worked explanation.
Abstract Classes in C++: Pure Virtual Functions, Examples and Errors
Learn why an abstract base cannot be instantiated but remains useful through pointers and references. Trace two shapes, fix override errors and practise safe polymorphism.





