These measurement studies and the bufferbloat project2 document the harmful effects of large, unmanaged buffers at the network edge.

Correct buffer sizing is not an easy problem. Undersizing—making buffers smaller than the traditional BDP (bandwidth-delay product)—is fraught with problems, 8 nicely illustrated by Guillaume Vu-Brugier et al. 20 Today’s links vary in bandwidth, and individual connections vary in round-trip times (the “delay” used in BDP). This makes it impossible to properly pick a static size for most edge links. 13, 14 A simple, robust algorithm that can manage buffer delay regardless of buffer size and link bandwidth without a negative impact on utilization can make oversized buffers irrelevant.

 

understanding Queues Developing effective active queue management has been hampered by misconceptions about the cause and meaning of queues. Network buffers exist to absorb the packet bursts that occur naturally in statistically multiplexed networks. Queues occur in the buffers as a result of short-term mis-matches in traffic arrival and departure rates that arise from upstream resource

Receiver Receiver

 

contention, transport conversation startup transients, and/or changes in the number of conversations sharing a link. Unfortunately, other network behavior can cause buffers to fill, with effects that are not nearly as benign. With the wrong conceptual model for queues, AQMs have limited operational range, require a lot of configuration tweaking, and frequently impair rather than improve performance.

Figure 1 shows a TCP connection
shortly after startup (see “Congestion
Avoidance and Control” 8 for more
discussion). The sender launches its
window of 25 packets back-to-back,
and they flow through the network
until they hit a bottleneck (bandwidth
reduction). There, as each packet is
squeezed down in bandwidth, it must
stretch out in time since its size stays
constant. The vertical direction is
bandwidth (bits/sec), and the horizon-
tal direction is time (sec), so the area
of each rectangle is the packet size
(bits/sec × sec = bits). For example,
if the packets were 1ms long and the
bandwidth reduction was 100Mbps
to 10Mbps, then the second packet
would arrive 1ms after the first but
would have to wait for an additional
9ms, since it takes 10ms for the first
packet to depart. The third packet
would have to wait for an additional
18ms for both one and two to depart,
and so on. This bottleneck-induced
waiting is what creates the queues that
form in the packet buffers at the link.