Computer NetworksFragmentation Calculations

IP Fragmentation Calculations: Mastering the Mathematics

LevelIntermediate

Duration90 mins

TopicFragmentation Calculations

4 / 5

Header Overhead

The Hidden Cost of Fragmentation

Every IP fragment carries its own complete IP header. When a single datagram becomes multiple fragments, the cumulative header bytes represent pure overhead—bytes transmitted that carry no application data. This overhead consumes bandwidth, adds latency, and strains processing resources.

Consider a 60,000-byte file transfer fragmented into 41 fragments over Ethernet:

Without fragmentation: 20 bytes of IP header (0.03% overhead)
With fragmentation: 41 × 20 = 820 bytes of IP headers (1.4% overhead)

That's 800 extra bytes—a 41× increase in header overhead. For high-volume data transfers, constrained wireless links, or metered connections, this overhead has real costs.

This page quantifies fragmentation overhead and develops formulas for calculating efficiency impact in any scenario.

What You Will Learn

By the end of this page, you will understand: (1) How to calculate header overhead for any fragmentation scenario, (2) The efficiency percentage formula comparing overhead to payload, (3) How MTU size affects overhead ratios, (4) Total bandwidth consumption including headers, and (5) Optimization strategies to minimize fragmentation overhead.

Understanding Header Overhead

Header overhead in the context of fragmentation refers to the additional header bytes beyond what a single unfragmented datagram would require.

Overhead Definition:

Overhead = (Total Header Bytes with Fragmentation) - (Original Header Bytes)
         = (N × Fragment_Header_Size) - Original_Header_Size

For standard IP headers (20 bytes):

Overhead = (N × 20) - 20 = 20 × (N - 1) bytes

Where N = number of fragments.

Key Insight:

The original datagram already had one header. Fragmentation adds (N-1) additional headers. The overhead grows linearly with fragment count.

Header Overhead by Fragment Count (20-byte headers)
Fragments	Total Headers	Original	Overhead	Overhead %*
1	20 bytes	20 bytes	0 bytes	0%
2	40 bytes	20 bytes	20 bytes	100%
3	60 bytes	20 bytes	40 bytes	200%
5	100 bytes	20 bytes	80 bytes	400%
7	140 bytes	20 bytes	120 bytes	600%
10	200 bytes	20 bytes	180 bytes	900%
45	900 bytes	20 bytes	880 bytes	4400%

*Overhead % = (Additional Headers / Original Header) × 100

Why This Matters:

For large data transfers, this header multiplication occurs for every datagram. A file transfer sending 1,000 large datagrams, each fragmenting into 7 pieces, adds:

1,000 datagrams × 6 extra headers × 20 bytes = 120,000 bytes = 117 KB of pure overhead

That's 117 KB of bandwidth consumed without delivering any application data.

Layer 2 Overhead Compounds

IP header overhead is just part of the story. Each fragment also requires its own Layer 2 frame header (e.g., 14-18 bytes for Ethernet). The true overhead is even higher when considering the complete protocol stack.

Calculating Total Transmission Size

The total bytes transmitted for a fragmented datagram includes both data and all headers. This "transmission size" determines actual bandwidth consumption.

Transmission Size Formula:

Total Transmission = Original_Data + (N × Header_Size)
                   = Original_Data + (N × 20)  [for standard headers]

Alternative Form:

Total Transmission = Sum of all fragment Total_Length values

Each fragment's Total Length = Fragment_Data + Fragment_Header

Comparison Formulas:

Original Size = Original_Data + Original_Header
Fragment Size = Original_Data + (N × Header_Size)
Size Increase = (N - 1) × Header_Size

transmission_size_calculation.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
import math
 
