Computer NetworksCSMA/CD

CSMA/CD: Carrier Sense Multiple Access with Collision Detection

LevelIntermediate

Duration60 mins

TopicCSMA/CD

4 / 5

CSMA/CD Efficiency — Mathematical Analysis

Measuring Protocol Performance

How efficiently does CSMA/CD utilize the available bandwidth? This question has profound implications for network design—it determines how many stations can share a medium, what throughput users can expect, and when the network will become congested.

Unlike simple point-to-point links where efficiency approaches 100%, shared media protocols like CSMA/CD must contend with collisions, backoff delays, and timing overhead. These factors reduce the effective throughput below the raw bit rate.

In this page, we'll derive the mathematical expressions for CSMA/CD efficiency, analyze how various parameters affect performance, and understand the conditions under which CSMA/CD performs best and worst.

What You Will Learn

By the end of this page, you will understand the key efficiency formula for CSMA/CD, how to calculate maximum throughput under different network configurations, the impact of propagation delay and frame size on efficiency, and why CSMA/CD becomes inefficient at high loads and with long propagation delays.

Defining CSMA/CD Efficiency

Before diving into formulas, we must precisely define what "efficiency" means in the context of CSMA/CD.

Channel Efficiency (η):

Channel efficiency is the fraction of time the channel is used for successful (non-colliding) data transmission:

η = (Time transmitting successful data) / (Total time)

Alternatively:

η = (Successful throughput) / (Channel capacity)

For example, if a 10 Mbps Ethernet network achieves 6 Mbps of actual data throughput, the efficiency is 60%.

What Reduces Efficiency?

Several factors consume channel time without delivering useful data:

Factor	Description	Impact
Collision overhead	Time spent transmitting frames that collide	Wasted bandwidth
Jam signals	32 bits per collision event	Small overhead per collision
Backoff time	Waiting period after collision	Idle channel time
Propagation delay	Signal travel time	Delay before next transmission
Inter-frame gap	Mandatory 96-bit quiet period	Fixed ~1% overhead
Protocol overhead	Headers, preamble, FCS	Reduces payload efficiency

Key Efficiency Metrics:

Normalized Throughput (S): Fraction of channel capacity used for successful transmissions (0 to 1)
Offered Load (G): Total transmission attempts (including retransmissions) as a fraction of channel capacity
Collision Probability (P): Probability that a transmission attempt collides
Maximum Throughput (S_max): Best achievable throughput under optimal load
Delay: Time from frame submission to successful delivery

Load vs. Throughput

As load (G) increases, throughput (S) initially increases but eventually decreases due to collisions. The relationship between G and S is the key to understanding CSMA/CD performance—there's an optimal load beyond which adding more traffic actually reduces successful throughput.

The Fundamental Parameter 'a'

The efficiency of CSMA/CD depends critically on a dimensionless parameter called 'a'—the ratio of propagation delay to frame transmission time.

Definition:

a = (Propagation Delay) / (Frame Transmission Time)

a = τ / T

Where:

τ (tau) = Maximum one-way propagation delay across the network
T = Time to transmit one frame

Understanding the 'a' Parameter
Parameter	Formula	Unit
Propagation Delay (τ)	τ = d / v	seconds
d = network diameter	Maximum cable length	meters
v = propagation velocity	~2 × 10⁸ m/s (in cable)	m/s
Transmission Time (T)	T = L / R	seconds
L = frame size	Bits in the frame	bits
R = data rate	Channel bit rate	bits/second
a = τ / T	a = (d × R) / (v × L)	dimensionless

Physical Interpretation:

The parameter 'a' tells us how many frames could fit on the wire at once:

a << 1: Propagation delay is small compared to transmission time. The first bit of a frame reaches the destination before the last bit is transmitted. This is ideal for CSMA/CD.
a ≈ 1: Propagation delay equals transmission time. The channel can 'hold' exactly one frame.
a >> 1: Propagation delay is large compared to transmission time. Multiple frames could be 'in flight' simultaneously—very problematic for CSMA/CD.

Small 'a' (a << 1):
  Sender: [=====Frame=====]
  Wire:    [=====Frame=====]
  Receiver:          [=====Frame=====]
  ↑ Frame nearly fully transmitted before first bit arrives

Large 'a' (a >> 1):
  Sender: [F]
  Wire:    [F]------------------
  Receiver:                             [F]
  ↑ Frame completely transmitted before first bit arrives!

calculate_a_parameter.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
"""
Calculate the 'a' parameter for different network configurations
"""
 
def calculate_a(
    network_diameter_m: float,
    data_rate_mbps: float,
    frame_size_bytes: int,
    velocity_factor: float = 0.67
) -> float:
    """
    Calculate the 'a' parameter for CSMA/CD analysis.
    
    Args:
        network_diameter_m: Maximum distance between stations (meters)
        data_rate_mbps: Channel data rate (megabits per second)
        frame_size_bytes: Size of frame in bytes
        velocity_factor: Fraction of speed of light (typically 0.65-0.77)
    
    Returns:
        The dimensionless 'a' parameter
    """
    # Calculate propagation delay
    speed_of_light = 3e8  # m/s
    propagation_velocity = speed_of_light * velocity_factor  # m/s
    propagation_delay = network_diameter_m / propagation_velocity  # seconds
    
    # Calculate transmission time
    frame_size_bits = frame_size_bytes * 8
    data_rate_bps = data_rate_mbps * 1e6
    transmission_time = frame_size_bits / data_rate_bps  # seconds
    
    # Calculate 'a'
    a = propagation_delay / transmission_time
    
    return a
 
 
