Network Coded TCP (CTCP)

Network Coded TCP (CTCP)

MinJi Kim M. Kim, J. Cloud, A. ParandehGheibi, L. Urbina, K. Fouli, and M. Médard are with the Massachusetts Institute of Technology, MA USA (e-mail: {minjikim, jcloud, parandeh, lurbina, fouli, medard}    Jason Cloud    Ali ParandehGheibi    Leonardo Urbina   
Kerim Fouli
   Douglas Leith D. Leith is with the Hamilton Institute, NUI Maynooth, Ireland (e-mail:    Muriel Médard

We introduce CTCP, a reliable transport protocol using network coding. CTCP is designed to incorporate TCP features such as congestion control, reliability, and fairness while significantly improving on TCP’s performance in lossy, interference-limited and/or dynamic networks. A key advantage of adopting a transport layer over a link layer approach is that it provides backward compatibility with wireless equipment installed throughout existing networks. We present a portable userspace implementation of CTCP and extensively evaluate its performance in both testbed and production wireless networks.

1 Introduction

Interference, especially for wireless channels located in unlicensed and white-space bands, is a major contributor to packet erasures and can be the primary factor affecting overall network performance. Common sources of interference include not only hidden terminals, but also other wireless links using heterogeneous technologies or non-network wireless devices such as radar, microwave ovens, etc. As an example, Figure 1 shows microwave oven interference that leads to packet erasures in 802.11 networks operating within the same or adjacent channels. With this type of interference, many existing transport layer protocols, such as TCP, are known to perform poorly and a variety of cross-layer techniques have been developed to increase performance [1]. Furthermore, a large majority of research has primarily focussed on a range of link layer approaches for mitigating the affects of such interference. In this paper we adopt a different strategy and propose a novel transport layer solution referred to as Network Coded TCP (CTCP).

Figure 1: Spectrum analyzer measurements showing microwave oven pulsed interference and 802.11 packet transmissions. The y-axis grid is in 10ms increments. The resolution bandwidth is set to 20 MHz, and thus captures about 99% of the WLAN signal.

The adoption of a transport layer approach ensures backward compatibility with legacy equipment. A recent industry study [2] estimates that almost 1.2 billion 802.11 devices have been shipped to date. Replacing these devices, in addition to other existing wireless infrastructures, in order to incorporate new link layer technology is largely impractical due to the costs involved. Furthermore, the need to provide a portable, easily implemented solution is also required to overcome challenges due to the proliferation of operating systems in use throughout the internet. This strongly motivates techniques that have the capability to be retro-fitted into a wide variety of existing systems with the aim of bringing immediate benefits to current and future users. We provide a userspace implementation so that adoption of the techniques presented in this paper can be achieved regardless of the user’s operating system or network infrastructure.

We further demonstrate how the TCP transport layer can be combined with network coding, without the need to consider cross-layer techniques such as explicit feedback from the link layer or other techniques such as explicit congestion notification (ECN), to yield significant performance gains in the presence of interference. For example, our measurements in public WiFi hotspots around Boston (see later) demonstrate that CTCP can achieve reductions in connection completion times of 100-300% compared with uncoded TCP. In controlled lab experiments, we consistently observed reductions of more than an order of magnitude (i.e. >1000%) in completion times for both HTTP and streaming video flows when the link packet loss rate exceeds 5%. By using a transport layer solution, we can provide error-correction coding across packets rather than simply within each individual packet so that CTCP yields significant performance gains in many complex, time-varying environments.

Our contributions include the following. First, we develop an error-correction coding approach tailored to packet streams with delayed feedback from the receiver. Classical error-correction coding for packet erasure channels is largely either open-loop in nature (i.e. forward error correction) or assumes near instantaneous feedback from the receiver (akin to automatic repeat request (ARQ)). We develop a variable-length block coding scheme that makes efficient use of delayed feedback to achieve high throughput and low decoding delay. We demonstrate that this scheme can be practically implemented in software on commodity hardware. Second, standard TCP congestion control uses packet loss as an indicator of congestion. The masking of path losses by error correction coding necessitates the development of a novel TCP congestion control approach. In keeping with the overall approach taken here, we seek to make the smallest possible changes consistent with achieving high performance. We propose a simple change to the TCP additive-increase, multiplicative-decrease (AIMD) algorithm. This algorithm introduces an adaption of the backoff factor, which reverts to the standard AIMD operation in networks where packets losses primarily occur due to queue overflow (e.g. most wired networks) ensuring backward compatibility with other congestion control algorithms. Third, we carry out an extensive experimental evaluation of the CTCP system both in controlled lab conditions (enabling reproducible, detailed performance analysis) and in production wireless networks (providing network conditions and performance data in the “wild”).

2 Related Work

Perhaps the closest previous work is that of Sundararajan et al.[3], which introduced TCP/NC and proposes a sliding window coding scheme that is fundamentally different from the variable-length block coding scheme proposed here. Their work focuses on a theoretical analysis over idealized links, and does not propose a method to guarantee intermediate packet decoding at the receiver. The use of coding has also been proposed before our work or that of [3] in order to mitigate the effect of losses on TCP, particularly in the context of wireless links. We may roughly taxonomize these into approaches that consider the operation of TCP jointly with lower layer redundancy, at the physical or MAC level, often in a cross-layer approach [1, 4, 5, 6, 7, 8, 9, 10, 11, 12] and those that consider redundancy at the IP layer or above without access to the lower layers [13, 14, 15, 16, 17, 18, 19]. Since our goal is to provide a system that operates without access to, or even detailed knowledge of, the physical layer, it is in the latter category that our approach belongs.

The approaches in papers implementing coding at the IP layer for operation with TCP have generally revolved around traditional fixed-length block codes, such as Reed-Solomon codes. Furthermore, many of these approaches are combined with mechanisms such as ECN [14, 10] to aid in generating the necessary redundancy. These block-based approaches acknowledge packets upon successful decoding and, if the number of errors exceeds the predetermined level of redundancy, a decoding failure occurs, requiring retransmission of the full block. Our approach uses network coding to mitigate this problem. If the number of errors exceeds the provided level of redundancy, additional redundancy can be provided by sending additional degrees of freedom (dof), or coded packets, rather than retransmitting the entire block.

3 Overview of Coded TCP (CTCP)

Before discussing the CTCP sender and receiver in detail, we provide a more holistic view of the two here. The CTCP sender initially segments the stream, or the file, into a series of blocks containing number of packets, where each packet is assumed to be of fixed length. If the remainder of a file or a stream is not large enough to form a complete packet, the packet is padded with zeros to ensure that all packets are of the same length. A block need not be completely full, i.e. a block may have fewer than packets; however, block should be full before block is initialized. After transmitting the initial block of packets, the size of the block is then adapted in light of feedback from the receiver.

The CTCP sender buffers of blocks and the value of should be conveyed to the receiver. The value of may be negotiated at initialization between the sender and the receiver, as directly affects the memory usage on both ends. We denote the smallest block in memory to be . Note that this does not mean that CTCP sender may send amount of data at any time.

The sender is allowed to transmit packets only if the congestion control mechanism allows it to; however, whenever it is allowed to transmit, the sender may choose to transmit a packet from any one of the blocks in memory, i.e. blocks , , …, . In Section 4.5, we shall discuss the sender’s algorithm for selecting a block from which it sends a packet. The payload of the transmitted packet may be coded or uncoded; the details of the coding operations can be found in Section 4.4.

The sender includes the following in each packet: (i) the block number, (ii) a seed for a pseudo-random number generator which allows the receiver to generate the coding coefficients, (iii) the sequence number , and (iv) the (coded or uncoded) payload. The sequence number for CTCP differs from that of TCP – for TCP, a sequence number indicates a specific data byte; for CTCP, a sequence number indicates that a packet is the -th packet transmitted by the sender, thus, is not tied to a byte in the file.

The CTCP receiver sends acknowledgments (ACKs) for the packets it receives. In the ACK, the receiver indicates: (i) the smallest undecoded block , (ii) the number of degrees of freedom (dofs) it has received for the current block , and (iii) the of the packet it is acknowledging.

Using the information in an ACK, the CTCP sender adjusts its behavior. We first describe the sender algorithm in Section 4, as most of the intelligence of the protocol is on the sender’s side. Then, we present the CTCP receiver algorithm in Section 5. The CTCP receiver’s main role is to decode and deliver data to the application.

4 CTCP Sender

We present the sender side algorithm for CTCP. The sender maintains several internal parameters (defined in Table 1), which it uses to generate coded packets and schedule blocks to be transmitted.

Notation Definition
Short term average packet loss rate
Retransmission timeout period (equal to where is a constant)
Current (or the last acknowledged packet’s) round-trip time
The minimum round-trip time
The sequence number of the next packet to be transmitted
The sequence number of the latest unacknowledged packet
Slow-start threshold, i.e. if , the sender leaves the slow-start mode
Timestamp of when the sender received the latest ACK (initialized to the time when the sender receives a SYN packet from the receiver)
Number of tokens, which is conceptually similar to congestion window for traditional TCP
Size of the blocks (in number of packets)
Current block number at the sender, which is the smallest unacknowledged block number
Number of dofs the receiver has acknowledged for the current block
Number of active blocks, i.e. the sender may schedule and transmit packets from blocks , , …,
Block number from which packet with was generated from
Timestamp of when packet with was sent
Table 1: Definitions of the sender parameters

4.1 Network Parameter Estimation

The CTCP sender estimates the network parameters, such as and estimated path loss rate , using the received ACKs as shown in Algorithm 1. The sender adjusts its actions, including coding operations and congestion control depending on these estimates. If the sender does not receive an ACK from the receiver for an extended period of time (i.e. a time-out occurs), the network parameters are reset to predefined default values. The predefined default values may need to be chosen with some care such that they estimate roughly what the network may look like.

Receive an ACK;
current time;
minimum of ;
if  then
        Free blocks , …, ;
end if
if  then
end if
Algorithm 1 CTCP sender algorithm for updating the network parameters.

The CTCP sender maintains moving averages of . We use a slightly modified version of the exponential smoothing technique, where we consider the data series we are averaging to be a 0-1 sequence, where 0 indicates that the packet has been received successfully and 1 otherwise (i.e. a packet loss). Now, assume that there were number of packets lost. If , then the update equation for in Algorithm 1 becomes


where is the smoothing factor. If , the same update equation becomes


which is identical to executing an exponential smoothing over two data points (one lost and one acknowledged). We can repeat this idea for to obtain the update rule for in Algorithm 1. Therefore, the fact that a single ACK may represent multiple losses () leads to a slightly more complicated update rule for than that for as shown in Algorithm 1. To the best of our knowledge, such an update rule has not been used previously.

4.2 Reliability

CTCP achieves reliability by using receiver feedback to dynamically adapt the size of each block such that it can be successfully decoded. In Algorithm 1, the CTCP sender increments only if it has received an ACK indicating that the receiver is able to decode (i.e. ). This mechanism is similar to traditional TCP’s window sliding scheme in which the TCP sender only slides its window when it receives an ACK indicating the some bytes have been received. In the case of CTCP, the reliability is implemented over blocks instead of bytes.

4.3 Congestion Control Mechanism

Traditional TCP’s AIMD congestion control increases the TCP sender’s congestion window size by packets per RTT and multiplicatively decreases by a backoff factor on detecting packet losses within one RTT inducing a single backoff. The usual values are when appropriate byte counting is used, and . On lossy links, repeated backoffs in response to noise losses rather than queue overflow can prevent from increasing to fill the available link capacity. The behavior is well known and is captured, for example, in [20] in which scales as , where is the packet loss rate.

The basic issue here is that on lossy links, loss is not a reliable indicator of network congestion. One option might be to use delay, rather than loss, as the indicator of congestion, but this raises many new issues and purely delay-based congestion control approaches have not been widely adopted in the internet despite being the subject of extensive study. Another option might be to use explicit signalling, for example via ECN, but this requires both network-wide changes and disabling of backoff on packet loss. These considerations motivate consideration of hybrid approaches, making use of both loss and delay information. The use of hybrid approaches is well-established, for example Compound TCP [21] is widely deployed.

We consider modifying the AIMD multiplicative backoff. Before discussing the details of backoff behavior, we emphasize that CTCP uses tokens to control the CTCP sender’s transmission rate instead of the congestion window . Therefore, play a similar role for CTCP as does for TCP. A token allows the CTCP sender to transmit a packet (coded or uncoded). When the sender transmits a packet, the token is used. The number of tokens, , is controlled according to the modified AIMD multiplicative backoff (Algorithm 2).

As shown in Algorithm 2, we modify the AIMD multiplicative backoff to have


where is the path round-trip propagation delay (which is typically estimated as the lowest per packet RTT observed during the lifetime of a connection) and is the current round-trip time.

if current time  then
        initial token number;
        Set to slow-start mode;
end if
if Receive an ACK on path  then
        if slow-start mode then
               if  then
                      Set to congestion avoidance mode;
               end if
               if  then
               end if
        end if
end if
Algorithm 2 CTCP sender congestion control.

This is similar to the approach considered in [22], which uses with the aim of making TCP throughput performance less sensitive to the level of queue provisioning. Indeed on links with only queue overflow losses, (3) reduces to the approach in [22] since (the link queue is full) when loss occurs. In this case, when a link is provisioned with a bandwidth-delay product of buffering, as per standard guidelines, then and , i.e. the behavior is identical to that of standard TCP. More generally, when queue overflow occurs the sum of the flows’ throughputs must equal the link capacity , where is the number of flows. After backoff according to (3), the sum-throughput becomes when the queue empties. That is, the choice (3) for decreases the flow’s so that the link queue just empties and full throughput is maintained.

On lossy links (with losses in addition to queue overflow losses), use of in (3) adapts to each loss event. When a network path is under-utilized, (therefore, and ). Thus, is not decreased on packet loss. Hence, is able to grow, despite the presence of packet loss. Once the link starts to experience queueing delay, and , i.e. is decreased on loss. Since the link queue is filling, the sum-throughput before loss is . After decreasing , the sum-throughput is at least (when all flows backoff their ) when the queue empties. That is, (3) adapts to maintain full throughput.

Although we focus on using (3) in combination with linear additive increase (where is constant), we note that this adaptive backoff approach can also be combined with other types of additive increase including, in particular, those used in Cubic TCP and Compound TCP. As shown here, these existing approaches can be extended to improve performance on lossy links.

4.3.1 Mathematical Modeling

In this section, we provide some analysis on our choice of , the multiplicative backoff factor. Consider a link shared by flows. Let denote the capacity of the link and the round-trip propagation delay of flow . We will assume that the queueing delay can be neglected, i.e. the queues are small or the link is sufficiently lossy that the queue does not greatly fill. We also assume that any differences in the times when flows detect packet loss (due to the differences in path propagation delay) can be neglected. Let denote the time of the -th network backoff event, where a network backoff event is defined to occur when one or more flows reduce their . Let denote the of flow immediately before the -th network backoff event and the corresponding throughput. With AIMD, we have


where , is the AIMD increase rate in packets per RTT, is the time in seconds between the and -th backoff events, and is the backoff factor of flow at event . The backoff factor is a random variable, which takes the value when flow does not experience a loss at network event , and takes the value given by (3) otherwise. The time is also a random variable, with distribution determined by the packet loss process and typically coupled to the flow rates , .

For example, associate a random variable with packet , where when packet is erased and otherwise. Assume the are i.i.d with erasure probability . Then where is the total number of packets transmitted over the link in interval following backoff event and is the number of packets transmitted by flow in this interval . Also, the probability that flow does not back off at the -th network backoff event is the probability that it does see any loss during the RTT interval , which can be approximated by on a link with sufficiently many flows.

Since both and are coupled to the flow rates , , analysis of the network dynamics is generally challenging. When the backoff factor is stochastically independent of the flow rate , the analysis is then relatively straightforward. Note that this assumption is valid in a number of useful and interesting circumstances. One such circumstance is when links are loss-free (with only queue overflow losses) [23]. Another is on links with many flows and i.i.d packet losses, where the contribution of a single flow to the queue occupancy (and so to in (3)) is small. Further, as we will see later, experimental measurements indicate that analysis using the assumption of independence accurately predicts performance over a range of other network conditions, and so results are relatively insensitive to this assumption.

Given independence, from (4),


When the network is also ergodic, a stationary distribution of flow rates exists. Let denote the mean stationary rate of flow . From (5) we have


Since the factor is common to all flows, the fraction of link capacity obtained by flow is determined by .

Fairness between flows with same RTT: From (6), when flows , have the same RTT, and so , and the same mean backoff factor then they obtain on average the same throughput share.

Fairness between flows with different RTTs: When flows , have different round trip times but the same mean backoff factor, the ratio of their throughputs is . Observe that this is identical to standard TCP behavior [23].

Fairness between flows with different loss rates: The stationary mean backoff factor depends on the probability that flow experiences a packet loss at a network backoff event. Hence, if two flows and experience different per packet loss rates and (e.g. they might have different access links while sharing a common throughput bottleneck), this will affect fairness through .

Friendliness: The model (4) is sufficiently general enough to include AIMD with fixed backoff factor, as used by standard TCP. We consider two cases. First, when the link is loss-free (the only losses are due to queue overflow) and all flows backoff when the queue fills, then . For a flow with fixed backoff of 0.5 and a flow with adaptive backoff , the ratio of the mean flow throughputs is by (6) when the flows have the same RTT. When , the throughputs are equal. Since where is the link buffer size and the link rate, when (i.e., the buffer is size at the bandwidth-delay product). The second case we consider here is when the link has i.i.d packet losses with probability . When is sufficiently large so that the queue rarely fills, queue overflow losses are rare and the throughput of a flow with fixed backoff of 0.5 is accurately modeled by the Padhye model [20]. That is, the throughput is largely decoupled from the behavior of other flows sharing the link (since coupling takes place via queue overflow) and, in particular, this means that flows using adaptive backoff do not penalize flows which use fixed backoff. We present experimental measurements confirming this behavior in Section 6.3.

4.4 Network Coding Operations

The coding operations are performed over blocks. Setting the initial bock size leads to operations similar to that of traditional TCP variants which cannot effectively take advantage of network coding. On the other hand, setting too large leads to increased encoding/decoding complexity and delay. Therefore, has to be chosen with care. In our experience, it is desirable to set to be similar to the bandwidthdelay of the network, so that feedback from the receiver about the first packet in the block arrives at the sender around the time that sending of packets is completed and the feedback can then be used to adapt the block size on the fly. The choice of coding field size also affects performance. While a higher field size leads to a higher probability of generating independent dofs (resulting in increased efficiency), this comes at the cost of coding and decoding complexity. We find that using a field of , i.e. each coefficient is a single byte, provides a good balance.

To avoid encoding delay and reduce encoding complecity, we use a systematic code – i.e. uncoded packets are first transmitted and then extra coded packets are sent. In generating coded packets, there are many options.

In our design, we use a simple approach – a coded packet is generated by randomly coding all packets in the block. This approach is most effective in terms erasure correction. With high probability, each coded packet will correct for any single erasure in the block.

4.5 Transmission Scheduling

Initialize an array to ;
for  in  do
        if current time  then
        end if
end for
for  in  do
        if  and  then
               Transmit a packet with sequence number from block ;
       else if  then
               Transmit a packet with sequence number from block ;
        end if
end for
Algorithm 3 CTCP sender algorithm for block scheduling when a token is available.

When a token is available, a packet is transmitted from a block decided on by the CTCP sender. The block scheduling algorithm is detailed in Algorithm 3. The algorithm first estimates the number of packets in a block that are in transit from the sender to the receiver. Given , the sender can then compute the expected number of packets the receiver will receive for any given block. In determining the expected number of dofs the receiver will receive for any given block, we exclude the packets that have been transmitted more than time ago since they are likely to be lost or significantly delayed. The constant factor of 1.5 may be adjusted depending on the delay constraints of the application of interest; however, the constant factor should be .

The goal of the sender is to ensure that the receiver will receive enough packets to decode the block, while also limiting the number of unnecessary coded packets transmitted. The sender prioritizes block before ; therefore, is of the highest priority. Note that the algorithm treats slightly differently from the rest of the blocks. In our design, the CTCP receiver informs the sender of how many dofs it has received () for block . Therefore, the sender is able to use the additional information to determine more precisely whether another packet should be sent from block or not. It is not difficult to piggy-back more information on the ACKs. For example, we could include how many dofs the receiver has received for blocks as well as , , …, . However, for simplicity, the CTCP receiver only informs the sender the number of dofs received for block .

5 CTCP Receiver

The receiver is responsible for decoding the received data and providing ACK feedback to the sender. Whenever the receiver receives a packet, it needs to check whether the current block is decodable () and to calculate how many dofs it has received for the current block ().

5.1 Decoding Operations

For each block , the receiver initializes a matrix for the coding coefficients and a corresponding payload structure . Whenever a packet from is received, the coding coefficients and the coded payload are inserted to and respectively. Gaussian elimination is then used to determine whether the received packet is linearly independent with the previously received packets. If it is, the receiver sets . If is equal to , then the receiver acknowledges that enough dofs have been received for and updates ( is also reset to reflect the dofs needed for the new ). If the received packet is not linearly independent from previously received packets, the receiver transmits an ACK (corresponding to the packet received) but does not update nor . Once enough linearly independent packets (dofs) have been received for a block, the receiver can decode all packets within the block.

6 Experimental Measurements

In this section, we evaluate CTCP’s performance in a testbed. We present results on not only throughput but also on friendliness and fairness.

Figure 2: Schematic of experimental testbed.

6.1 Testbed Setup

(a) Link 25Mbps, RTT 20ms
(b) CTCP
Figure 3: Measurements of goodput efficiency against packet loss rate, link rate and RTT. The Theory curve in Figure (b)b is generated using Equation (7).

The lab testbed consists of commodity servers (Dell Poweredge 850, 3GHz Xeon, Intel 82571EB Gigabit NIC) connected via a router and gigabit switches (Figure 2). Sender and receiver machines used in the tests both run a Linux kernel. The router is also a commodity server running FreeBSD 4.11 and ipfw-dummynet. It can be configured with various propagation delays , packet loss rates , queue sizes and link rates to emulate a range of network conditions. As indicated in Figure 2, packet losses in dummynet occur before the rate constraint, not after, and so do not reduce the bottleneck link capacity . Unless otherwise stated, appropriate byte counting is enabled for standard TCP and experiments are run for at least 300s. Data traffic is generated using rsync (version 3.0.4), HTTP traffic using apache2 (version 2.2.8) and wget (version 1.10.2), video traffic using vlc as both server and client (version 0.8.6e as server, version 2.0.4 as client).

CTCP is implemented in userspace as a forward proxy located on the client and a reverse proxy located on the server. This has the advantage of portability and of requiring neither root-level access nor kernel changes. Traffic between the proxies is sent using CTCP. With this setup, a client request is first directed to the local forward proxy. This transmits the request to the reverse proxy, which then sends the request to the appropriate port on the server. The server response follows the reverse process. The proxies support the SOCKS protocol and standard tools allow traffic to be transparently redirected via the proxies. In our tests, we used proxychains (version 3.1) for this purpose.

6.2 Efficiency

Figure 4: Goodput for a standard TCP and a CTCP flow sharing a loss-free link; results are shown for 10Mbps and 25Mbps links with varying RTTs.
(a) Lossy 10Mbps link with RTT=25ms
(b) Lossy 25Mbps link with RTT=25ms
Figure 5: Goodput against link loss rate for (i) a TCP and a CTCP flow sharing this link (solid lines), and (ii) two TCP flows sharing lossy link (dashed line).

Figure 3 presents experimental measurements of the efficiency (equal to ) of various TCP implementations and CTCP over a range of network conditions. Figure (a)a shows the measured efficiency versus the packet loss probability for a 25Mbps link with 25ms RTT and a bandwidth-delay product of buffering. Baseline data is shown for standard TCP (i.e. TCP SACK/Reno), Cubic TCP (current default on most Linux distributions), H-TCP, TCP Westwood, TCP Veno, together with the value packets per RTT predicted by the popular Padhye model [20]. It can be seen that the measurements for standard TCP are in good agreement with the Padhye model, as expected. Also that Cubic TCP, H-TCP, TCP Westwood, and TCP Veno closely follow the standard TCP behavior. Again, this is as expected since the link bandwidth-delay product of 52 packets lies in the regime where these TCP variants seek to ensure backward compatibility with standard TCP. Observe that the achieved goodput decreases rapidly with increasing loss rate, falling to 20% of the link capacity when the packet loss rate is 1%. This feature of standard TCP is, of course, well known. Compare this, however, with the efficiency measurements for CTCP, which are shown in Figure (a)a and also given in more detail in Figure (b)b. The goodput is % of link capacity for a loss rate of 1%, a roughly five-fold increase in goodput compared to standard TCP.

Figure (b)b presents the efficiency of CTCP for a range of link rates, RTTs and loss rates. It shows that the efficiency achieved is not sensitive to the link rate or RTT. Also shown in Figure (b)b is a theoretical upper bound on the efficiency calculated using


where is the block size, the packet erasure probability and is the number of forward-transmitted coded packets sent with each block. This value is the mean number of such forward-transmitted coded packets that are unnecessary (because there are fewer then erasures).

The efficiency achieved by CTCP is also insensitive to the buffer provisioning, as discussed in Section 4.3. This property is illustrated in Figure (a)a, which presents CTCP measurements when the link buffer is reduced in size to 25% of the bandwidth-delay product. The efficiency achieved with 25% buffering is close to that with a full bandwidth-delay product of buffering.

6.3 Friendliness with Standard TCP

(a) 25Mbps, RTT 25ms, 5% packet loss rate
(b) RTT 25ms
Figure 6: Measurements of and goodput for two CTCP flows sharing a lossy link. Figure (a)a provides a sample of time history while Figure (b)b summarizes the goodputs for a range of packet loss rates (%) with 10Mbps and 25Mbps links (RTT 25ms). Similar behavior was observed for other values of RTTs.

Figures 4 and 5 confirm that standard TCP and CTCP can coexist in a well-behaved manner. In these measurements, a standard TCP flow and a CTCP flow share the same link competing for bandwidth. As a baseline, Figure 4 presents the goodputs of TCP and CTCP for range of RTTs and link rates on a loss-free link (i.e. when queue overflow is the only source of packet loss). As expected, it can be seen that the standard TCP and CTCP flows consistently obtain similar goodput.

Figure 5 presents goodput data when the link is lossy. The solid lines indicate the goodputs achieved by the CTCP flow and the standard TCP flow sharing the same link with varying packet loss rates. At low loss rates, they obtain similar goodputs; but as the loss rate increases, the goodput of standard TCP rapidly decreases (as already observed in Figure (a)a).

For comparison, in Figure 5, we also show (using the dotted lines) the goodput achieved by a standard TCP flow when competing against another standard TCP flow (i.e. when two standard TCP flows share the link). Note that the goodput achieved by a standard TCP flow (dotted line) when competing against another standard TCP flow is close to that achieved when sharing the link with a CTCP flow (solid line). This demonstrates that CTCP does not penalize the standard TCP flow.

6.4 Fairness among CTCP Flows

We turn now to fairness, i.e. how goodput is allocated between competing CTCP flows. Figure (a)a plots a typical time history for two CTCP flows sharing a lossy link. The second flow (black) is started after the first (grey) so that we can observe the convergence to fairness. It can be seen that the two flows’ rapidly converge. Figure (b)b presents corresponding goodput measurements for a range of link rates, RTTs, and loss rates. Again, the two CTCP flows consistently achieve similar goodputs.

6.5 Application Performance

In this section, we present our testbed results seen by various applications.

6.5.1 Web

Figure 7 shows measurements of HTTP request completion time against file size for standard TCP and CTCP. The HTTP requests are generated using wget and the response is by an apache2 web server. Note the log scale on the y-axis.

Figure 7: Measured HTTP request mean completion time against file size over 25Mbps link with RTT = 10ms. Data is shown for standard TCP (red) and CTCP (black) for a range of loss rates. Error bars are comparable in size to the symbols used in the plot and so are omitted.

The completion times with CTCP are largely insensitive to the packet loss rate. For larger file sizes, the completion times approach the best possible performance indicated by the dashed line. For smaller file sizes, the completion time is dominated by slow-start behavior. Note that CTCP and TCP achieve similar performance when the link is loss-free; however, TCP’s completion time quickly increases with loss rate. For a 1MB connection, the completion time with standard TCP increases from 0.9s to 18.5s as the loss rate increases from 1% to 20%, while for a 10MB connection the corresponding increase is from 7.1s to 205s. Observe that the completion time is reduced by more than 20 (2000%) for a 1MB connection and by almost (3000%) for a 10MB connection.

6.5.2 Streaming Video

Figure 8 plots performance measurements for streaming video for a range of packet loss rates on a 25Mbps link with RTT equal to 10 ms. A vlc server and client are used to stream a 60s video. Figure (a)a plots the measured time for playout of the video to complete. Again, note the log scale on the y-axis.

(a) Completion Time
(b) Buffer Under-runs
Figure 8: Measurements of video streaming performance against loss rate with a 25Mbps link and a RTT of 10ms. Data is shown for standard TCP and CTCP. Figure (a)a shows the running time taken to play a video of nominal duration (60s); Figure (b)b shows the number of under-runs of the playout buffer at the client.

The playout time with CTCP is approximately 60s and is insensitive to the packet loss rate. In contrast, the playout time with standard TCP increases from 60s to 95s when the loss rate is increased from 0% to 1%, and increases further to 1886s (31 minutes) as the loss rate is increased to 20% (more than 30 slower than when using CTCP). Figure (b)b plots measurements of playout buffer under-run events at the video client. It can be seen that there are no buffer under-run events when using CTCP even when the loss rate is as high as 20%. With standard TCP, the number of buffer under-runs increases with loss rate until it reaches a plateau at around 100 events, corresponding to a buffer underrun occurring after every playout of a block of frames. In terms of user experience, the increases in running time result in the video repeatedly stalling for long periods of time and are indicative of a thoroughly unsatisfactory quality of experience even at a loss rate of 1%.

7 Real-world Performance

In this section we present measurements from a number of wireless links subject to real impairments.

7.1 Microwave Oven Interference

We begin by considering an 802.11b/g wireless client downloading from an access point over a link subject to interference from a domestic microwave oven (MWO). The wireless client and AP were equipped with Atheros 802.11 b/g 5212 chipsets (radio 4.6, MAC 5.9, PHY 4.3 using Linux MadWifi driver version 0.9.4) operating on channel 8. The microwave oven used was a 700 W Tesco MM08 17L. Unless otherwise stated, the default operating system settings are used for all network parameters. The wireless client used rsync to download a 50MB file via the AP. Figure 1 (shown in the introduction) presents spectrum analyzer (Rohde & Schwarz FSL-6) measurements illustrating both the MWO interference and packet transmissions on the wireless link. The MWO operates in the 2.4 GHz ISM band, with significant overlap () with the WiFi 20 MHz channels 6 to 13. The MWO interference is approximately periodic, with period 20ms (i.e. 50Hz) and mean pulse width 9ms (the width was observed to fluctuate due to frequency instability of the MWO cavity magnetron, a known effect in MWOs).

Figure 9: Measurements of mean throughput vs wireless PHY rate used with standard TCP (Cubic TCP) and CTCP on an 802.11 link affected by microwave oven interference.

Figure 9 presents measurements of the mean throughout achieved over the file download vs the PHY rate used on the downlink. Data is shown using standard TCP (in this case Cubic TCP, the Linux default variant) and CTCP. Data is not shown for a PHY rate of 1Mbps as the packet loss rate was close to 100% – this is because at this PHY rate, the time to transmit a 1500B frame is greater than the interval between MWO interference bursts and so almost all frames are damaged by the interference. It can be seen that the throughput achieved by standard TCP rises slightly as the PHY rate is increased from 1Mbps to 5.5Mbps, but then decreases to zero for PHY rates above 36Mbps (due to channel path losses). In comparison, when using CTCP the throughput achieved is approximately doubled (200%) at a PHY rate of 5.5Mbps, more than tripled (300%) at PHY rates of 8, 11 and 18 Mbps and increased by more than an order of magnitude (1000%) at a PHY rates above this. Furthermore, the fluctuations of both TCP and CTCP performance under different link layer coding rates and modulation schemes (indicated by the changes in the WiFi transmission rate) suggests that CTCP’s performance is much more robust to network changes than that of TCP’s performance, although more testing is required to verify this claim.

7.2 Hidden Terminal Interference

We now consider an 802.11 wireless link (configured similarly to that in Section 7.1) which is subject to hidden terminal interference. The hidden terminal is created by adding a third station to the network created in the last section. Carrier sense on the terminal’s wireless interface card is disabled and 1445B UDP packets are transmitted with exponentially distributed inter-arrival times. The 802.11 transmit rates for both the hidden terminal and AP were set to 11 Mbps. Unless otherwise stated, the default operating system settings are used for all of the remaining network parameters. Figure 10 plots the measured throughput on the downlink from the AP to a wireless client versus the mean transmit rate of the hidden terminal traffic. It can be seen that CTCP consistently obtains approximately twice (200%) the throughput of standard TCP (Cubic TCP) across a wide range of interference conditions.

Figure 10: Throughput vs intensity of hidden terminal interference when using standard TCP (Cubic TCP) and CTCP over an 802.11b/g wireless link.

7.3 Public WiFi Measurements

(a) CTCP Time = 313 s,
TCP Time = 807 s,
Mean PLR = 4.28%,
Mean RTT = 54.21 ms
(b) CTCP Time = 388 s,
TCP Time = 1151 s,
Mean PLR = 5.25%,
Mean RTT = 73.51 ms
(c) CTCP Time = 676 s,
TCP Time = 753 s,
Mean PLR = 4.65%,
Mean RTT = 106.31 ms
(d) CTCP Time = 292 s,
TCP Time = 391 s,
Mean PLR = 4.56%,
Mean RTT = 50.39 ms
(e) CTCP Time = 1093 s,
TCP Time = 3042 s,
Mean PLR = 2.16%,
Mean RTT = 208.94 ms
Figure 11: Public WiFi Network Test Traces (CTCP in black, TCP in red). The download completion times, the mean packet loss rate (), and mean for each experiment are also provided.

Measurements were collected at various public WiFi networks in the greater Boston area by downloading a 50 MB file from a server (running Ubuntu 10.04.3 LTS) located on the MIT campus to a laptop (running Ubuntu 12.04.1 LTS) under the public WiFi hotspot. The default operating system settings are used for all network parameters on client and server. Figure 11 shows representative traces for five examples of these experiments. It is important to point out that standard TCP stalled and had to be restarted twice before successfully completing in the test shown in Figure (c)c. CTCP, on the other hand, never stalled nor required a restart.

Each trace represents a different WiFi network that was chosen because of the location, accessibility, and perceived congestion. For example, the experiments were run over WiFi networks in shopping center food courts, coffee shops, and hotel lobbies. In Figures (a)a - (d)d, the WiFi network spanned a large user area increasing the possibility of hidden terminals; a scan of most of the networks showed > 40 active WiFi radios, which also increases the probability of collision losses. The only experiment that had a small number of terminals (i.e. five active radios) is shown in Figure (e)e. The mean packet loss rate measured over all experiments was approximately .

It can be seen that in each of the experiments, CTCP consistently achieved a larger average goodput and faster completion time. The average throughput for both CTCP and TCP is shown in Figure 12. Taking the mean throughput over all of the conducted experiments, CTCP achieves a goodput of approximately kbps while standard TCP achieves approximately kbps; resulting in a gain of approximately (250%).

We emphasize the observed loss rates of approximately in Figure 11, which is quite high and unexpected; resulting in CTCP’s significant performance gain over TCP’s. We believe that the loss rate is not only due to randomness but also due to congestion, interference, and hidden terminals. This is an area that would be worthwhile to investigate further. If our intuition is indeed correct, we believe that CTCP can greatly help increase efficiency in challenged network environments.

8 Summary and Future Work

We introduce CTCP, a reliable transport protocol using network coding. CTCP is designed to incorporate TCP features such as congestion control and reliability while significantly improving on TCP’s performance in lossy, interference-limited and/or dynamic networks. A key advantage of adopting a transport layer over a link layer approach is that it provides backward compatibility with the enormous installed base of existing wireless equipment. We present an portable userspace implementation of CTCP (requiring neither kernel level modifications nor changes to the network) and extensively evaluate its performance in both testbed and production wireless networks. In controlled lab experiments, we consistently observed reductions of more than an order of magnitude (i.e. >1000%) in completion times for both HTTP and streaming video flows when the link packet loss rate exceeds 5%. Measurements in public WiFi hotspots demonstrate that CTCP can achieve reductions in connection completion times of 100-300% compared with uncoded TCP.

Figure 12: Mean goodput for each of the experiments shown in Figure 11.

There are areas for further research. CTCP’s congestion control mechanism performs well in lossy networks where an increase in RTT indicates congestion. When the RTT also varies with non-congestion events such as variability resulting from specific MAC implementations, CTCP’s congestion control can needlessly limit throughput. New approaches for fairness and friendliness may be needed for such networks. In addition, we did not investigate the potential impact of active queue management (AQM) on CTCP. However, the effect of AQM may not be significant as fewer networks use AQMs with the introduction of protocols using streamlets, selective repeat mechanisms, and new congestion control mechanisms such as Cubic. Another possible extension is to allow re-encoding within the network [24, 25, 26], although this may require changes within the network (not just end-to-end). However, this approach has been shown to increase efficiency. Finally, we believe that CTCP can be extended to provide gains in multi-path environments [27]. By coding over multiple paths, initial simulations and experiments in [27] show that we can achieve the sum rate of each path without the complexity of tracking and scheduling individual packets through the multiple networks.


  • [1] B. Bakshi, P. Krishna, N. Vaidya, and D. Pradhan, “Improving performance of tcp over wireless networks,” in Proceedings of ICDCS, pp. 365–373, 1997.
  • [2] “Wireless technologies for network service providers 2012-2013.” Technicolor White Paper.
  • [3] J. K. Sundararajan, D. Shah, M. Médard, S. Jakubczak, M. Mitzenmacher, and J. Barros, “Network coding meets TCP: Theory and implementation,” Proceedings of IEEE, vol. 99, pp. 490–512, March 2011.
  • [4] C. Barakat and A. A. Fawal, “Analysis of link-level hybrid FEC/ARQ-SR for wireless links and long-lived tcp traffic,” in Proceedings of IEEE WiOpt, 2003.
  • [5] D. Barman, I. Matta, E. Altman, and R. Azouzi, “TCP optimization through FEC, ARQ and transmission power tradeoffs,” tech. rep., Boston Universirty, 2003.
  • [6] C. Barakat and E. Altman, “Bandwidth tradeoff between TCP and link-level FEC,” Computer Networks, vol. 39, pp. 133–150, June 2002.
  • [7] B. Liu, L. Dennis, A. Goeckel, and D. Towsley, “TCP-cognizant adaptive forward error correction in wireless networks,” in Proceedings of IEEE GLOBECOM, 2002.
  • [8] A. Chockalingam, M. Zorzi, and V. Tralli, “Wireless TCP performance with link layer FEC/ARQ,” in Proceedings of IEEE ICC, 1999.
  • [9] D. Kliazovich, M. Bendazzolo, and F. Granelli, “TCP-aware forward error correction for wireless networks,” in Proceedings of ICST Mobilight, 2010.
  • [10] M. Miyoshi, M. Sugano, and M. Murata, “Performance improvement of TCP on wireless cellular networks by adaptive FEC combined with explicit loss notification,” in Proceedings of IEEE Vehicular Technology Conference, 2002.
  • [11] I. Ahmad, D. Habibi, and M. Z. Rahman, “An improved FEC scheme for mobile wireless communication at vehicular speeds,” in Proceedings of ATNAC, 2008.
  • [12] T. Tsugawa, N. Fujita, T. Hama, H. Shimonishi, and T. Murase, “TCP-AFEC: An adaptive FEC code control for end-to-end bandwidth guarantee,” Packet Video, 2007.
  • [13] T. Porter and X.-H. Peng, “Effective video content distribution by combining TCP with adaptive FEC coding,” in Proceedings of IEEE BMSB, 2010.
  • [14] O. Tickoo, V. Subramanian, S. Kalyanaraman, and K. K. Ramakrishnan, “LT-TCP: End-to-end framework to improve TCP performance over networks with lossy channels,” in Proceedings of IEEE IWQoS, 2005.
  • [15] L. Baldantoni, H. Lundqvist, and G. Karlsson, “Adaptive end-to-end FEC for improving TCP performance over wireless links,” in Proceedings of IEEE ICC, 2004.
  • [16] T. Anker, R. Cohen, and D. Dolev, “Transport layer end-to-end error correcting,” tech. rep., Hebrew University, Leibniz Center, 2004.
  • [17] H. Lundqvist and G. Karlsson, “TCP with end-to-end FEC,” in International Zurich Seminar on Communications, 2004.
  • [18] C. Padhye, K. J. Christensen, , and W. Moreno, “A new adaptive FEC loss control algorithm for voice over IP applications,” in Proceedings of IPCCC 2000, 2000.
  • [19] V. Subramanian, “Transport and link-level protocols for wireless networks and extreme environments.” Ph.D. Thesis, RPI.
  • [20] J. Padhye, V. Firoiu, D. F. Towsley, and J. F. Kurose, “Modeling TCP Reno performance: a simple model and its empirical validation,” IEEE/ACM Trans. Netw., vol. 8, pp. 133–145, 2000.
  • [21] K. Tan, J. Song, Q. Zhang, and M. Sridharan, “A compound TCP approach for high-speed and long distance networks,” in Proceedings of INFOCOM, 2006.
  • [22] R. N. Shorten and D. J. Leith, “On queue provisioning, network efficiency and the transmission control protocol,” IEEE/ACM Trans. Netw., vol. 15, pp. 866–877, 2007.
  • [23] R. Shorten, F. Wirth, and D. Leith, “A positive systems model of TCP-like congestion control: asymptotic results,” IEEE/ACM Trans. Netw., vol. 14, pp. 616–629, 2006.
  • [24] T. Ho, M. Médard, R. Koetter, D. Karger, M. Effros, J. Shi, and B. Leong, “A random linear network coding approach to multicast,” IEEE Trans. Inf. Theory, vol. 52, pp. 4413–4430, October 2006.
  • [25] D. S. Lun, M. Médard, R. Koetter, and M. Effros, “On coding for reliable communication over packet networks,” Physical Communication, vol. 1, pp. 3–20, March 2008.
  • [26] S. Katti, H. Rahul, W. Hu, D. Katabi, M. Médard, and J. Crowcroft, “Xors in the air: Practical wireless network coding,” in Proceedings of ACM SIGCOMM, 2006.
  • [27] M. Kim, A. ParandehGheibin, L. Urbina, and M. Médard, “CTCP: Coded TCP using multiple paths,” in ArXiv, 2012.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
Add comment
Loading ...
This is a comment super asjknd jkasnjk adsnkj
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test description