The Transmission Control Protocol (TCP) was originally designed for wired networks, by interpreting packet loss (PL) as congestion consequence; meanwhile, in wireless networks, PL is also caused by issues in the communication channel, such as interference, multi-path fading, mobility, and reflections, which may produce a PL misinterpreting [1
]. In order to avoid congestion, TCP employs cumulative Acknowledgments (ACK); in this sense, the receptor sends ACKs to indicate that a packet was successfully received and to specify that it is expecting the next one. If the transmitter undetected an ACK, the packets are re-sent or the connection is disrupted [2
]. TCP can use four algorithms for Congestion Window (CWND) control: Slow Start, Congestion Avoidance, Fast Retransmit and Fast Recovery. These algorithms seek to achieve a high network performance and to avoid collapse by congestion. Slow Start increases exponentially the transmission bit rate until a packet loss is detected. From this point, the Congestion Avoidance algorithm increases the transmission bit rate linearly, and when three duplicate ACKs are detected, TCP reduces the transmission bit rate by half. Meanwhile, Fast Retransmit and Fast Recovery allow to resend packets immediately when three duplicate ACK (DUPACK) are detected. The transition from one algorithm to another occurs when PL is detected [3
]. Although CWND control algorithms achieve their goal in wired networks, in wireless networks, unnecessary executions of the four algorithms occur frequently, which, in turn, causes low transmission bit rates, as seen in the results presented in [4
TCP has different versions seeking CWND optimization by an ACK notification rate analysis. Two of the most popular TCP versions are TCP Reno and TCP Westwood. The first one reduces CWND by half after three DUPACK, while the second selects a Slow Start threshold (ssthresh) and a CWND consistent with the effective connection bit rate [5
]. Several efforts to improve TCP protocol in wireless networks have been developed, for instance, Explicit Loss Notifications (ELN) which adds explicit bits to the packet as feedback to the TCP source to identify the loss cause. For example, in [6
], ELN gives a superior throughput (
than TCP Reno and TCP-Tahoe, reaching as high as 80 to 90% in an error free simulated scenario. Similarly, in [7
], by using ELN, reduced response times of almost 30% were obtained for high error probability web traffic in a simulated scenario. Another proposal for wireless TCP improvement is the end-to-end coding approach [8
], in which redundancy is added to the TCP packet to facilitate loss recovery, which outperforms in simulation TCP New Reno and TCP with the selective acknowledgment option (TCP SACK) over a range of loss probability and propagation delays.
Additionally, other modification approaches exist for TCP functionality, such as the use of a fast end-to-end retransmission scheme [9
]. This proposal avoids long pauses in communication during cellular handoffs. It requires minimal changes to end terminals and improves
values from 1400 to 1490 kb/s for non-overlapped cells with zero seconds between cells, and from 1100 to 1380 kb/s for non-overlapped cells with 1 second between cells. In [10
], the Indirect TCP protocol (I-TCP) splits the network in a wired-cum-wireless connection by adding a Mobility Support Router, and then it attempts to alleviate mobility related performance problems by adapting the transport layer protocols on the wireless link, modifications are required only on the Mobile Host (MH). This solution achieved better
than TCP Reno for a local area network under a Bit Error Rate (BER) of up to 2 × 10−6
, and twice
for a wide area network under BER of up to 5 × 10−6
. In [11
], a sender-only TCP modification based on dynamic bandwidth estimation in wired-cum-wireless networks is presented as TCP Prairie. This protocol fairly estimates the bandwidth to set the CWND and the ssthresh
after three DUPACK or after a timeout. The protocol was simulated by ns-2, where the θ gain over TCP Westwood was 17 percent at 0.01 BER and 542% over TCP New-Reno at 0.5 BER. Finally, another wireless link problem to be addressed is the Retransmission Timeout (RTO) which is calculated based on the Round-Trip Time (RTT), which is fluctuating in wireless networks. This RTT dependence can be appreciated on in-door environments, where θ unbalances, hidden terminals problems, and interference among Basic Service Sets frequently occur. As a solution, in [12
], a MAC layer contention window control is proposed using an analytical model of nonlinear equations, achieving a fair θ distribution with a confidence interval of 99.98% at a 2 Mb/s bit rate.
Several solutions for wired-cum-wireless network improvement with a wireless local retransmission approach have been also proposed, for example, in [13
], the snoop protocol caches unacknowledged packets from the fixed host at the Base Station (BS) and performs local retransmissions across the wireless link. For a wireless link BER of over 5 × 10−7
, the snoop protocol achieves a
improvement of 1 to 20 times than TCP Reno for data transfer from the fixed host to the MH, requiring modifications at the BS and the MH. In [14
], a TCP extension called Delayed Congestion Response TCP protocol (TCP-DCR) was proposed. Such protocol delays the fast retransmit/recovery algorithm when the sender receives the first DUPACK by starting a delayed response timer in order to allow a link level retransmission at the BS to recover a lost packet. With some modifications at the sender host, TCP-DCR reaches better θ than TCP-SACK for several BER values. Meanwhile, in [15
], the authors propose a trend topic in communications by using machine learning based loss discrimination algorithm (ML-LDA) for wireless TCP congestion control. ML-LDA learns how to distinguish packet losses due to congestion and wireless channel environment using multi-layer perceptron (MLP). Based on the learning results, the congestion control classifies the cause of losses and does not reduce congestion window in case of random losses. The algorithm was implemented in Linux kernel and configured a testbed where packet loss occurs randomly. They compared the experimental results with TCP-Reno and TCP-Westwood and showed that the proposed ML-LDA has 98% packet loss classification accuracy in wireless channel environments, and average throughput is greatly improved compared to the others congestion controls.
In this context, the aim of this paper is to describe the development of a novel simple TCP protocol algorithm adapted to wireless networks. Specifically, we address improvements in the wireless TCP. In this paper, we will consider all stages related to performance evaluation, including a mathematical analysis, configuring our proposal by modifying the linux kernel, emulations, and finally testbed analysis in real scenarios. Our primary hypothesis is that by inserting a negative acknowledgment (NACK) flag inside the TCP header, naming this TCP modification as “TCP-NACK”, we will prevent the misinterpretation of PL due to channel instability, as well as PL due to congestion, thus reaching a better performance. In this sense, we consider the ELN concept of retransmitting corrupted packets without the CWND reduction.
The rest of the paper is organized as follows: In Section 2
, we describe the methods and materials used for TCP-NACK design, emulation, and evaluation. Section 3
presents the experimentation process and how the results were obtained. Section 4
presents the discussion of the results when compared to generic TCP algorithms. Finally, our conclusion and future works are presented in Section 5
5. Conclusion and Future Work
Since the TCP protocol was designed to work in wired networks, its performance is not adequate for wireless networks, where the packets corrupted for interference, obstacles or fading are discarded and taken as a fictional congestion con- sequence. This assumption entails to an unnecessary CWND reduction which decreases the transmission bit rate.
In this paper, we proposed a TCP-NACK protocol that endures wireless performance problems by the incorporation of an error notification or “NACK” to the Generic TCP protocol functionality. This notification indicates to the transmitter the arrival of corrupted packets, proceeding to an immediate re- transmission without the CWND reduction. For its validation, we exposed the mathematical analysis, configurations to the Linux source code, emulation, and the testbed analysis in real scenarios.
The results obtained demonstrate a better performance of TCP-NACK protocol against its generic counterpart (TCP Reno) under different scenarios including different distances, bandwidths, packet error rates and technologies employed. Regardless of the fact that the experimental results obtained are lower than the mathematical results, we achieved an average improvement of 54% in , 26% in δ, and 5% in jitter when compared to Generic TCP. It is important to highlight that we obtained the best results between 100 and 414 m, where, on average, there is an improvement of 90%. The principal differences among our work and those described in the literature are the performance evaluation as a function of the distance, and the experimentation tests over networks with exclusively wireless links.
In summary, TCP-NACK is a good option for wireless networks, and it is perfectly attachable to any personal computer as a modified Linux operating system. This proposal was evaluated under several real conditions and demonstrated high improvements when compared with TCP Reno protocol.
As future works we are interested in considering the communication standard, frequency and the running application (e.g., VoIP) as variables. We are also interested in performing tests with larger distances and bandwidths evenly distributed. We are also planning to include tests with an optimization of the RTT calculation, by applying the mathematical modeling described in [24
] with the aim of improving the θ
values for wireless links with short and long distances. Finally, we are interested in comparing with other proposals which are available to be implemented in open hardware.