# Example calculations
print("Standard 10BASE5 Ethernet:")
a = calculate_a(
    network_diameter_m=2500,
    data_rate_mbps=10,
    frame_size_bytes=1518  # Maximum frame
)
print(f"  a = {a:.4f} (max frame)")
 
a_min = calculate_a(
    network_diameter_m=2500,
    data_rate_mbps=10,
    frame_size_bytes=64  # Minimum frame
)
print(f"  a = {a_min:.4f} (min frame)")
 
 
print("
Gigabit Ethernet (100m cable):")
a = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=1000,
    frame_size_bytes=1518
)
print(f"  a = {a:.4f} (max frame)")
 
a_min = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=1000,
    frame_size_bytes=64
)
print(f"  a = {a_min:.4f} (min frame)")
 
 
print("
10 Gigabit Ethernet (theoretical half-duplex):")
a = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=10000,
    frame_size_bytes=1518
)
print(f"  a = {a:.4f} (max frame)")
 
# Output:
# Standard 10BASE5 Ethernet:
#   a = 0.0082 (max frame)
#   a = 0.1942 (min frame)
#
# Gigabit Ethernet (100m cable):
#   a = 0.0041 (max frame)
#   a = 0.0971 (min frame)
#
# 10 Gigabit Ethernet (theoretical half-duplex):
#   a = 0.0410 (max frame)

Rule of Thumb

For good CSMA/CD efficiency, 'a' should be much less than 1, ideally below 0.05. The maximum efficiency approaches 1 / (1 + 2a) for a single transmitter, and actual efficiency is lower under contention.

The CSMA/CD Efficiency Formula

The maximum efficiency of CSMA/CD can be derived analytically using queueing theory and probability analysis. The classic result is:

Maximum Channel Efficiency:

η_max = 1 / (1 + 5a)

This simplified formula assumes:

Heavy traffic (network always has frames to send)
Many stations (contention is always present)
Optimal load (network operates at maximum throughput point)

Derivation Overview:

The formula comes from analyzing the expected duration of a "transmission cycle":

Transmission Cycle Analysis:

┌─────────────────────────────────────────────────────────────────────────┐
│                       ONE TRANSMISSION CYCLE                            │
├───────────────────────────────────────┬─────────────────────────────────┤
│      CONTENTION INTERVAL              │     TRANSMISSION INTERVAL        │
│                                       │                                 │
│ [C1][C2][C3]...[Cn] contention slots  │ [======Successful Frame======]  │
│                                       │                                 │
│ Average duration: expected number of  │ Duration: T (frame transmission │
│ contention slots × slot time (2τ)     │ time)                           │
└───────────────────────────────────────┴─────────────────────────────────┘

With 'n' stations contending:

Each slot, probability of exactly one transmission: n × (1/n) × (1 - 1/n)^(n-1)
As n → ∞, this approaches 1/e ≈ 0.368
Expected contention slots before success: e ≈ 2.718
Contention interval = e × (slot time) = e × 2τ = 5.44τ

Simplified to 5τ:

The factor of 5 in the formula (rather than 2e ≈ 5.44) comes from practical considerations and approximations. Some derivations use 2e, others use 5—the difference is small.

CSMA/CD Efficiency at Different 'a' Values
a Value	η_max = 1/(1+5a)	Context
0.01	95.2%	Optimal: Long frames, short distance
0.02	90.9%	Good: Standard Ethernet max-frame
0.05	80.0%	Acceptable: Medium conditions
0.10	66.7%	Marginal: Short frames or long distance
0.20	50.0%	Poor: Approaching minimum frame size limits
0.50	28.6%	Very Poor: Network at design limits
1.00	16.7%	Impractical: Theoretical limit case

csmacd_efficiency.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
"""
CSMA/CD Efficiency Calculator
Comprehensive analysis with various formulas and scenarios
"""
 
from dataclasses import dataclass
from typing import Tuple
import math
 
@dataclass
class NetworkConfig:
    """Network configuration parameters"""
    diameter_m: float       # Network diameter in meters
    data_rate_mbps: float   # Data rate in Mbps
    velocity_factor: float = 0.67  # Signal velocity as fraction of c
    
    @property
    def propagation_delay(self) -> float:
        """Maximum one-way propagation delay in seconds"""
        c = 3e8  # speed of light
        v = c * self.velocity_factor
        return self.diameter_m / v
 
 
def calculate_efficiency_simple(a: float) -> float:
    """
    Simplified efficiency formula: η = 1 / (1 + 5a)
    Valid for heavy load, many stations
    """
    return 1 / (1 + 5 * a)
 
 
def calculate_efficiency_precise(a: float, n_stations: int = 10) -> float:
    """
    More precise efficiency formula considering station count
    η = 1 / (1 + (2n-1)/(n) * a)
    """
    contention_factor = (2 * n_stations - 1) / n_stations
    return 1 / (1 + contention_factor * a * math.e)
 
 
def analyze_network(
    config: NetworkConfig,
    frame_size_bytes: int
) -> dict:
    """
    Complete efficiency analysis for a network configuration
    """
    # Calculate transmission time
    frame_bits = frame_size_bytes * 8
    data_rate_bps = config.data_rate_mbps * 1e6
    transmission_time = frame_bits / data_rate_bps
    
    # Calculate 'a' parameter
    a = config.propagation_delay / transmission_time
    
    # Calculate efficiencies
    efficiency_simple = calculate_efficiency_simple(a)
    efficiency_precise = calculate_efficiency_precise(a)
    
    # Calculate slot time (2 × propagation delay for round-trip)
    slot_time = 2 * config.propagation_delay
    
    # Calculate maximum throughput
    max_throughput_mbps = efficiency_simple * config.data_rate_mbps
    
    return {
        'propagation_delay_us': config.propagation_delay * 1e6,
        'transmission_time_us': transmission_time * 1e6,
        'a_parameter': a,
        'slot_time_us': slot_time * 1e6,
        'efficiency_simple': efficiency_simple,
        'efficiency_precise': efficiency_precise,
        'max_throughput_mbps': max_throughput_mbps,
    }
 
 
