TCP Quadric Window Increment Based Congestion Control Algorithm

Implementation and Simulation in Computer Networks

Girish Paliwal, 1Swapnesh Taterh

1
1
Amity Institute of Information Technology, Amity University Rajasthan Jaipur, india
gpaliwal@jpr.amity.edu;staterh@jpr.amity.edu

ABSTRACT

Now, these days internet traffic increased over the server and Transmission Control Protocol
(TCP) provide the connection-oriented services. Different types of TCP congestion control
proposals have been developed to improve the TCP performance. TCP has a problem with
reduced the speed when it is face the congestion. It is not utilized full bandwidth due to
congestion avoidance. Most of the TCP congestion control algorithms are based on packet
losses, delay based, bandwidth estimation based or hybrid. In this research paper proposed
TCP congestion control algorithm is packet loss base. Its performance increased by
modifying congestion windows size increment during the transmission. This paper presents
the implementation of quadric increase congestion (QIC) control algorithm. The TCP QIC
simulated using network simulator (NS3). The TCP QIC algorithm is implemented after
modification in binary increased congestion (BIC) control algorithm. The TCP QIC
implemented with network simulator and tested with congestion control algorithms. We
analyze TCP Westwood, BIC, New Reno, scalable and Illinois congestion control algorithms
with TCP QIC. The performance of the TCP QIC is having the significance over the other
congestion control algorithms in respect of throughput, goodput, delay variance and round-
trip time.
Keywords: Congestion control, Transmission Control Protocol (TCP), NS3, TCP, Quadric Increase
Congestion (QIC), Data Communication.

INTRODUCTION
Over the past three decades, lot of work has been already done to enhance the TCP performance and the result
many different congestion control algorithms. But recently the congestion control work continue going on to find
out the best solution or alternative to resolve the congestion problem. The Transmission Control Protocol (TCP) is
completely responsible to provide a reliable communication between more than two Internet devices. TCP is
required almost all the communications. TCP provides reliable, error free and guaranteed data transmission at
transport layer. TCP is more secure data transmission protocol then the others. TCP control the data flow between
sender and receiver through the congestion window and advertised window. (Esterhuizen y Krzesinski, 2012).
The number of congestion control algorithms are already developed and implemented after finding some
enhancement result over the existing congestion control algorithms (Nagori, Balachandran, Deepak, Tahiliani y

1
Chandavarkar). The network simulator is used to compare different types of communication protocols. The
implementation and comparing them with other congestion control algorithms is troublesome without network
simulators. In the real world scenario, it is very difficult to compare algorithm performance on the basis of actual
devices. It is possible and vary convenient with the simulators. It is taken less time to evaluate an algorithm and
less expensive to the real testing. The network simulators are given almost near results to the actual results.
Computer network simulator provides valuable insight into potential algorithm implementation before extending
the considerable effort that may be required to build a technology. The simulators are allowing us to measure and
compare the existing algorithm as well as we can introduce a new algorithm and compare in light of existing
algorithms. It provides a much more flexible way to implement a new algorithm and finding out the related result
on the basis of some existing networking topology (Yang et al., 2014).
This paper presents an implementation of the Quadric Congestion Control (QIC) algorithm that is based on the
TCP BIC. In order to the ns3 TCP BIC that is most widely used by the Linux operating system (Brett Levasseur,
Mark Claypool,Robert Kinicki, 2014). I enhance the congestion control algorithm TCP back that use the
methodology of the congestion window increase in a binary manner whereas I will change a little bit in this
algorithm to check the performance of quadric congestion control window increase the effect is immense to attract
our attention.
The rest of this paper is organized as in the following sections the basic of the TCP in section II, section III related
work of the TCP congestion control algorithm, section IV simulation setup, and section V have the simulation
result matrix the last section is the conclusion of the present quadric congestion control algorithm performance.