def calculate_transmission_metrics(original_data, mtu, header_size=20):
    """
    Calculate complete transmission metrics for fragmentation.
    
    Returns:
        dict with all relevant metrics
    """
    # Maximum data per fragment
    max_frag_data = ((mtu - header_size) // 8) * 8
    
    # Number of fragments
    num_fragments = math.ceil(original_data / max_frag_data)
    
    # Size calculations
    original_total = original_data + header_size
    fragmented_total = original_data + (num_fragments * header_size)
    overhead = fragmented_total - original_total
    
    return {
        'original_data': original_data,
        'original_total': original_total,
        'fragments': num_fragments,
        'fragmented_total': fragmented_total,
        'header_overhead': overhead,
        'overhead_percent': (overhead / original_total) * 100,
        'efficiency': (original_data / fragmented_total) * 100
    }
 
# Analyze various scenarios
print("Transmission Size Analysis (MTU 1500, Header 20)")
print("="*70)
 
test_cases = [
    (1000, "Small packet (no fragmentation)"),
    (1480, "Exactly 1 fragment capacity"),
    (2960, "Exactly 2 fragment capacity"),
    (5000, "Typical large transfer"),
    (10000, "10KB data"),
    (65515, "Maximum IPv4 data"),
]
 
for data_size, description in test_cases:
    m = calculate_transmission_metrics(data_size, 1500)
    print(f"\n{description}:")
    print(f"  Original: {m['original_total']:6d} bytes ({m['original_data']} data + 20 header)")
    print(f"  With fragmentation: {m['fragmented_total']:6d} bytes "
          f"({m['fragments']} fragments)")
    print(f"  Header overhead: {m['header_overhead']:4d} bytes "
          f"({m['overhead_percent']:.1f}% of original)")
    print(f"  Transmission efficiency: {m['efficiency']:.1f}%")

Efficiency Interpretation

Transmission efficiency = (Original Data / Total Bytes Sent) × 100%. An efficiency of 98.6% means 1.4% of transmitted bytes are headers. Even small efficiency losses compound over large transfers—1.4% of a 1TB transfer is 14GB of overhead!

MTU Impact on Overhead Ratios

Smaller MTUs create more fragments, increasing overhead proportionally. Understanding this relationship helps in network design and MTU optimization.

The MTU-Overhead Relationship:

For a fixed data size, decreasing MTU:

Increases fragment count
Increases total header bytes
Decreases transmission efficiency
Increases processing overhead

Comparative Analysis:

10,000-Byte Data Transfer Across Different MTUs
MTU	Max Frag Data	Fragments	Total Headers	Overhead	Efficiency
9000 (Jumbo)	8976	2	40 bytes	20 bytes	99.6%
4500	4480	3	60 bytes	40 bytes	99.4%
1500 (Ethernet)	1480	7	140 bytes	120 bytes	98.6%
1000	976	11	220 bytes	200 bytes	97.8%
576 (Minimum)	552	19	380 bytes	360 bytes	96.3%
296	272	37	740 bytes	720 bytes	93.1%

mtu_overhead_analysis.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
import math
 
def analyze_mtu_impact(original_data, mtu_list, header_size=20):
    """Compare overhead across different MTUs."""
    results = []
    
    for mtu in mtu_list:
        max_data = ((mtu - header_size) // 8) * 8
        fragments = math.ceil(original_data / max_data)
        total_headers = fragments * header_size
        overhead = total_headers - header_size
        total_bytes = original_data + total_headers
        efficiency = (original_data / total_bytes) * 100
        
        results.append({
            'mtu': mtu,
            'max_data': max_data,
            'fragments': fragments,
            'total_headers': total_headers,
            'overhead': overhead,
            'efficiency': efficiency
        })
    
    return results
 
# Compare MTUs for a 50KB transfer
data_size = 50000
mtu_list = [9000, 4500, 1500, 1000, 576]
 
print(f"Overhead Analysis: {data_size:,} bytes data")
print("="*70)
 
results = analyze_mtu_impact(data_size, mtu_list)
 
print(f"{'MTU':>6} {'Frags':>6} {'Headers':>10} {'Overhead':>10} {'Efficiency':>12}")
print("-"*46)
 
for r in results:
    print(f"{r['mtu']:>6} {r['fragments']:>6} {r['total_headers']:>10} "
          f"{r['overhead']:>10} {r['efficiency']:>11.2f}%")
 
# Calculate bandwidth "tax" for 1GB transfer
print("\n" + "="*70)
print("Bandwidth 'Tax' for 1 GB transfer:")
print("-"*46)
 
for r in results:
    # For 1GB of actual data
    data_gb = 1024 * 1024 * 1024  # 1 GB in bytes
    overhead_per_frag = (r['fragments'] - 1) * 20  # Extra headers per original datagram
    datagrams = math.ceil(data_gb / 50000)  # Assuming 50KB datagrams
    total_overhead = datagrams * overhead_per_frag
    overhead_mb = total_overhead / (1024 * 1024)
    
    print(f"  MTU {r['mtu']}: {overhead_mb:.1f} MB extra header data")

Jumbo Frames Trade-off

While jumbo frames (MTU 9000) dramatically reduce overhead, they require end-to-end support. A single link with standard MTU forces fragmentation of jumbo frames, potentially worsening efficiency if Path MTU Discovery fails. Always verify the complete path supports jumbo frames before enabling them.

Layer 2 Overhead Considerations

IP fragmentation overhead is compounded by Layer 2 framing. Each IP fragment becomes a separate Layer 2 frame, each with its own headers.

Complete Overhead Stack:

Per Fragment:
├── Ethernet Header: 14 bytes (destination MAC, source MAC, EtherType)
├── IP Header: 20-60 bytes
├── IP Data: variable
├── Ethernet FCS: 4 bytes (Frame Check Sequence)
└── Interframe Gap: 12 bytes (mandatory silence between frames)

Total Ethernet overhead per frame: 14 + 4 + 12 = 30 bytes
Plus optional: 802.1Q VLAN tag adds 4 bytes

Combined Overhead Formula:

Total Overhead = N × (L2_Header + IP_Header + L2_Trailer + IFG) - Original_Headers
              = N × (14 + 20 + 4 + 12) - (14 + 20 + 4 + 12)
              = (N - 1) × 50 bytes  [for standard Ethernet + IP]

Complete Protocol Stack Overhead per Fragment
Layer	Component	Size	Notes
L2	Ethernet Header	14 bytes	Dest MAC + Src MAC + EtherType
L2	VLAN Tag (optional)	4 bytes	802.1Q if tagged
L3	IP Header	20-60 bytes	20 typical, up to 60 with options
L2	Ethernet FCS	4 bytes	CRC-32 checksum
L1	Preamble + SFD	8 bytes	Not counted in MTU
L1	Interframe Gap	12 bytes	96 bits of silence

complete_overhead_analysis.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
import math
 
def complete_overhead_analysis(original_data, mtu, include_l1=True):
    """
    Calculate complete overhead including Layer 2/1.
    
    Args:
        original_data: Application data size
        mtu: Layer 3 MTU (IP datagram max size)
        include_l1: Whether to include preamble and IFG
    """
    # IP parameters
    ip_header = 20
    max_frag_data = ((mtu - ip_header) // 8) * 8
    fragments = math.ceil(original_data / max_frag_data)
    
    # Layer 2 parameters (Ethernet)
    eth_header = 14
    eth_fcs = 4
    
    # Layer 1 parameters
    preamble_sfd = 8 if include_l1 else 0
    ifg = 12 if include_l1 else 0
    
    # Per-frame overhead
    per_frame_overhead = eth_header + ip_header + eth_fcs + preamble_sfd + ifg
    
    # Calculate totals
    total_overhead = fragments * per_frame_overhead
    original_overhead = per_frame_overhead  # Single frame would have this
    added_overhead = total_overhead - original_overhead
    
    # Bytes on wire
    total_on_wire = original_data + total_overhead
    efficiency = (original_data / total_on_wire) * 100
    
    return {
        'fragments': fragments,
        'per_frame_overhead': per_frame_overhead,
        'total_overhead': total_overhead,
        'added_overhead': added_overhead,
        'total_on_wire': total_on_wire,
        'efficiency': efficiency
    }
 
# Analyze 10KB transfer with complete overhead
print("Complete Overhead Analysis: 10,000 bytes data, MTU 1500")
print("="*60)
 
result = complete_overhead_analysis(10000, 1500, include_l1=True)
 
print(f"Fragments: {result['fragments']}")
print(f"Per-frame overhead: {result['per_frame_overhead']} bytes")
print(f"  (14 Eth + 20 IP + 4 FCS + 8 Preamble + 12 IFG)")
print(f"Total overhead: {result['total_overhead']} bytes")
print(f"Added by fragmentation: {result['added_overhead']} bytes")
print(f"Total on wire: {result['total_on_wire']} bytes")
print(f"Wire efficiency: {result['efficiency']:.2f}%")
 
# Compare L3-only vs complete stack
print("\n" + "="*60)
print("Comparison: IP-only vs Complete Stack Overhead")
print("-"*60)
 
for data in [5000, 10000, 50000]:
    ip_only = complete_overhead_analysis(data, 1500, include_l1=False)
    complete = complete_overhead_analysis(data, 1500, include_l1=True)
    
    print(f"\n{data:,} bytes data:")
    print(f"  IP-only overhead:  {(ip_only['fragments']-1)*20:4d} bytes "
          f"(efficiency: {(data/(data+ip_only['fragments']*20))*100:.2f}%)")
    print(f"  Complete overhead: {complete['added_overhead']:4d} bytes "
          f"(efficiency: {complete['efficiency']:.2f}%)")

What Counts as 'On the Wire'

Different contexts measure overhead differently. Link utilization includes L1 (preamble, IFG). Packet captures show L2 and up. IP analysis focuses on L3. Be clear about which layers you're measuring when discussing efficiency.

Processing Overhead

Beyond bandwidth, fragmentation incurs processing costs at routers, firewalls, and destination hosts. These computational overheads can impact performance, especially on high-volume links or resource-constrained devices.

Processing Requirements per Fragment:

Per-Fragment Processing Costs

•Header Checksum Calculation — Each fragment's IP header has its own checksum, requiring computation at creation and verification at each hop
•Routing Table Lookup — Each fragment is independently routed, requiring separate forwarding table lookups
•Buffer Allocation — Routers allocate packet buffers for each fragment passing through
•Access Control List Processing — Firewalls must process each fragment against security rules
•Quality of Service Classification — Each fragment undergoes independent QoS marking and queuing
•NAT Translation — If applicable, each fragment requires NAT table lookup and possible modification

Destination Reassembly Costs:

The destination bears additional burdens:

Operation	Description	Resource Cost
Fragment Table Maintenance	Track pending fragments by ID	Memory
Fragment Ordering	Sort fragments by offset	CPU + Memory
Gap Detection	Identify missing fragments	CPU
Timeout Management	Handle incomplete reassembly	CPU + Timer
Buffer Allocation	Hold fragments until complete	Memory
Reassembly	Combine fragments into datagram	Memory + Copying

Memory Pressure Example:

A destination receiving incomplete fragment sets must hold them pending:

Default Linux timeout: 30 seconds
During attack: Thousands of partial datagrams
Memory consumed: (Fragment data + metadata) × pending datagrams

This enables fragmentation-based DoS attacks that exhaust reassembly buffers.

Security Device Performance Impact

Firewalls and IDS must often reassemble fragments to inspect application data. High fragment rates can overwhelm these devices, creating blind spots or causing packet drops. Some security devices simply block all fragmented traffic as a defensive measure.

Overhead Minimization Strategies

Given fragmentation's costs, minimizing or eliminating it is a network design priority. Several strategies effectively reduce fragmentation overhead.

Network-Level Strategies

•Path MTU Discovery — Discover minimum MTU and size datagrams appropriately at source
•Consistent MTU Design — Configure uniform MTU across all links to avoid fragmentation points
•Jumbo Frame Adoption — Use larger MTUs (9000 bytes) where end-to-end support exists
•Tunnel MTU Adjustment — Account for encapsulation overhead in tunnel endpoints

Application-Level Strategies

•TCP MSS Negotiation — TCP automatically sizes segments to avoid fragmentation
•UDP Application Sizing — Applications should limit UDP payloads to path MTU
•DF Flag Usage — Set Don't Fragment to trigger ICMP feedback for PMTUD
•Protocol-Specific Limits — DNS uses 512-byte default to ensure no fragmentation

calculate_optimal_payload.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
def calculate_optimal_payload(path_mtu, protocol='tcp', tunnel_overhead=0):
    """
    Calculate the maximum payload to avoid fragmentation.
    
    Args:
        path_mtu: Minimum MTU along the path
        protocol: 'tcp', 'udp', or 'icmp'
        tunnel_overhead: Additional bytes for tunnel encapsulation
    
    Returns:
        dict with optimal sizes
    """
    # Adjust for tunnel overhead
    effective_mtu = path_mtu - tunnel_overhead
    
    # Protocol headers
    ip_header = 20
    tcp_header = 20  # Minimum, can be up to 60
    udp_header = 8
    icmp_header = 8
    
    protocol_headers = {
        'tcp': tcp_header,
        'udp': udp_header,
        'icmp': icmp_header
    }
    
    proto_header = protocol_headers.get(protocol, 0)
    
    # Maximum payload without fragmentation
    max_payload = effective_mtu - ip_header - proto_header
    
    # For connection-oriented protocols, this is MSS
    mss = effective_mtu - ip_header - tcp_header if protocol == 'tcp' else None
    
    return {
        'path_mtu': path_mtu,
        'tunnel_overhead': tunnel_overhead,
        'effective_mtu': effective_mtu,
        'protocol': protocol,
        'max_payload': max_payload,
        'tcp_mss': mss
    }
 
# Common scenarios
print("Optimal Payload Calculations to Avoid Fragmentation")
print("="*60)
 
scenarios = [
    (1500, 'tcp', 0, "Standard Ethernet"),
    (1500, 'udp', 0, "Standard Ethernet UDP"),
    (1500, 'tcp', 20, "GRE Tunnel"),
    (1500, 'tcp', 50, "IPsec ESP Tunnel"),
    (1492, 'tcp', 0, "PPPoE"),
    (576, 'udp', 0, "Minimum Internet MTU"),
]
 
for mtu, proto, tunnel, desc in scenarios:
    result = calculate_optimal_payload(mtu, proto, tunnel)
    print(f"\n{desc} ({proto.upper()}):")
    if tunnel > 0:
        print(f"  Path MTU: {result['path_mtu']}, Tunnel overhead: {tunnel} bytes")
        print(f"  Effective MTU: {result['effective_mtu']}")
    else:
        print(f"  MTU: {result['path_mtu']}")
    print(f"  Max payload without fragmentation: {result['max_payload']} bytes")
    if result['tcp_mss']:
        print(f"  TCP MSS: {result['tcp_mss']} bytes")

The 1400-Byte Safe Zone

When path MTU is unknown, 1400 bytes is a commonly used 'safe' maximum payload. It accommodates most tunnel overheads (IPsec, GRE, PPPoE) on Ethernet. Applications designed for uncertain network conditions often use 1400 as a conservative limit.

Real-World Overhead Examples

Let's analyze fragmentation overhead in realistic enterprise and Internet scenarios.

Example 1: Video Streaming Over VPN

A remote worker streams video from a corporate server. The VPN adds IPsec overhead, reducing effective MTU. Video UDP packets are 1472 bytes, causing fragmentation.

vpn_video_overhead.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
import math
 
# Video streaming over IPsec VPN
print("Example 1: Video Streaming Over VPN")
print("="*60)
 
# Parameters
video_packet_size = 1472  # UDP payload (common for video)
udp_header = 8
inner_ip = 20
ipsec_overhead = 58  # ESP header + trailer + auth
outer_ip = 20
physical_mtu = 1500
 
# Inner packet size (what IPsec must encapsulate)
inner_total = video_packet_size + udp_header + inner_ip  # 1500 bytes
 
# After IPsec
encapsulated = inner_total + ipsec_overhead  # 1558 bytes
 
# This exceeds MTU, so outer IP must fragment
outer_data = encapsulated  # IP payload to fragment
max_frag_data = ((physical_mtu - outer_ip) // 8) * 8  # 1480 bytes
fragments = math.ceil(outer_data / max_frag_data)  # 2 fragments
 
print(f"Video packet: {video_packet_size} bytes")
print(f"Inner IP datagram: {inner_total} bytes")
print(f"After IPsec: {encapsulated} bytes")
print(f"Physical MTU: {physical_mtu} bytes")
print(f"Fragmentation: {fragments} fragments per video packet")
 
# Streaming 1 hour at 5 Mbps
bitrate = 5 * 1000 * 1000  # 5 Mbps
duration = 3600  # 1 hour
total_bytes = (bitrate * duration) / 8
packets = total_bytes / video_packet_size
extra_headers = packets * (fragments - 1) * outer_ip
 
print(f"\n1-hour stream at 5 Mbps:")
print(f"  Total data: {total_bytes/1e9:.2f} GB")
print(f"  Video packets: {packets:,.0f}")
print(f"  Extra headers from fragmentation: {extra_headers/1e6:.2f} MB")
print(f"  Overhead percentage: {(extra_headers/total_bytes)*100:.2f}%")

Example 2: Database Backup Over WAN

A database backup transfers large (64KB) blocks over a WAN with MTU 1500. Each block becomes a datagram that must be fragmented.

database_backup_overhead.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
import math
 
# Database backup analysis
print("\nExample 2: Database Backup Over WAN")
print("="*60)
 
# Parameters
block_size = 65536  # 64 KB blocks
mtu = 1500
ip_header = 20
max_data = ((mtu - ip_header) // 8) * 8  # 1480 bytes
 
# Fragmentation per block
frags_per_block = math.ceil(block_size / max_data)  # 45 fragments
headers_per_block = frags_per_block * ip_header
overhead_per_block = headers_per_block - ip_header  # Extra headers
 
print(f"Block size: {block_size:,} bytes")
print(f"Fragments per block: {frags_per_block}")
print(f"Header overhead per block: {overhead_per_block} bytes")
print(f"Overhead per block: {(overhead_per_block/block_size)*100:.2f}%")
 
# 1 TB backup
backup_size = 1024 ** 4  # 1 TB
blocks = backup_size / block_size
total_overhead = blocks * overhead_per_block
 
print(f"\n1 TB backup:")
print(f"  Blocks: {blocks:,.0f}")
print(f"  Total header overhead: {total_overhead/1e9:.2f} GB")
print(f"  Extra time at 1 Gbps: {(total_overhead*8)/(1e9):.1f} seconds")
 
# Compare to optimal (no fragmentation at source)
print(f"\nOptimization:")
print(f"  If application used PMTUD to avoid fragmentation:")
print(f"  Original headers only: {blocks * ip_header / 1e6:.1f} MB")
print(f"  Savings: {total_overhead/1e9:.2f} GB")

Modern Applications Avoid This

Well-designed backup applications use TCP with proper MSS negotiation or implement their own chunking at the application layer, avoiding IP-level fragmentation entirely. These examples illustrate why transport-layer awareness of path MTU is critical.

Summary: Header Overhead Analysis

We've thoroughly analyzed the overhead costs of IP fragmentation. Let's consolidate the key formulas and insights.

Key Overhead Formulas

•Header Overhead = (N - 1) × Header_Size — Extra headers beyond the original
•Total Transmission = Data + (N × Header_Size) — Complete bytes sent
•Efficiency = Data / Total_Transmission × 100 — Payload as percentage of transmission
•Complete Overhead = (N - 1) × (L2_Header + IP_Header + L2_Trailer + IFG) — Full stack overhead
•Overhead compounds with fragment count — Smaller MTU = more fragments = more overhead
•Processing overhead scales linearly with fragments — Each fragment requires independent handling

Quick Reference: Overhead Impact
Metric	Formula/Value	Notes
Extra headers	(N-1) × 20 bytes	For standard IP
Max efficiency loss	~7% at MTU 576	For max-size datagrams
L2 overhead per frag	14 + 4 + 12 = 30 bytes	Ethernet (excl. preamble)
Safe payload limit	1400 bytes	Works across most paths

What's Next:

With comprehensive understanding of fragment calculations—sizes, offsets, counts, and overhead—the final page brings everything together with practical problems. We'll solve complex, exam-style and real-world scenarios that integrate all fragmentation concepts.

Overhead Analysis Complete

You now understand the full cost of fragmentation—bandwidth, processing, and efficiency impacts. This knowledge supports network design decisions that minimize fragmentation and optimize performance.

4 / 5

Loading learning content...

Computer NetworksFragmentation Calculations

IP Fragmentation Calculations: Mastering the Mathematics

LevelIntermediate

Duration90 mins

TopicFragmentation Calculations

4 / 5

Header Overhead

The Hidden Cost of Fragmentation

Consider a 60,000-byte file transfer fragmented into 41 fragments over Ethernet:

Without fragmentation: 20 bytes of IP header (0.03% overhead)
With fragmentation: 41 × 20 = 820 bytes of IP headers (1.4% overhead)

That's 800 extra bytes—a 41× increase in header overhead. For high-volume data transfers, constrained wireless links, or metered connections, this overhead has real costs.

This page quantifies fragmentation overhead and develops formulas for calculating efficiency impact in any scenario.

What You Will Learn

Understanding Header Overhead

Header overhead in the context of fragmentation refers to the additional header bytes beyond what a single unfragmented datagram would require.

Overhead Definition:

Overhead = (Total Header Bytes with Fragmentation) - (Original Header Bytes)
         = (N × Fragment_Header_Size) - Original_Header_Size

For standard IP headers (20 bytes):

Overhead = (N × 20) - 20 = 20 × (N - 1) bytes

Where N = number of fragments.

Key Insight:

The original datagram already had one header. Fragmentation adds (N-1) additional headers. The overhead grows linearly with fragment count.

Header Overhead by Fragment Count (20-byte headers)
Fragments	Total Headers	Original	Overhead	Overhead %*
1	20 bytes	20 bytes	0 bytes	0%
2	40 bytes	20 bytes	20 bytes	100%
3	60 bytes	20 bytes	40 bytes	200%
5	100 bytes	20 bytes	80 bytes	400%
7	140 bytes	20 bytes	120 bytes	600%
10	200 bytes	20 bytes	180 bytes	900%
45	900 bytes	20 bytes	880 bytes	4400%

*Overhead % = (Additional Headers / Original Header) × 100

Why This Matters:

For large data transfers, this header multiplication occurs for every datagram. A file transfer sending 1,000 large datagrams, each fragmenting into 7 pieces, adds:

1,000 datagrams × 6 extra headers × 20 bytes = 120,000 bytes = 117 KB of pure overhead

That's 117 KB of bandwidth consumed without delivering any application data.

Layer 2 Overhead Compounds

Calculating Total Transmission Size

The total bytes transmitted for a fragmented datagram includes both data and all headers. This "transmission size" determines actual bandwidth consumption.

Transmission Size Formula:

Total Transmission = Original_Data + (N × Header_Size)
                   = Original_Data + (N × 20)  [for standard headers]

Alternative Form:

Total Transmission = Sum of all fragment Total_Length values

Each fragment's Total Length = Fragment_Data + Fragment_Header

Comparison Formulas:

Original Size = Original_Data + Original_Header
Fragment Size = Original_Data + (N × Header_Size)
Size Increase = (N - 1) × Header_Size

transmission_size_calculation.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
import math
 
def calculate_transmission_metrics(original_data, mtu, header_size=20):
    """
    Calculate complete transmission metrics for fragmentation.
    
    Returns:
        dict with all relevant metrics
    """
    # Maximum data per fragment
    max_frag_data = ((mtu - header_size) // 8) * 8
    
    # Number of fragments
    num_fragments = math.ceil(original_data / max_frag_data)
    
    # Size calculations
    original_total = original_data + header_size
    fragmented_total = original_data + (num_fragments * header_size)
    overhead = fragmented_total - original_total
    
    return {
        'original_data': original_data,
        'original_total': original_total,
        'fragments': num_fragments,
        'fragmented_total': fragmented_total,
        'header_overhead': overhead,
        'overhead_percent': (overhead / original_total) * 100,
        'efficiency': (original_data / fragmented_total) * 100
    }
 
# Analyze various scenarios
print("Transmission Size Analysis (MTU 1500, Header 20)")
print("="*70)
 
test_cases = [
    (1000, "Small packet (no fragmentation)"),
    (1480, "Exactly 1 fragment capacity"),
    (2960, "Exactly 2 fragment capacity"),
    (5000, "Typical large transfer"),
    (10000, "10KB data"),
    (65515, "Maximum IPv4 data"),
]
 
for data_size, description in test_cases:
    m = calculate_transmission_metrics(data_size, 1500)
    print(f"\n{description}:")
    print(f"  Original: {m['original_total']:6d} bytes ({m['original_data']} data + 20 header)")
    print(f"  With fragmentation: {m['fragmented_total']:6d} bytes "
          f"({m['fragments']} fragments)")
    print(f"  Header overhead: {m['header_overhead']:4d} bytes "
          f"({m['overhead_percent']:.1f}% of original)")
    print(f"  Transmission efficiency: {m['efficiency']:.1f}%")

Efficiency Interpretation

MTU Impact on Overhead Ratios

Smaller MTUs create more fragments, increasing overhead proportionally. Understanding this relationship helps in network design and MTU optimization.

The MTU-Overhead Relationship:

For a fixed data size, decreasing MTU:

Increases fragment count
Increases total header bytes
Decreases transmission efficiency
Increases processing overhead

Comparative Analysis:

10,000-Byte Data Transfer Across Different MTUs
MTU	Max Frag Data	Fragments	Total Headers	Overhead	Efficiency
9000 (Jumbo)	8976	2	40 bytes	20 bytes	99.6%
4500	4480	3	60 bytes	40 bytes	99.4%
1500 (Ethernet)	1480	7	140 bytes	120 bytes	98.6%
1000	976	11	220 bytes	200 bytes	97.8%
576 (Minimum)	552	19	380 bytes	360 bytes	96.3%
296	272	37	740 bytes	720 bytes	93.1%

mtu_overhead_analysis.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
import math
 
def analyze_mtu_impact(original_data, mtu_list, header_size=20):
    """Compare overhead across different MTUs."""
    results = []
    
    for mtu in mtu_list:
        max_data = ((mtu - header_size) // 8) * 8
        fragments = math.ceil(original_data / max_data)
        total_headers = fragments * header_size
        overhead = total_headers - header_size
        total_bytes = original_data + total_headers
        efficiency = (original_data / total_bytes) * 100
        
        results.append({
            'mtu': mtu,
            'max_data': max_data,
            'fragments': fragments,
            'total_headers': total_headers,
            'overhead': overhead,
            'efficiency': efficiency
        })
    
    return results
 
# Compare MTUs for a 50KB transfer
data_size = 50000
mtu_list = [9000, 4500, 1500, 1000, 576]
 
print(f"Overhead Analysis: {data_size:,} bytes data")
print("="*70)
 
results = analyze_mtu_impact(data_size, mtu_list)
 
print(f"{'MTU':>6} {'Frags':>6} {'Headers':>10} {'Overhead':>10} {'Efficiency':>12}")
print("-"*46)
 
for r in results:
    print(f"{r['mtu']:>6} {r['fragments']:>6} {r['total_headers']:>10} "
          f"{r['overhead']:>10} {r['efficiency']:>11.2f}%")
 
# Calculate bandwidth "tax" for 1GB transfer
print("\n" + "="*70)
print("Bandwidth 'Tax' for 1 GB transfer:")
print("-"*46)
 
for r in results:
    # For 1GB of actual data
    data_gb = 1024 * 1024 * 1024  # 1 GB in bytes
    overhead_per_frag = (r['fragments'] - 1) * 20  # Extra headers per original datagram
    datagrams = math.ceil(data_gb / 50000)  # Assuming 50KB datagrams
    total_overhead = datagrams * overhead_per_frag
    overhead_mb = total_overhead / (1024 * 1024)
    
    print(f"  MTU {r['mtu']}: {overhead_mb:.1f} MB extra header data")

Jumbo Frames Trade-off

Layer 2 Overhead Considerations

IP fragmentation overhead is compounded by Layer 2 framing. Each IP fragment becomes a separate Layer 2 frame, each with its own headers.

Complete Overhead Stack:

Per Fragment:
├── Ethernet Header: 14 bytes (destination MAC, source MAC, EtherType)
├── IP Header: 20-60 bytes
├── IP Data: variable
├── Ethernet FCS: 4 bytes (Frame Check Sequence)
└── Interframe Gap: 12 bytes (mandatory silence between frames)

Total Ethernet overhead per frame: 14 + 4 + 12 = 30 bytes
Plus optional: 802.1Q VLAN tag adds 4 bytes

Combined Overhead Formula:

Total Overhead = N × (L2_Header + IP_Header + L2_Trailer + IFG) - Original_Headers
              = N × (14 + 20 + 4 + 12) - (14 + 20 + 4 + 12)
              = (N - 1) × 50 bytes  [for standard Ethernet + IP]

Complete Protocol Stack Overhead per Fragment
Layer	Component	Size	Notes
L2	Ethernet Header	14 bytes	Dest MAC + Src MAC + EtherType
L2	VLAN Tag (optional)	4 bytes	802.1Q if tagged
L3	IP Header	20-60 bytes	20 typical, up to 60 with options
L2	Ethernet FCS	4 bytes	CRC-32 checksum
L1	Preamble + SFD	8 bytes	Not counted in MTU
L1	Interframe Gap	12 bytes	96 bits of silence

complete_overhead_analysis.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
import math
 
def complete_overhead_analysis(original_data, mtu, include_l1=True):
    """
    Calculate complete overhead including Layer 2/1.
    
    Args:
        original_data: Application data size
        mtu: Layer 3 MTU (IP datagram max size)
        include_l1: Whether to include preamble and IFG
    """
    # IP parameters
    ip_header = 20
    max_frag_data = ((mtu - ip_header) // 8) * 8
    fragments = math.ceil(original_data / max_frag_data)
    
    # Layer 2 parameters (Ethernet)
    eth_header = 14
    eth_fcs = 4
    
    # Layer 1 parameters
    preamble_sfd = 8 if include_l1 else 0
    ifg = 12 if include_l1 else 0
    
    # Per-frame overhead
    per_frame_overhead = eth_header + ip_header + eth_fcs + preamble_sfd + ifg
    
    # Calculate totals
    total_overhead = fragments * per_frame_overhead
    original_overhead = per_frame_overhead  # Single frame would have this
    added_overhead = total_overhead - original_overhead
    
    # Bytes on wire
    total_on_wire = original_data + total_overhead
    efficiency = (original_data / total_on_wire) * 100
    
    return {
        'fragments': fragments,
        'per_frame_overhead': per_frame_overhead,
        'total_overhead': total_overhead,
        'added_overhead': added_overhead,
        'total_on_wire': total_on_wire,
        'efficiency': efficiency
    }
 
# Analyze 10KB transfer with complete overhead
print("Complete Overhead Analysis: 10,000 bytes data, MTU 1500")
print("="*60)
 
result = complete_overhead_analysis(10000, 1500, include_l1=True)
 
print(f"Fragments: {result['fragments']}")
print(f"Per-frame overhead: {result['per_frame_overhead']} bytes")
print(f"  (14 Eth + 20 IP + 4 FCS + 8 Preamble + 12 IFG)")
print(f"Total overhead: {result['total_overhead']} bytes")
print(f"Added by fragmentation: {result['added_overhead']} bytes")
print(f"Total on wire: {result['total_on_wire']} bytes")
print(f"Wire efficiency: {result['efficiency']:.2f}%")
 
# Compare L3-only vs complete stack
print("\n" + "="*60)
print("Comparison: IP-only vs Complete Stack Overhead")
print("-"*60)
 
for data in [5000, 10000, 50000]:
    ip_only = complete_overhead_analysis(data, 1500, include_l1=False)
    complete = complete_overhead_analysis(data, 1500, include_l1=True)
    
    print(f"\n{data:,} bytes data:")
    print(f"  IP-only overhead:  {(ip_only['fragments']-1)*20:4d} bytes "
          f"(efficiency: {(data/(data+ip_only['fragments']*20))*100:.2f}%)")
    print(f"  Complete overhead: {complete['added_overhead']:4d} bytes "
          f"(efficiency: {complete['efficiency']:.2f}%)")

What Counts as 'On the Wire'

Processing Overhead

Processing Requirements per Fragment:

Per-Fragment Processing Costs

•Header Checksum Calculation — Each fragment's IP header has its own checksum, requiring computation at creation and verification at each hop
•Routing Table Lookup — Each fragment is independently routed, requiring separate forwarding table lookups
•Buffer Allocation — Routers allocate packet buffers for each fragment passing through
•Access Control List Processing — Firewalls must process each fragment against security rules
•Quality of Service Classification — Each fragment undergoes independent QoS marking and queuing
•NAT Translation — If applicable, each fragment requires NAT table lookup and possible modification

Destination Reassembly Costs:

The destination bears additional burdens:

Operation	Description	Resource Cost
Fragment Table Maintenance	Track pending fragments by ID	Memory
Fragment Ordering	Sort fragments by offset	CPU + Memory
Gap Detection	Identify missing fragments	CPU
Timeout Management	Handle incomplete reassembly	CPU + Timer
Buffer Allocation	Hold fragments until complete	Memory
Reassembly	Combine fragments into datagram	Memory + Copying

Memory Pressure Example:

A destination receiving incomplete fragment sets must hold them pending:

Default Linux timeout: 30 seconds
During attack: Thousands of partial datagrams
Memory consumed: (Fragment data + metadata) × pending datagrams

This enables fragmentation-based DoS attacks that exhaust reassembly buffers.

Security Device Performance Impact

Overhead Minimization Strategies

Given fragmentation's costs, minimizing or eliminating it is a network design priority. Several strategies effectively reduce fragmentation overhead.

Network-Level Strategies

•Path MTU Discovery — Discover minimum MTU and size datagrams appropriately at source
•Consistent MTU Design — Configure uniform MTU across all links to avoid fragmentation points
•Jumbo Frame Adoption — Use larger MTUs (9000 bytes) where end-to-end support exists
•Tunnel MTU Adjustment — Account for encapsulation overhead in tunnel endpoints

Application-Level Strategies

•TCP MSS Negotiation — TCP automatically sizes segments to avoid fragmentation
•UDP Application Sizing — Applications should limit UDP payloads to path MTU
•DF Flag Usage — Set Don't Fragment to trigger ICMP feedback for PMTUD
•Protocol-Specific Limits — DNS uses 512-byte default to ensure no fragmentation

calculate_optimal_payload.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
def calculate_optimal_payload(path_mtu, protocol='tcp', tunnel_overhead=0):
    """
    Calculate the maximum payload to avoid fragmentation.
    
    Args:
        path_mtu: Minimum MTU along the path
        protocol: 'tcp', 'udp', or 'icmp'
        tunnel_overhead: Additional bytes for tunnel encapsulation
    
    Returns:
        dict with optimal sizes
    """
    # Adjust for tunnel overhead
    effective_mtu = path_mtu - tunnel_overhead
    
    # Protocol headers
    ip_header = 20
    tcp_header = 20  # Minimum, can be up to 60
    udp_header = 8
    icmp_header = 8
    
    protocol_headers = {
        'tcp': tcp_header,
        'udp': udp_header,
        'icmp': icmp_header
    }
    
    proto_header = protocol_headers.get(protocol, 0)
    
    # Maximum payload without fragmentation
    max_payload = effective_mtu - ip_header - proto_header
    
    # For connection-oriented protocols, this is MSS
    mss = effective_mtu - ip_header - tcp_header if protocol == 'tcp' else None
    
    return {
        'path_mtu': path_mtu,
        'tunnel_overhead': tunnel_overhead,
        'effective_mtu': effective_mtu,
        'protocol': protocol,
        'max_payload': max_payload,
        'tcp_mss': mss
    }
 
# Common scenarios
print("Optimal Payload Calculations to Avoid Fragmentation")
print("="*60)
 
scenarios = [
    (1500, 'tcp', 0, "Standard Ethernet"),
    (1500, 'udp', 0, "Standard Ethernet UDP"),
    (1500, 'tcp', 20, "GRE Tunnel"),
    (1500, 'tcp', 50, "IPsec ESP Tunnel"),
    (1492, 'tcp', 0, "PPPoE"),
    (576, 'udp', 0, "Minimum Internet MTU"),
]
 
for mtu, proto, tunnel, desc in scenarios:
    result = calculate_optimal_payload(mtu, proto, tunnel)
    print(f"\n{desc} ({proto.upper()}):")
    if tunnel > 0:
        print(f"  Path MTU: {result['path_mtu']}, Tunnel overhead: {tunnel} bytes")
        print(f"  Effective MTU: {result['effective_mtu']}")
    else:
        print(f"  MTU: {result['path_mtu']}")
    print(f"  Max payload without fragmentation: {result['max_payload']} bytes")
    if result['tcp_mss']:
        print(f"  TCP MSS: {result['tcp_mss']} bytes")

The 1400-Byte Safe Zone

Real-World Overhead Examples

Let's analyze fragmentation overhead in realistic enterprise and Internet scenarios.

Example 1: Video Streaming Over VPN

A remote worker streams video from a corporate server. The VPN adds IPsec overhead, reducing effective MTU. Video UDP packets are 1472 bytes, causing fragmentation.

vpn_video_overhead.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
import math
 
# Video streaming over IPsec VPN
print("Example 1: Video Streaming Over VPN")
print("="*60)
 
# Parameters
video_packet_size = 1472  # UDP payload (common for video)
udp_header = 8
inner_ip = 20
ipsec_overhead = 58  # ESP header + trailer + auth
outer_ip = 20
physical_mtu = 1500
 
# Inner packet size (what IPsec must encapsulate)
inner_total = video_packet_size + udp_header + inner_ip  # 1500 bytes
 
# After IPsec
encapsulated = inner_total + ipsec_overhead  # 1558 bytes
 
# This exceeds MTU, so outer IP must fragment
outer_data = encapsulated  # IP payload to fragment
max_frag_data = ((physical_mtu - outer_ip) // 8) * 8  # 1480 bytes
fragments = math.ceil(outer_data / max_frag_data)  # 2 fragments
 
print(f"Video packet: {video_packet_size} bytes")
print(f"Inner IP datagram: {inner_total} bytes")
print(f"After IPsec: {encapsulated} bytes")
print(f"Physical MTU: {physical_mtu} bytes")
print(f"Fragmentation: {fragments} fragments per video packet")
 
# Streaming 1 hour at 5 Mbps
bitrate = 5 * 1000 * 1000  # 5 Mbps
duration = 3600  # 1 hour
total_bytes = (bitrate * duration) / 8
packets = total_bytes / video_packet_size
extra_headers = packets * (fragments - 1) * outer_ip
 
print(f"\n1-hour stream at 5 Mbps:")
print(f"  Total data: {total_bytes/1e9:.2f} GB")
print(f"  Video packets: {packets:,.0f}")
print(f"  Extra headers from fragmentation: {extra_headers/1e6:.2f} MB")
print(f"  Overhead percentage: {(extra_headers/total_bytes)*100:.2f}%")

Example 2: Database Backup Over WAN

A database backup transfers large (64KB) blocks over a WAN with MTU 1500. Each block becomes a datagram that must be fragmented.

database_backup_overhead.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
import math
 
# Database backup analysis
print("\nExample 2: Database Backup Over WAN")
print("="*60)
 
# Parameters
block_size = 65536  # 64 KB blocks
mtu = 1500
ip_header = 20
max_data = ((mtu - ip_header) // 8) * 8  # 1480 bytes
 
# Fragmentation per block
frags_per_block = math.ceil(block_size / max_data)  # 45 fragments
headers_per_block = frags_per_block * ip_header
overhead_per_block = headers_per_block - ip_header  # Extra headers
 
print(f"Block size: {block_size:,} bytes")
print(f"Fragments per block: {frags_per_block}")
print(f"Header overhead per block: {overhead_per_block} bytes")
print(f"Overhead per block: {(overhead_per_block/block_size)*100:.2f}%")
 
# 1 TB backup
backup_size = 1024 ** 4  # 1 TB
blocks = backup_size / block_size
total_overhead = blocks * overhead_per_block
 
print(f"\n1 TB backup:")
print(f"  Blocks: {blocks:,.0f}")
print(f"  Total header overhead: {total_overhead/1e9:.2f} GB")
print(f"  Extra time at 1 Gbps: {(total_overhead*8)/(1e9):.1f} seconds")
 
# Compare to optimal (no fragmentation at source)
print(f"\nOptimization:")
print(f"  If application used PMTUD to avoid fragmentation:")
print(f"  Original headers only: {blocks * ip_header / 1e6:.1f} MB")
print(f"  Savings: {total_overhead/1e9:.2f} GB")

Modern Applications Avoid This

Summary: Header Overhead Analysis

We've thoroughly analyzed the overhead costs of IP fragmentation. Let's consolidate the key formulas and insights.

Key Overhead Formulas

•Header Overhead = (N - 1) × Header_Size — Extra headers beyond the original
•Total Transmission = Data + (N × Header_Size) — Complete bytes sent
•Efficiency = Data / Total_Transmission × 100 — Payload as percentage of transmission
•Complete Overhead = (N - 1) × (L2_Header + IP_Header + L2_Trailer + IFG) — Full stack overhead
•Overhead compounds with fragment count — Smaller MTU = more fragments = more overhead
•Processing overhead scales linearly with fragments — Each fragment requires independent handling

Quick Reference: Overhead Impact
Metric	Formula/Value	Notes
Extra headers	(N-1) × 20 bytes	For standard IP
Max efficiency loss	~7% at MTU 576	For max-size datagrams
L2 overhead per frag	14 + 4 + 12 = 30 bytes	Ethernet (excl. preamble)
Safe payload limit	1400 bytes	Works across most paths

What's Next:

Overhead Analysis Complete

4 / 5