# Analyze different scenarios
print("=" * 70)
print("CSMA/CD EFFICIENCY ANALYSIS")
print("=" * 70)
 
# Scenario 1: Classic 10BASE5 Ethernet
config_10base5 = NetworkConfig(
    diameter_m=2500,
    data_rate_mbps=10
)
 
print("
10BASE5 Ethernet (2500m, 10 Mbps):")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_10base5, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.2f} Mbps")
 
# Scenario 2: 100BASE-TX Ethernet
config_100base = NetworkConfig(
    diameter_m=200,
    data_rate_mbps=100
)
 
print("
100BASE-TX Ethernet (200m, 100 Mbps):")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_100base, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.1f} Mbps")
 
# Scenario 3: Gigabit Ethernet (half-duplex, theoretical)
config_1gbase = NetworkConfig(
    diameter_m=100,
    data_rate_mbps=1000
)
 
print("
Gigabit Ethernet (100m, 1 Gbps) [theoretical half-duplex]:")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_1gbase, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.0f} Mbps")

The Small Frame Problem

Notice how efficiency drops dramatically for small frames. At 64-byte minimum frame size, the 'a' parameter is much larger, severely reducing efficiency. This is why protocols try to send larger frames and why jumbo frames exist—larger frames mean lower 'a' values and higher efficiency.

Throughput vs. Load Curve

One of the most important characteristics of CSMA/CD is the relationship between offered load (G) and achieved throughput (S). This relationship reveals the protocol's behavior under varying network conditions.

The Throughput Equation:

For CSMA/CD, the relationship is approximately:

S = G × e^(-2aG) (simplified for 1-persistent CSMA/CD)

Where:

S = Normalized throughput (0 to 1)
G = Normalized offered load (can exceed 1 due to retransmissions)
a = Propagation parameter (τ/T)

Throughput Curve Characteristics:

Throughput (S)
    ^
    |                    ____
    |                 __/    \____
    |              __/            \____
S_max|............./....................\....... Maximum throughput
    |           /                          \
    |          /                             \
    |         /                                \
    |        /                                   \
    |       /                                      \
    |      /                                         \
    |_____/______________________________________________\____> Load (G)
    0    G_opt                                              
         (optimal load)

Key Observations:

Rising Phase (G < G_opt): Throughput increases with load. More traffic means more successful transmissions. The channel has spare capacity.
Peak (G = G_opt): Maximum throughput S_max is achieved. The network is at optimal operating point.
Falling Phase (G > G_opt): Throughput decreases as load increases! Collisions become so frequent that retransmissions dominate, wasting bandwidth.
Collapse (G >> G_opt): The network enters "collision collapse" where almost all time is spent on collisions and backoff.

Throughput at Different Load Levels
Load (G)	Relative State	Collisions	Efficiency
0.1	Light	Rare	~90% of capacity used
0.3	Moderate	Occasional	Near optimal
0.5	Heavy	Frequent	At or near maximum
0.8	Overloaded	Very frequent	Declining
1.0	Saturated	Dominant	Significantly degraded
2.0+	Collapsed	Almost continuous	Severe degradation

Optimal Operating Point:

The optimal load G_opt that maximizes throughput can be found by differentiating the throughput equation:

For S = G × e^(-2aG)
dS/dG = e^(-2aG) - 2aG × e^(-2aG)
      = e^(-2aG) × (1 - 2aG)

Setting dS/dG = 0:
1 - 2aG = 0
G_opt = 1/(2a)

Substituting back:
S_max = G_opt × e^(-2a × G_opt)
      = (1/2a) × e^(-1)
      = 1/(2ae)
      ≈ 0.184/a

For small 'a' (which is typical), this approximates to:

η_max ≈ 1 / (1 + 5a) (the formula we saw earlier)

Why Throughput Drops at High Load

At high loads, the probability of collision increases dramatically. With many stations wanting to transmit, the chance that two or more transmit simultaneously approaches 100%. Each collision wastes time equal to the collision period plus jam, and triggers backoffs that add more delay. The result is a vicious cycle where collisions cause retransmissions, retransmissions increase load, and more load causes more collisions.

Factors Affecting CSMA/CD Efficiency

Multiple factors influence CSMA/CD efficiency. Understanding these factors enables network designers to optimize performance.

1. Frame Size:

Larger frames are more efficient because:

Transmission time (T) increases
'a' parameter decreases (a = τ/T)
Fixed overheads (headers, IFG, preamble) are amortized over more data

Factors That INCREASE Efficiency

•Larger frame sizes — More data per transmission
•Shorter cables — Less propagation delay
•Lower data rates — Longer transmission time
•Fewer stations — Less contention
•Moderate traffic — Optimal load range

Factors That DECREASE Efficiency

•Smaller frame sizes — Higher overhead ratio
•Longer cables — More propagation delay
•Higher data rates — Shorter transmission time
•More stations — More contention
•Heavy traffic — Beyond optimal load

2. Number of Stations:

With more stations contending:

Collision probability increases
More contention slots before successful transmission
Backoff times interact causing longer delays

Collision Probability with n Stations:

If each of n stations transmits with probability p:

P(success) = n × p × (1-p)^(n-1)
Optimal p = 1/n (each station transmits with probability 1/n)
At optimal: P(success) = (1 - 1/n)^(n-1) → 1/e as n → ∞

This means with many stations, only about 37% of contention slots succeed!