TCP BASICS
Transmission control protocol (TCP) provides a connection-oriented connection between sender and receiver. A
Connection-oriented communication means TCP send packets between computers and provides acknowledgment.
The acknowledgement sequence number verify from the send data packet sequence number. Unacknowledged
data packets are retransmitted after a specific time period. The decision made from received acknowledgment basis
information about successfully received or not. The different algorithm takes their decision for retransmission of
data packet on the basis of lost sequence number or round trip time out. TCP congestion control enhancement
proposed are going on over the last 30 years to maximize the throughput and avoiding the congestion at the
internet routers and provide the services effectively and efficiently. The congestion control approach having some
common features these features are on the basis of changing in congestion window size, acknowledgment received
and round trip time of a packet. These parameters are used to implement and evaluated each and every TCP
congestion control algorithm. The proposed TCP wants to provide good throughput and low latency time also use
the maximum capacity of the channel (Allman, Paxson y Stevens, 2001).
The congestion window control the number of packets that TCP flow between two ends. The congestion window
is set using additive increase multiplicative decrease (AIMD) mechanism. The TCP probes the available

2
bandwidth dynamically adapting to changing network conditions. The AIMD mechanism work well when the
sender continuously has data to send. It is typically the case of TCP used for bulk data transfer. The TCP
implementation has a range of the congestion window behaviors for starting up after an ideal period. Many TCP
implementation slow start or reduced the congestion windows size after an ideal period longer than the round-trip
time out (RTO) estimates as suggested in (Allman et al., 2001) RFC 2581. while other implementations don’t
reduce their congestion window after an ideal period. When the congestion window is reduced the slow start
threshold remains as a memory of the recent congestion window, it is used to reset the congestion window again.
TCP sending of back to back data packets are facing packets dropout over the period of a round trip time. If the
congestion window that has not been fully utilized for some cases, we will not be assumed that an indication of the
bandwidth currently available for the floor. We would contain that the mechanism to pass out packet allowed by
the congestion window are largely used to determine the appropriate size of the congestion window (Allman,
2003). The Mechanism is to determine the number of round trip time out (RTO). The RTO is ideal period could
also be implemented by using the timer that expires every round trip time (RTT) after the last data packet received,
check per packet.

RELATED WORK

After, the literature revived. We found lots of related work with the TCP congestion control problem. It is broadly
studies in the context of different network as high speed network, wireless sensor network, ad-hoc mobile network
etc. (Kushwaha y Gupta, 2014) The congestion control taxonomy first time given for the packet switch network in
1995 (Yang y Reddy, 1995). Many research papers proposed end to end congestion control techniques. These
techniques have been developed over the last 30 years and address the problem in different ways. The different
TCP congestion control algorithms are analyze with the proposed congestion control algorithm. TCP scalable
introducing congestion control and it is used by windows operating system and others. It provides loss based
congestion control in high speed network. The TCP scalable used the multiplicative increase and multiplicative
decreased (MIMD). Second congestion control algorithm based on binary increased and multiplicative decreased
(BIMD). This algorithm is known as TCP binary increase congestion control (BIC). Another congestion control
algorithm based on loss base and delay based congestion control. The TCP New Reno improving the network
efficiency to adjusting congestion window for sensing delay. The TCP westwood algorithm is congestion control
by channel bandwidth estimation and loss based. TCP westwood increased the congestion window in logarithmic
form. Last type of congestion control algorithm is hybrid type. The TCP Illinois congestion control algorithm is
hybrid based on loss, delay and bandwidth estimation (Kushwaha y Gupta, 2014).
It is very challenging task to design a new protocol that can satisfy all the criteria like in congestion control. These
criteria are round trip time (RTT), fairness TCP friendliness and scalability (Hua y Jian; Nagori et al.). A protocol
should adopt its congestion window control depending on the size of the window. TCP BIC the congestion control

3
problem is viewed as a search problem ("https://www.nsnam.org/docs/models/html/tcp.html," 2017).The TCP
BIC binary increase congestion control that consists two parts binary search increase and additive increase.

METHODOLOGY

Quadric increase
Starting points for this search our current maximum window size and maximum window size usually represent
Wmin and Wmax are the windows just before the last recovery. The algorithm rapidly computes the Quadric-
point between Wmax and Wmin and set the current window size with the Quadric-point. It is check for feedback
in the form of packet loss. (Wang, Xin, Reeves y Shin, 2000)
If there is a packet loss then present threshold set to minimum increments. The bandwidth probing to be more
aggressive initially but it is relatively less aggressive to binary increase congestion (BIC), when the difference from
the current window size to the target window size is large, it become less aggressive as the current window size
gets closer to the target window size this technique is called quadric increase (L. Xu y K. Harfoush and I. Rhee,
2004).

