Hierarchical Addressing

The Internet connects billions of devices, yet packets find their destinations in milliseconds. This feat isn't accomplished through brute-force memorization of every device—it's achieved through hierarchical addressing, an elegant design principle that transforms an impossible problem into a tractable one.

Hierarchical addressing is the reason the Internet's global routing table contains roughly 900,000 entries rather than 20 billion. It's why a router in Tokyo doesn't need to know about every laptop in New York—only how to reach the networks those laptops inhabit.

This page explores hierarchical addressing in depth: the fundamental division between network and host portions, how subnet masks define this boundary, the revolutionary impact of CIDR, and the architectural principles that make modern internetworking possible.

Every IP address encodes two distinct pieces of information:

1. Network Identifier: Which network does this device belong to?
2. Host Identifier: Which specific device within that network?

This two-level structure is the cornerstone of hierarchical addressing. It mirrors the structure of physical addresses: a street name (network) and house number (host) within that street.

Conceptual Division:

Consider the IPv4 address 192.168.1.100 with subnet mask 255.255.255.0:

IP Address:      192.168.1.100
                  ├────────┤ └──┤
                  Network    Host
                  Portion    Portion

The network portion (192.168.1) identifies the network. Every device on this network shares this prefix. The host portion (.100) uniquely identifies this specific device among all devices on that network.

Why This Division Matters:

The network-host division enables two critical capabilities:

1. Efficient Routing Routers only need to know how to reach networks, not individual hosts. A router with an entry for 192.168.1.0/24 can forward packets to any of the 254 possible hosts on that network without 254 separate routing entries.

2. Local Autonomy Network administrators have complete control over host address assignments within their allocated network prefix. They can add, remove, or reassign hosts without coordinating with the global Internet infrastructure.

This autonomy is profound: the organization owning 192.168.1.0/24 can assign addresses .1 through .254 however they wish. The Internet at large neither knows nor cares about these internal assignments—it only routes to the network prefix.

The subnet mask is the key that reveals where the network portion ends and the host portion begins. Understanding subnet masks is essential for IP address manipulation, subnetting, and routing.

What is a Subnet Mask?

A subnet mask is a 32-bit value where:

• 1 bits mark positions belonging to the network portion
• 0 bits mark positions belonging to the host portion

By convention, all 1s appear on the left (network) and all 0s on the right (host), creating a contiguous block structure.

Common Subnet Masks:

The Masking Operation:

To determine which network an IP address belongs to, perform a bitwise AND between the address and the subnet mask:

IP Address:     192.168.1.100  = 11000000.10101000.00000001.01100100
Subnet Mask:    255.255.255.0  = 11111111.11111111.11111111.00000000
                               ─────────────────────────────────────
AND Result:     192.168.1.0    = 11000000.10101000.00000001.00000000
                (Network Address)

The result (192.168.1.0) is the network address—the identifier for the entire network. Every device on this network, regardless of its specific host portion, produces the same network address when masked.

Classless Inter-Domain Routing (CIDR) revolutionized IP addressing by freeing it from the rigid constraints of classful addressing. CIDR allows subnet boundaries at any bit position, not just at octet boundaries.

The /Prefix Notation:

CIDR notation appends a prefix length to an IP address, indicating how many bits constitute the network portion:

192.168.1.0/24
└────┬────┘ └┬┘
 IP address  Prefix length (24 network bits)

This compact notation conveys the same information as a full subnet mask but is more concise and immediately reveals the network size:

• /24 = 8 host bits = 2⁸ - 2 = 254 hosts
• /16 = 16 host bits = 2¹⁶ - 2 = 65,534 hosts
• /22 = 10 host bits = 2¹⁰ - 2 = 1,022 hosts

Historical Context: The Classful Era

Before CIDR (pre-1993), addresses were allocated in fixed classes:

• Class A: /8 blocks (16.7 million hosts each) for largest organizations
• Class B: /16 blocks (65,536 hosts each) for medium organizations
• Class C: /24 blocks (256 hosts each) for small organizations

This rigid system caused severe problems:

1. Wasteful Allocation: A company needing 500 addresses had to request a Class B (65,536 addresses). 99% went unused.
2. Routing Table Explosion: Allocating Class C blocks to everyone needing >256 addresses created millions of routes.
3. Address Exhaustion: Inefficient allocation accelerated IPv4 depletion.

CIDR solved these problems by allowing allocation at any prefix length. A company needing 500 addresses receives a /23 (512 addresses)—a nearly perfect fit.