Efficiency Impact of Network Parameters
Change	Effect on 'a'	Effect on Efficiency
Double cable length	a × 2	η decreases significantly
Halve cable length	a × 0.5	η increases
Double data rate	a × 2	η decreases
Double frame size	a × 0.5	η increases
Use jumbo frames (9000B)	a × 0.07 (vs 1518B)	η approaches 99%
Use minimum frames (64B)	a × 24 (vs 1518B)	η drops significantly

3. Traffic Pattern:

Bursty traffic behaves differently than smooth traffic:

Smooth traffic: Predictable, manageable collision rate
Bursty traffic: Spikes cause temporary overload, then recovery
Synchronized bursts: Worst case—many stations transmit simultaneously

Applications like video streaming, file transfers, and database queries each produce different traffic patterns affecting overall efficiency.

Design Guideline

For half-duplex CSMA/CD networks, keep utilization below 40% to maintain good performance under bursty conditions. Above 60% utilization, collision rates become problematic. This is one reason switched full-duplex networks became the standard—they eliminate these concerns entirely.

Worked Examples

Let's work through several efficiency calculations to solidify understanding.

Example 1: Classic 10BASE5 Ethernet

Given:

Data rate: 10 Mbps
Maximum cable length: 2500 m
Frame size: 1518 bytes (maximum)
Propagation velocity: 2 × 10⁸ m/s

example_calculations.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# Example 1: 10BASE5 Maximum Frame Efficiency
 
# Given values
data_rate = 10e6        # 10 Mbps in bps
cable_length = 2500     # meters
frame_size = 1518       # bytes
velocity = 2e8          # m/s
 
# Step 1: Calculate propagation delay (τ)
tau = cable_length / velocity
print(f"Propagation delay (τ): {tau * 1e6:.2f} μs")
# τ = 2500 / (2×10⁸) = 12.5 μs
 
# Step 2: Calculate transmission time (T)
frame_bits = frame_size * 8
T = frame_bits / data_rate
print(f"Transmission time (T): {T * 1e6:.2f} μs")
# T = (1518 × 8) / 10⁶ = 12144 / 10⁶ = 1214.4 μs
 
# Step 3: Calculate 'a' parameter
a = tau / T
print(f"'a' parameter: {a:.4f}")
# a = 12.5 / 1214.4 = 0.0103
 
# Step 4: Calculate maximum efficiency
efficiency = 1 / (1 + 5 * a)
print(f"Maximum efficiency: {efficiency * 100:.2f}%")
# η = 1 / (1 + 5 × 0.0103) = 1 / 1.0515 = 95.1%
 
# Step 5: Calculate maximum achievable throughput
max_throughput = efficiency * data_rate / 1e6
print(f"Maximum throughput: {max_throughput:.2f} Mbps")
# Max throughput = 0.951 × 10 = 9.51 Mbps

Example 2: Minimum Frame Size Impact

Using the same network but minimum 64-byte frames:

example_2_minimum_frame.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Example 2: 10BASE5 Minimum Frame Efficiency
 
# Same network, minimum frame
frame_size_min = 64     # bytes
 
# Transmission time for minimum frame
T_min = (64 * 8) / 10e6   # = 51.2 μs
 
# 'a' parameter
tau = 12.5e-6   # same propagation delay
a_min = tau / T_min
print(f"'a' for 64B frame: {a_min:.4f}")
# a = 12.5 / 51.2 = 0.244
 
# Efficiency
efficiency_min = 1 / (1 + 5 * a_min)
print(f"Efficiency (64B frame): {efficiency_min * 100:.1f}%")
# η = 1 / (1 + 5 × 0.244) = 1 / 2.22 = 45.0%
 
# Throughput
max_throughput_min = efficiency_min * 10
print(f"Max throughput: {max_throughput_min:.1f} Mbps")
# Only 4.5 Mbps achievable with minimum frames!

Example 3: Gigabit Ethernet Comparison

For Gigabit Ethernet, let's see why half-duplex is impractical:

example_3_gigabit.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# Example 3: Gigabit Ethernet (hypothetical half-duplex)
 
# Given: 100m cable, 1 Gbps, 1518-byte frame
data_rate = 1e9         # 1 Gbps
cable_length = 100      # meters (smaller network)
frame_size = 1518       # bytes
velocity = 2e8          # m/s
 
# Propagation delay
tau = cable_length / velocity   # = 0.5 μs
 
# Transmission time
T = (frame_size * 8) / data_rate   # = 12.14 μs
 
# 'a' parameter
a = tau / T
print(f"Gigabit 'a' (max frame): {a:.4f}")
# a = 0.5 / 12.14 = 0.041
 
# Efficiency (still reasonable for max frames!)
efficiency = 1 / (1 + 5 * a)
print(f"Efficiency (1518B): {efficiency * 100:.1f}%")
# η = 1 / (1 + 0.205) = 83.0%
 
# But for minimum 64-byte frames:
T_min = (64 * 8) / 1e9   # = 0.512 μs
a_min = 0.5 / 0.512
print(f"Gigabit 'a' (min frame): {a_min:.4f}")
# a = 0.976 ≈ 1 (terrible!)
 
efficiency_min = 1 / (1 + 5 * a_min)
print(f"Efficiency (64B): {efficiency_min * 100:.1f}%")
# η = 1 / (1 + 4.88) = 17.0%
 
# This is why Gigabit Ethernet uses carrier extension or full-duplex!

Gigabit Half-Duplex Lesson

At Gigabit speeds, even a 100-meter network with minimum frames yields only 17% efficiency. This is why Gigabit Ethernet in half-duplex mode required carrier extension (padding to 512 bytes) and why full-duplex with switches became universal—it eliminates collisions entirely.