Additive Increase
To ensure convergence at RTT fairness the quadric increase having an additive increase strategy also. When
distance from the Quadric-point to a current minimum is too large increase window size directly to the Quadric-
point. When the distance from the current window size to the target is less than the Smax, at that time window
increase directly to the target (L. Xu y K. Harfoush and I. Rhee, 2004).

Slow Start

The TCP congestion control algorithm runs a “slow start” strategy to probe for a new maximum, once the current
window size is greater than Wmax but smaller than Wmax+Smax. The congestion window increases in each RTT
round in steps.
Under the fast convergence, the quadric increase combines in multiplicative decrease converges to fair share.
Since the large window reduces more and multiplicative decrease the fast convergence strategy. The quadric
increase after a window reduction new maximum and minimum are set, than re-adjust the new congestion window
maximum size to be the same as the new target window. Which is the Quadric-point and then we adjust the target
and apply quadric increase. This has an effect to reduce the increasing rate of the larger window allows the smaller
window to catch up this strategy called fast convergence (L. Xu y K. Harfoush and I. Rhee, 2004).
The proposed algorithm based on TCP binary increased congestion control (BIC). It is modified when probing the
bandwidth and reset the congestion window. The proposed algorithm called Quadric Increase Congestion Control
(QIC). The detailed description of TCP BIC algorithm could be found in (SeyedShams Feyzabadi). A diagram of
BIC algorithm during the Congestion Avoidance phase is shown in figure 1

4
 Figure 1. TCP BIC congestion avoidance representation

SIMULATION SET UP

In this section, we have evaluated and analyzed the different type of congestion control algorithms Westwood,
BIC, NewReno, scalable, Illinois with QIC. We are using a simple network scenario and applied through the
network simulator NS3. To test the behavior of each congestion control algorithm Protocol in the bottleneck
bandwidth network, we used simple simulation topology that consisting of a one sender and one receiver
interconnected to each other through a router this is shown in Figure 2. Here we create a point to point connection
between the sources and sink. Simulate this for different bandwidth between server to the router. Each bandwidth
simulated with different time period but used the same queue handling method. Each TCP congestion control
algorithm is analysis on the basis of the congestion window, Round trip time , throughput, goodput, jitter and
packet sends. Table 1 shows the network simulator parameters that used in simulation in NS3. (Grieco y Mascolo,
2004).

10 Mb/s, 0.45 ms 2Mb/s,0.01ms

Figure 2. TCP congestion Simulation network Scenario

5
Table 1
Simulation variables and its values
Parameters Values
Bottleneck Bandwidth 2 Mb/s
Time of Simulation 50 seconds
Queue Type PfifoFastQueueDisc
Nodes 2
Delay 0.01 ms
TCP Congestion Control Algorithms TCP Westwood, BIC, NewReno, scalable, Illinois, and QIC
Access Bandwidth 10 Mb/s
Access Delay 0.45 ms

Few lines of code of NS3 implementation are describe here that show the different TCP
congestion control algorithm are simulated according to the supplied parameters in
transport_prot.compare command line arguments. To generate the congestion situation transmits
the bulk data packet randomly. The NS3 having default random number generator to perform the
events to send data packet and received by the source and sink nodes.

…
Address sinkLocalAddress (InetSocketAddress (Ipv4Address::GetAny (), port));
PacketSinkHelper sinkHelper ("ns3::TcpSocketFactory", sinkLocalAddress);

for (uint16_t i = 0; i < sources.GetN (); i++)