Address aggregation (also called supernetting or route summarization) is the most powerful consequence of hierarchical addressing. It allows multiple contiguous network addresses to be represented by a single routing entry.

The Aggregation Principle:

Consider an ISP that owns these four /24 networks:

192.168.0.0/24   (192.168.0.0   - 192.168.0.255)
192.168.1.0/24   (192.168.1.0   - 192.168.1.255)
192.168.2.0/24   (192.168.2.0   - 192.168.2.255)
192.168.3.0/24   (192.168.3.0   - 192.168.3.255)

Instead of advertising four separate routes, the ISP can advertise a single aggregate:

192.168.0.0/22   (192.168.0.0   - 192.168.3.255)

The /22 route covers all addresses in the four /24 networks. This is possible because the networks are contiguous and share the same upper 22 bits.

Binary Analysis of Aggregation:

192.168.0.0 = 11000000.10101000.000000|00.00000000
192.168.1.0 = 11000000.10101000.000000|01.00000000
192.168.2.0 = 11000000.10101000.000000|10.00000000
192.168.3.0 = 11000000.10101000.000000|11.00000000
                                     │
                                     └─ Varies in bits 23-24

The first 22 bits are identical (11000000.10101000.000000). Only bits 23-24 vary. Therefore, we can summarize with a /22 prefix.

Aggregation Requirements:

For routes to be aggregated:

1. Contiguity: The address blocks must be numerically adjacent
2. Common Prefix: All blocks must share the same prefix up to the aggregation point
3. Power of Two Groups: You can only aggregate 2, 4, 8, 16, etc. blocks (due to binary nature)
4. Alignment: The starting address must be aligned to the aggregate boundary

Hierarchical addressing fundamentally transforms routing efficiency. Let's quantify the difference it makes.

Without Hierarchy (Flat Addressing):

• Every router needs entries for every device (≈20 billion)
• Routing table lookup becomes O(n) or expensive O(log n) with massive tables
• Memory requirements exceed practical limits (terabytes per router)
• Route update propagation becomes a broadcast storm
• Any device change affects global routing tables

With Hierarchy (Current Internet):

• Global routing tables contain ~900,000 entries
• Local routers only need default routes + local networks
• Aggregation reduces global routing by 99.995%
• Changes within a network are invisible to external routers
• Scalable to trillions of devices

Multi-Level Hierarchy in Practice:

The Internet's routing hierarchy has multiple levels:

Level 0: Individual hosts (/32)
    │
    └─ Aggregated into...

Level 1: Enterprise networks (/24, /23, /22, etc.)
    │
    └─ Aggregated into...

Level 2: ISP customer aggregates (/16, /17, etc.)
    │
    └─ Aggregated into...

Level 3: Regional allocations (/8, /10, etc.)
    │
    └─ Aggregated into...

Level 4: Continental allocations

At each level, aggregation occurs. A home user's device never appears in global routing tables—only the ISP's aggregate that contains it.

Let's examine hierarchical addressing through concrete examples that illustrate its practical application.

Example 1: University Network Design

A university receives the allocation 10.0.0.0/8 from their ISP (a very large block for illustration). They design a hierarchical structure:

Example 2: ISP Address Allocation

An ISP receives 198.51.0.0/16 from their Regional Internet Registry (RIR). They subdivide for customers:

IPv6 was designed from the start with hierarchical addressing as a first-class principle, learning from IPv4's challenges.

IPv6 Address Structure:

An IPv6 address is 128 bits, typically displayed as eight groups of four hexadecimal digits:

2001:0db8:85a3:0000:0000:8a2e:0370:7334
└─┬─┘└─┬─┘└─┬─┘└───────────┬──────────┘
Global  Site   Subnet      Interface ID
Prefix  ID     ID          (64 bits)

Standard IPv6 Hierarchy:

IPv6 Allocation Example:

RIR (ARIN) allocates to ISP:    2001:db8::/32 (96 bits for ISP to use)
ISP allocates to customer:       2001:db8:acme::/48 (80 bits for customer)
Customer creates subnets:        2001:db8:acme:0001::/64 through
                                 2001:db8:acme:ffff::/64
                                 (65,536 possible subnets!)

Advantages of IPv6 Hierarchy:

1. Fixed Interface ID: The 64-bit interface ID simplifies device configuration (SLAAC)
2. 16 Bits for Subnets: Every organization gets 65,536 subnets—no VLSM calculations needed
3. Generous Allocation: Standard /48s mean organizations never outgrow their allocation
4. Clean Aggregation: The fixed structure promotes natural aggregation at each level
5. No NAT Requirement: Ample addresses eliminate the need for address translation