Summary: CSMA/CD Efficiency Principles

Understanding CSMA/CD efficiency is essential for network design and performance analysis.

Key Takeaways

•The 'a' parameter is fundamental — a = τ/T determines efficiency. Smaller 'a' means higher efficiency.
•Maximum efficiency formula — η_max = 1/(1+5a) gives the theoretical best case under heavy load.
•Frame size matters greatly — Large frames have smaller 'a' and much higher efficiency than minimum frames.
•Throughput peaks then falls — Increasing load beyond the optimal point causes throughput collapse.
•Higher speeds require shorter distances — At Gigabit speeds, half-duplex CSMA/CD becomes impractical.
•Full-duplex eliminates the problem — Modern switched networks don't use CSMA/CD, achieving near-100% efficiency.

What's Next:

With the theory of collision detection, minimum frame size, jam signals, and efficiency understood, we'll conclude this module by examining CSMA/CD's role in Ethernet—how these principles shaped the most successful LAN technology in history.

Page Complete

You now understand the mathematical foundations of CSMA/CD efficiency—the 'a' parameter, the efficiency formulas, and the factors that affect throughput. This knowledge is essential for network design and understanding why modern networks moved to switched full-duplex architectures.

4 / 5

Loading learning content...

Computer NetworksCSMA/CD

CSMA/CD: Carrier Sense Multiple Access with Collision Detection

LevelIntermediate

Duration60 mins

TopicCSMA/CD

4 / 5

CSMA/CD Efficiency — Mathematical Analysis

Measuring Protocol Performance

What You Will Learn

Defining CSMA/CD Efficiency

Before diving into formulas, we must precisely define what "efficiency" means in the context of CSMA/CD.

Channel Efficiency (η):

Channel efficiency is the fraction of time the channel is used for successful (non-colliding) data transmission:

η = (Time transmitting successful data) / (Total time)

Alternatively:

η = (Successful throughput) / (Channel capacity)

For example, if a 10 Mbps Ethernet network achieves 6 Mbps of actual data throughput, the efficiency is 60%.

What Reduces Efficiency?

Several factors consume channel time without delivering useful data:

Factor	Description	Impact
Collision overhead	Time spent transmitting frames that collide	Wasted bandwidth
Jam signals	32 bits per collision event	Small overhead per collision
Backoff time	Waiting period after collision	Idle channel time
Propagation delay	Signal travel time	Delay before next transmission
Inter-frame gap	Mandatory 96-bit quiet period	Fixed ~1% overhead
Protocol overhead	Headers, preamble, FCS	Reduces payload efficiency

Key Efficiency Metrics:

Normalized Throughput (S): Fraction of channel capacity used for successful transmissions (0 to 1)
Offered Load (G): Total transmission attempts (including retransmissions) as a fraction of channel capacity
Collision Probability (P): Probability that a transmission attempt collides
Maximum Throughput (S_max): Best achievable throughput under optimal load
Delay: Time from frame submission to successful delivery

Load vs. Throughput

The Fundamental Parameter 'a'

The efficiency of CSMA/CD depends critically on a dimensionless parameter called 'a'—the ratio of propagation delay to frame transmission time.

Definition:

a = (Propagation Delay) / (Frame Transmission Time)

a = τ / T

Where:

τ (tau) = Maximum one-way propagation delay across the network
T = Time to transmit one frame

Understanding the 'a' Parameter
Parameter	Formula	Unit
Propagation Delay (τ)	τ = d / v	seconds
d = network diameter	Maximum cable length	meters
v = propagation velocity	~2 × 10⁸ m/s (in cable)	m/s
Transmission Time (T)	T = L / R	seconds
L = frame size	Bits in the frame	bits
R = data rate	Channel bit rate	bits/second
a = τ / T	a = (d × R) / (v × L)	dimensionless

Physical Interpretation:

The parameter 'a' tells us how many frames could fit on the wire at once:

a << 1: Propagation delay is small compared to transmission time. The first bit of a frame reaches the destination before the last bit is transmitted. This is ideal for CSMA/CD.
a ≈ 1: Propagation delay equals transmission time. The channel can 'hold' exactly one frame.
a >> 1: Propagation delay is large compared to transmission time. Multiple frames could be 'in flight' simultaneously—very problematic for CSMA/CD.

Small 'a' (a << 1):
  Sender: [=====Frame=====]
  Wire:    [=====Frame=====]
  Receiver:          [=====Frame=====]
  ↑ Frame nearly fully transmitted before first bit arrives

Large 'a' (a >> 1):
  Sender: [F]
  Wire:    [F]------------------
  Receiver:                             [F]
  ↑ Frame completely transmitted before first bit arrives!

calculate_a_parameter.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
"""
Calculate the 'a' parameter for different network configurations
"""
 
def calculate_a(
    network_diameter_m: float,
    data_rate_mbps: float,
    frame_size_bytes: int,
    velocity_factor: float = 0.67
) -> float:
    """
    Calculate the 'a' parameter for CSMA/CD analysis.
    
    Args:
        network_diameter_m: Maximum distance between stations (meters)
        data_rate_mbps: Channel data rate (megabits per second)
        frame_size_bytes: Size of frame in bytes
        velocity_factor: Fraction of speed of light (typically 0.65-0.77)
    
    Returns:
        The dimensionless 'a' parameter
    """
    # Calculate propagation delay
    speed_of_light = 3e8  # m/s
    propagation_velocity = speed_of_light * velocity_factor  # m/s
    propagation_delay = network_diameter_m / propagation_velocity  # seconds
    
    # Calculate transmission time
    frame_size_bits = frame_size_bytes * 8
    data_rate_bps = data_rate_mbps * 1e6
    transmission_time = frame_size_bits / data_rate_bps  # seconds
    
    # Calculate 'a'
    a = propagation_delay / transmission_time
    
    return a
 
 