{
AddressValue remoteAddress (InetSocketAddress
(sink_interfaces.GetAddress (i, 0), port));

if (transport_prot.compare ("TcpNewReno") == 0
|| transport_prot.compare ("TcpWestwood") == 0
|| transport_prot.compare ("TcpQIC") == 0
|| transport_prot.compare ("TcpBic") == 0
|| transport_prot.compare ("TcpScalable") == 0
|| transport_prot.compare ("TcpIllinois") == 0)
{
Config::SetDefault ("ns3::TcpSocket::SegmentSize", UintegerValue
(tcp_adu_size));
BulkSendHelper ftp ("ns3::TcpSocketFactory", Address ());
ftp.SetAttribute ("Remote", remoteAddress);
ftp.SetAttribute ("SendSize", UintegerValue (tcp_adu_size));
ftp.SetAttribute ("MaxBytes", UintegerValue (int(data_mbytes *
1000000)));

ApplicationContainer sourceApp = ftp.Install (sources.Get (i));

sourceApp.Start (Seconds (start_time * i));
sourceApp.Stop (Seconds (stop_time - 3));
...

6
 RESULT EVALUATION METRICS
The performance of the congestion control algorithms evaluated from the major performance metrics as average
throughput, average goodput , average delay, average package reception and packet send per seconds. These
metrics are calculated for the bottleneck link. To extract these metrics values trace sources are installed on the
network device of the router. Each time a packet is send or received by the device. The event handler method
invoked to calculates performance metrics. The timestamp to packet as they en-queue and de-queue is
implemented by the call back function.

Throughput

It is measured as the ratio of the total amount of received data and the total simulation run time. This
metrics is important to find out the performance of the network (Girish Paliwal y Swapnesh Taterh,
2017).

Average Throughput =Total data received / Simulation time

Goodput

In computer networks, goodput is the application- level throughput. The amount of data considered
excludes protocol overhead bits as well as retransmitted data packets. The goodput is the actual data that
send and received by end user. This is always less than the throughput value because goodput remove the
extra overhead data bits.

Delay (End to End)

D end-end= N[ dtrans+dprop+dproc+dqueue]

where

Dend-end= end-to-end delay

dtrans= transmission delay, due to data packaging

dprop= propagation delay, due to distance

dproc= processing delay, due to packet processing

dqueue= Queuing delay, due to handling of queue

N= number of links (Number of routers - 1), intermediate routers between source and destination.

Note: we have neglected queuing delays.

The average end-to-end delay measured by the total time taken by sent packets, divided by the total time
taken by received packets.

Packet Delivery Ratio

It is a ratio of a packet generated by the source and the number of packets delivered to the destination

7
(Girish Paliwal y Swapnesh Taterh, 2017).

Packet delivery time = Transmission time + Propagation delay

Packet Loss

Number of dropped packed when the buffered becomes full or stored packed time to live exceeds. It is a
metrics that identify the algorithm loss of packets.

TCP QIC ANALYSIS WITH OTHERS

After the simulation results metrics are calculated. The observation of the throughput metrics is that the proposed
TCP QIC values are attracts the attention. It is analyzed that the throughput of the TCP QIC having some
significance value with comparing to other congestion control algorithms. This is represented by the figure 3. In
this graph the throughput representation in increasing order.

Figure 3. Throughput comparison between congestion control algorithms in increasing order

8
 Figure 4. Goodput graph for bottleneck bandwidth 2Mb/s in increasing order

In figure 4 represent the goodput graph. The throughput and goodput result of the simulation 50 seconds for 2
Mb/s bottleneck bandwidth. The simulation with different cases of bandwidth (2,5,10) and simulation
time(25,50,80). The observation is that when bandwidth increasing the congestion windows is increasing
significantly and congestion does not occur for this scenario that’s why here only one simulation results describe.
In the figure 5 shows the end to end delays in transmission. In this graph, the average delay calculated that show
the lowest average delay TCP Westwood, NewReno, and Scalable and highest average delay TCP Illinois and
BIC. TCP QIC having an average delays between lowest and highest. In this regard, the TCP QIC performance is
better than the TCP BIC and Illinois.

Figure 5. Average end to end delay representation

The following figure 6 shows the number of packets sends by each TCP congestion control algorithm in increasing
order these are represented by the graph. It is very simple logic when the number of packets sent by any algorithm

9
then data more transmitted and it shows the maximum utilization of the bandwidth and produced maximum
throughput. It is proved by the above and below graphs that the TCP QIC is having an advantage in terms of
throughput and data transmission.

Figure 6. Packet received in 50 seconds simulation

Figure 7 represents the data packet transmission speed that is represented by the lambda. Lambda is the data packet
send per second. If data packet sends per second is higher that means the data packed acknowledgment received
speed is higher, that show the congestion prevention and congestion control is efficiently handled by the TCP QIC
rather than TCP BIC, Westwood, NewReno, Illinois and Scalable.

Figure 7. packet send speed

If data packet send speed higher but receiving speed not similar to the sending speed in this situation congestion
occur and data packets are dropped and retransmission of same data packets. This is affecting the throughput and
average end to end delay.

10
TCP QIC throughput and goodput are 0.54% higher than the TCP BIC, similarly number of packets 11.35% more
transmitted and received then the TCP BIC. The average delay of the TCP QIC is 0.04% decreased then the TCP
BIC. These comparisons show that the TCP QIC have better performance then TCP QIC. The following table 2
shows comparative result.
Table 2
2Mb/s BW and 50 seconds Simulation values
  Throughput Goodput Average Delay Number of Lambda
/ Jitter packets
TCP BIC 246948.479 214188.137 0.045304860 17417 630.01
TCP QIC 248278.629 215341.839 0.045287447 19394 633.40

CONCLUSION
This paper proposes a TCP congestion control algorithm based on the TCP BIC that is a quadric congestion
control (QIC). TCP QIC is a simulation of the different parameters values using the NS3 simulator. The simulation
metrics are generated after 50-second simulation. Each of the congestion control algorithms simulated same time.
The different kind of graph plotted on the basis of simulation metrics result that represents the TCP QIC having
0.54% better throughput and Goodput. TCP QIC having 11.35% efficient data packet transmission speed to the
TCP BIC and it also receives a maximum number of packets within a 50 second of simulation time. TCP QIC
average delay time is 0.04% lower than the TCP BIC delay time. Finally, we say that the TCP QIC having better
performance than the other TCP congestion control algorithms as Westwood, Illinois, NewReno, BIC and
scalable.

REFERENCIAS
Allman, M., Paxson, V. y Stevens, W. (2001). RFC 2581: Tcp congestion control, April 1999. Obsoletes RFC2001
[48],
Allman, M. (2003). TCP congestion control with appropriate byte counting (ABC).
Brett Levasseur, Mark Claypool,Robert Kinicki. (2014). A TCP CUBIC Implementation in ns-3 ∗, In Proceedings
of the 2014 Workshop on ns-3 (p. 3). ACM., 1–12. https://doi.org/10.1002/9781118266892.ch1
Esterhuizen, A. y Krzesinski, A. E. (2012). TCP Congestion Control Comparison. SATNAC, September,
Girish Paliwal y Swapnesh Taterh. (2017). Impact of Dense Network in MANET Routing Protocols AODV and
DSDV Comparative Analysis Through NS3, 327–335.
Grieco, L. A. y Mascolo, S. (2004). Performance evaluation and comparison of Westwood+, New Reno, and Vegas
TCP congestion control. ACM SIGCOMM Computer Communication Review, 34(2), 25.
https://doi.org/10.1145/997150.997155
https://www.nsnam.org/docs/models/html/tcp.html. (2017).
Hua, W. y Jian, G. Analysis of TCP BIC Congestion Control Implementation, 781–784.
https://doi.org/10.1109/CSSS.2012.200
Kushwaha, V. y Gupta, R. (2014). Congestion control for high-speed wired network: A systematic literature review.
Journal of Network and Computer Applications, 45, 62–78.

11
L. Xu y K. Harfoush and I. Rhee. (2004). IEEE INFOCOM 2004: The conference on computer communications :
Twenty-third Annual Joint Conference of the IEEE Computer and Communications Societies : proceedings : 7-
11 March, 2004, Hong Kong Convention and Exhibition Centre, Hong Kong, PR China.
Nagori, K., Balachandran, M., Deepak, A., Tahiliani, M. P. y Chandavarkar, B. R. Common TCP Evaluation Suite
for ns-3, 9–16. https://doi.org/10.1145/3067665.3067676
SeyedShams Feyzabadi. Identifying TCP Congestion Control Mechanisms Using Active Probing.
Wang, H., Xin, H., Reeves, D. S. y Shin, K. G. (2000). A simple refinement of slow-start of TCP congestion control.
En Computers and Communications, 2000. Proceedings. ISCC 2000. Fifth IEEE Symposium on (pp. 98–105).
Yang, C.-Q. y Reddy, A. V. S. (1995). A taxonomy for congestion control algorithms in packet switching networks.
IEEE network, 9(4), 34–45.
Yang, P., Shao, J., Luo, W., Xu, L., Deogun, J. y Lu, Y. (2014). TCP Congestion Avoidance Algorithm
Identification. IEEE/ACM Transactions on Networking, 22(4), 1311–1324.
https://doi.org/10.1109/TNET.2013.2278271

12