# Example calculations
print("Standard 10BASE5 Ethernet:")
a = calculate_a(
    network_diameter_m=2500,
    data_rate_mbps=10,
    frame_size_bytes=1518  # Maximum frame
)
print(f"  a = {a:.4f} (max frame)")
 
a_min = calculate_a(
    network_diameter_m=2500,
    data_rate_mbps=10,
    frame_size_bytes=64  # Minimum frame
)
print(f"  a = {a_min:.4f} (min frame)")
 
 
print("
Gigabit Ethernet (100m cable):")
a = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=1000,
    frame_size_bytes=1518
)
print(f"  a = {a:.4f} (max frame)")
 
a_min = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=1000,
    frame_size_bytes=64
)
print(f"  a = {a_min:.4f} (min frame)")
 
 
print("
10 Gigabit Ethernet (theoretical half-duplex):")
a = calculate_a(
    network_diameter_m=100,
    data_rate_mbps=10000,
    frame_size_bytes=1518
)
print(f"  a = {a:.4f} (max frame)")
 
# Output:
# Standard 10BASE5 Ethernet:
#   a = 0.0082 (max frame)
#   a = 0.1942 (min frame)
#
# Gigabit Ethernet (100m cable):
#   a = 0.0041 (max frame)
#   a = 0.0971 (min frame)
#
# 10 Gigabit Ethernet (theoretical half-duplex):
#   a = 0.0410 (max frame)

Rule of Thumb

The CSMA/CD Efficiency Formula

The maximum efficiency of CSMA/CD can be derived analytically using queueing theory and probability analysis. The classic result is:

Maximum Channel Efficiency:

η_max = 1 / (1 + 5a)

This simplified formula assumes:

Heavy traffic (network always has frames to send)
Many stations (contention is always present)
Optimal load (network operates at maximum throughput point)

Derivation Overview:

The formula comes from analyzing the expected duration of a "transmission cycle":

Transmission Cycle Analysis:

┌─────────────────────────────────────────────────────────────────────────┐
│                       ONE TRANSMISSION CYCLE                            │
├───────────────────────────────────────┬─────────────────────────────────┤
│      CONTENTION INTERVAL              │     TRANSMISSION INTERVAL        │
│                                       │                                 │
│ [C1][C2][C3]...[Cn] contention slots  │ [======Successful Frame======]  │
│                                       │                                 │
│ Average duration: expected number of  │ Duration: T (frame transmission │
│ contention slots × slot time (2τ)     │ time)                           │
└───────────────────────────────────────┴─────────────────────────────────┘

With 'n' stations contending:

Each slot, probability of exactly one transmission: n × (1/n) × (1 - 1/n)^(n-1)
As n → ∞, this approaches 1/e ≈ 0.368
Expected contention slots before success: e ≈ 2.718
Contention interval = e × (slot time) = e × 2τ = 5.44τ

Simplified to 5τ:

The factor of 5 in the formula (rather than 2e ≈ 5.44) comes from practical considerations and approximations. Some derivations use 2e, others use 5—the difference is small.

CSMA/CD Efficiency at Different 'a' Values
a Value	η_max = 1/(1+5a)	Context
0.01	95.2%	Optimal: Long frames, short distance
0.02	90.9%	Good: Standard Ethernet max-frame
0.05	80.0%	Acceptable: Medium conditions
0.10	66.7%	Marginal: Short frames or long distance
0.20	50.0%	Poor: Approaching minimum frame size limits
0.50	28.6%	Very Poor: Network at design limits
1.00	16.7%	Impractical: Theoretical limit case

csmacd_efficiency.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
"""
CSMA/CD Efficiency Calculator
Comprehensive analysis with various formulas and scenarios
"""
 
from dataclasses import dataclass
from typing import Tuple
import math
 
@dataclass
class NetworkConfig:
    """Network configuration parameters"""
    diameter_m: float       # Network diameter in meters
    data_rate_mbps: float   # Data rate in Mbps
    velocity_factor: float = 0.67  # Signal velocity as fraction of c
    
    @property
    def propagation_delay(self) -> float:
        """Maximum one-way propagation delay in seconds"""
        c = 3e8  # speed of light
        v = c * self.velocity_factor
        return self.diameter_m / v
 
 
def calculate_efficiency_simple(a: float) -> float:
    """
    Simplified efficiency formula: η = 1 / (1 + 5a)
    Valid for heavy load, many stations
    """
    return 1 / (1 + 5 * a)
 
 
def calculate_efficiency_precise(a: float, n_stations: int = 10) -> float:
    """
    More precise efficiency formula considering station count
    η = 1 / (1 + (2n-1)/(n) * a)
    """
    contention_factor = (2 * n_stations - 1) / n_stations
    return 1 / (1 + contention_factor * a * math.e)
 
 
def analyze_network(
    config: NetworkConfig,
    frame_size_bytes: int
) -> dict:
    """
    Complete efficiency analysis for a network configuration
    """
    # Calculate transmission time
    frame_bits = frame_size_bytes * 8
    data_rate_bps = config.data_rate_mbps * 1e6
    transmission_time = frame_bits / data_rate_bps
    
    # Calculate 'a' parameter
    a = config.propagation_delay / transmission_time
    
    # Calculate efficiencies
    efficiency_simple = calculate_efficiency_simple(a)
    efficiency_precise = calculate_efficiency_precise(a)
    
    # Calculate slot time (2 × propagation delay for round-trip)
    slot_time = 2 * config.propagation_delay
    
    # Calculate maximum throughput
    max_throughput_mbps = efficiency_simple * config.data_rate_mbps
    
    return {
        'propagation_delay_us': config.propagation_delay * 1e6,
        'transmission_time_us': transmission_time * 1e6,
        'a_parameter': a,
        'slot_time_us': slot_time * 1e6,
        'efficiency_simple': efficiency_simple,
        'efficiency_precise': efficiency_precise,
        'max_throughput_mbps': max_throughput_mbps,
    }
 
 
# Analyze different scenarios
print("=" * 70)
print("CSMA/CD EFFICIENCY ANALYSIS")
print("=" * 70)
 
# Scenario 1: Classic 10BASE5 Ethernet
config_10base5 = NetworkConfig(
    diameter_m=2500,
    data_rate_mbps=10
)
 
print("
10BASE5 Ethernet (2500m, 10 Mbps):")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_10base5, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.2f} Mbps")
 
# Scenario 2: 100BASE-TX Ethernet
config_100base = NetworkConfig(
    diameter_m=200,
    data_rate_mbps=100
)
 
print("
100BASE-TX Ethernet (200m, 100 Mbps):")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_100base, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.1f} Mbps")
 
# Scenario 3: Gigabit Ethernet (half-duplex, theoretical)
config_1gbase = NetworkConfig(
    diameter_m=100,
    data_rate_mbps=1000
)
 
print("
Gigabit Ethernet (100m, 1 Gbps) [theoretical half-duplex]:")
for frame_size in [64, 512, 1518]:
    result = analyze_network(config_1gbase, frame_size)
    print(f"  Frame={frame_size}B: a={result['a_parameter']:.4f}, "
          f"η={result['efficiency_simple']*100:.1f}%, "
          f"Max={result['max_throughput_mbps']:.0f} Mbps")

The Small Frame Problem

Throughput vs. Load Curve

The Throughput Equation:

For CSMA/CD, the relationship is approximately:

S = G × e^(-2aG) (simplified for 1-persistent CSMA/CD)

Where:

S = Normalized throughput (0 to 1)
G = Normalized offered load (can exceed 1 due to retransmissions)
a = Propagation parameter (τ/T)

Throughput Curve Characteristics:

Throughput (S)
    ^
    |                    ____
    |                 __/    \____
    |              __/            \____
S_max|............./....................\....... Maximum throughput
    |           /                          \
    |          /                             \
    |         /                                \
    |        /                                   \
    |       /                                      \
    |      /                                         \
    |_____/______________________________________________\____> Load (G)
    0    G_opt                                              
         (optimal load)

Key Observations:

Rising Phase (G < G_opt): Throughput increases with load. More traffic means more successful transmissions. The channel has spare capacity.
Peak (G = G_opt): Maximum throughput S_max is achieved. The network is at optimal operating point.
Falling Phase (G > G_opt): Throughput decreases as load increases! Collisions become so frequent that retransmissions dominate, wasting bandwidth.
Collapse (G >> G_opt): The network enters "collision collapse" where almost all time is spent on collisions and backoff.

Throughput at Different Load Levels
Load (G)	Relative State	Collisions	Efficiency
0.1	Light	Rare	~90% of capacity used
0.3	Moderate	Occasional	Near optimal
0.5	Heavy	Frequent	At or near maximum
0.8	Overloaded	Very frequent	Declining
1.0	Saturated	Dominant	Significantly degraded
2.0+	Collapsed	Almost continuous	Severe degradation

Optimal Operating Point:

The optimal load G_opt that maximizes throughput can be found by differentiating the throughput equation:

For S = G × e^(-2aG)
dS/dG = e^(-2aG) - 2aG × e^(-2aG)
      = e^(-2aG) × (1 - 2aG)

Setting dS/dG = 0:
1 - 2aG = 0
G_opt = 1/(2a)

Substituting back:
S_max = G_opt × e^(-2a × G_opt)
      = (1/2a) × e^(-1)
      = 1/(2ae)
      ≈ 0.184/a

For small 'a' (which is typical), this approximates to:

η_max ≈ 1 / (1 + 5a) (the formula we saw earlier)

Why Throughput Drops at High Load

Factors Affecting CSMA/CD Efficiency

Multiple factors influence CSMA/CD efficiency. Understanding these factors enables network designers to optimize performance.

1. Frame Size:

Larger frames are more efficient because:

Transmission time (T) increases
'a' parameter decreases (a = τ/T)
Fixed overheads (headers, IFG, preamble) are amortized over more data

Factors That INCREASE Efficiency

•Larger frame sizes — More data per transmission
•Shorter cables — Less propagation delay
•Lower data rates — Longer transmission time
•Fewer stations — Less contention
•Moderate traffic — Optimal load range

Factors That DECREASE Efficiency

•Smaller frame sizes — Higher overhead ratio
•Longer cables — More propagation delay
•Higher data rates — Shorter transmission time
•More stations — More contention
•Heavy traffic — Beyond optimal load

2. Number of Stations:

With more stations contending:

Collision probability increases
More contention slots before successful transmission
Backoff times interact causing longer delays

Collision Probability with n Stations:

If each of n stations transmits with probability p:

P(success) = n × p × (1-p)^(n-1)
Optimal p = 1/n (each station transmits with probability 1/n)
At optimal: P(success) = (1 - 1/n)^(n-1) → 1/e as n → ∞

This means with many stations, only about 37% of contention slots succeed!

Efficiency Impact of Network Parameters
Change	Effect on 'a'	Effect on Efficiency
Double cable length	a × 2	η decreases significantly
Halve cable length	a × 0.5	η increases
Double data rate	a × 2	η decreases
Double frame size	a × 0.5	η increases
Use jumbo frames (9000B)	a × 0.07 (vs 1518B)	η approaches 99%
Use minimum frames (64B)	a × 24 (vs 1518B)	η drops significantly

3. Traffic Pattern:

Bursty traffic behaves differently than smooth traffic:

Smooth traffic: Predictable, manageable collision rate
Bursty traffic: Spikes cause temporary overload, then recovery
Synchronized bursts: Worst case—many stations transmit simultaneously

Applications like video streaming, file transfers, and database queries each produce different traffic patterns affecting overall efficiency.

Design Guideline

Worked Examples

Let's work through several efficiency calculations to solidify understanding.

Example 1: Classic 10BASE5 Ethernet

Given:

Data rate: 10 Mbps
Maximum cable length: 2500 m
Frame size: 1518 bytes (maximum)
Propagation velocity: 2 × 10⁸ m/s

example_calculations.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# Example 1: 10BASE5 Maximum Frame Efficiency
 
# Given values
data_rate = 10e6        # 10 Mbps in bps
cable_length = 2500     # meters
frame_size = 1518       # bytes
velocity = 2e8          # m/s
 
# Step 1: Calculate propagation delay (τ)
tau = cable_length / velocity
print(f"Propagation delay (τ): {tau * 1e6:.2f} μs")
# τ = 2500 / (2×10⁸) = 12.5 μs
 
# Step 2: Calculate transmission time (T)
frame_bits = frame_size * 8
T = frame_bits / data_rate
print(f"Transmission time (T): {T * 1e6:.2f} μs")
# T = (1518 × 8) / 10⁶ = 12144 / 10⁶ = 1214.4 μs
 
# Step 3: Calculate 'a' parameter
a = tau / T
print(f"'a' parameter: {a:.4f}")
# a = 12.5 / 1214.4 = 0.0103
 
# Step 4: Calculate maximum efficiency
efficiency = 1 / (1 + 5 * a)
print(f"Maximum efficiency: {efficiency * 100:.2f}%")
# η = 1 / (1 + 5 × 0.0103) = 1 / 1.0515 = 95.1%
 
# Step 5: Calculate maximum achievable throughput
max_throughput = efficiency * data_rate / 1e6
print(f"Maximum throughput: {max_throughput:.2f} Mbps")
# Max throughput = 0.951 × 10 = 9.51 Mbps

Example 2: Minimum Frame Size Impact

Using the same network but minimum 64-byte frames:

example_2_minimum_frame.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Example 2: 10BASE5 Minimum Frame Efficiency
 
# Same network, minimum frame
frame_size_min = 64     # bytes
 
# Transmission time for minimum frame
T_min = (64 * 8) / 10e6   # = 51.2 μs
 
# 'a' parameter
tau = 12.5e-6   # same propagation delay
a_min = tau / T_min
print(f"'a' for 64B frame: {a_min:.4f}")
# a = 12.5 / 51.2 = 0.244
 
# Efficiency
efficiency_min = 1 / (1 + 5 * a_min)
print(f"Efficiency (64B frame): {efficiency_min * 100:.1f}%")
# η = 1 / (1 + 5 × 0.244) = 1 / 2.22 = 45.0%
 
# Throughput
max_throughput_min = efficiency_min * 10
print(f"Max throughput: {max_throughput_min:.1f} Mbps")
# Only 4.5 Mbps achievable with minimum frames!

Example 3: Gigabit Ethernet Comparison

For Gigabit Ethernet, let's see why half-duplex is impractical:

example_3_gigabit.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# Example 3: Gigabit Ethernet (hypothetical half-duplex)
 
# Given: 100m cable, 1 Gbps, 1518-byte frame
data_rate = 1e9         # 1 Gbps
cable_length = 100      # meters (smaller network)
frame_size = 1518       # bytes
velocity = 2e8          # m/s
 
# Propagation delay
tau = cable_length / velocity   # = 0.5 μs
 
# Transmission time
T = (frame_size * 8) / data_rate   # = 12.14 μs
 
# 'a' parameter
a = tau / T
print(f"Gigabit 'a' (max frame): {a:.4f}")
# a = 0.5 / 12.14 = 0.041
 
# Efficiency (still reasonable for max frames!)
efficiency = 1 / (1 + 5 * a)
print(f"Efficiency (1518B): {efficiency * 100:.1f}%")
# η = 1 / (1 + 0.205) = 83.0%
 
# But for minimum 64-byte frames:
T_min = (64 * 8) / 1e9   # = 0.512 μs
a_min = 0.5 / 0.512
print(f"Gigabit 'a' (min frame): {a_min:.4f}")
# a = 0.976 ≈ 1 (terrible!)
 
efficiency_min = 1 / (1 + 5 * a_min)
print(f"Efficiency (64B): {efficiency_min * 100:.1f}%")
# η = 1 / (1 + 4.88) = 17.0%
 
# This is why Gigabit Ethernet uses carrier extension or full-duplex!

Gigabit Half-Duplex Lesson

Summary: CSMA/CD Efficiency Principles

Understanding CSMA/CD efficiency is essential for network design and performance analysis.

Key Takeaways

•The 'a' parameter is fundamental — a = τ/T determines efficiency. Smaller 'a' means higher efficiency.
•Maximum efficiency formula — η_max = 1/(1+5a) gives the theoretical best case under heavy load.
•Frame size matters greatly — Large frames have smaller 'a' and much higher efficiency than minimum frames.
•Throughput peaks then falls — Increasing load beyond the optimal point causes throughput collapse.
•Higher speeds require shorter distances — At Gigabit speeds, half-duplex CSMA/CD becomes impractical.
•Full-duplex eliminates the problem — Modern switched networks don't use CSMA/CD, achieving near-100% efficiency.

What's Next:

Page Complete

4 / 5