Implementation of TCP LoLa in ns-3

Course Code : CO365

Course : Advanced Computer Networks

Overview

TCP LoLa is a delay-based congestion control algorithm that supports both, low queuing delay and high network utilization in high speed wide-area networks.

TCP Lola Summary

RTT_max and RTT_min: maximal and minimal measured RTT respectively
Q_low and Q_target: threshold values
Q_delay: queuing delay caused by the standing queue
Standing queue: a small queue deliberately created by TCP LoLa
Standing queue exists: overall amount of in-flight data is sufficient to fully utilize the bottleneck link

(a) Slow Start

TCP LoLa enters the slow start state after its initial start or after a retransmission timeout.

(b) Cubic Increase

Increase function used by TCP LoLa:

t: time since last window reduction
C: unit-less factor (C = 0.4)
K: recalculated whenever CWnd has to be reduced
CWnd_max: size of CWnd before last reduction

TCP LoLa uses this function only if the potential bottleneck link is most likely not fully utilized, i.e., no standing queue is detected.

(c) Fair Flow Balancing

Basic idea: Each flow should keep a low but similar amount of data (X) in the bottleneck queue. To keep the overall queuing delay between the thresholds Q_low and Q_target, X has to be dynamically scaled:

t = 0, when fair flow balancing is entered
φ is a constant.
CWnd is adapted as follows:

Qdata: amount of data the flow itself has queued at the bottleneck. Fair flow balancing requires that all competing flows enter and leave it at similar points in time => design puts a strong emphasis on synchronized state changes.

(d) CWnd Hold

In this state, the CWnd is unchanged for a fixed amount of time t_sync (default value = 250 ms). The hold time is necessary to ensure that all flows quit the current round of fair flow balancing.

(e) Tailored Decrease

Tailored decrease adjusts the CWnd reduction to the amount of congestion:

Each flow reduces its CWnd by Q_data – this should already empty the queue. CWnd is further reduced by the factor γ < 1 to ensure that the queue will actually be drained completely. To achieve this, K is calculated as follows:

RTT_min: RTT without any queuing delays
RTT_now: RTT including the standing queue

How are queuing delay measurements done?

RTT(t_k): an individual RTT measurement at time t_k
t_measure: a certain time interval independent of a flow’s RTT

The validity of RTT_min is checked after tailored decrease. RTT_min is reset, if no RTT_now value close to RTT_min has been measured for a certain number (e.g., 100) of tailored decreases.

Steps to reproduce

To run the code

First we need to download and use the development version of ns-3. If you have successfully installed mercurial, you can get copy of the development version with the following command :

hg clone http://code.nsnam.org/ns-3-allinone

cd ns-3-allinone && ./download.py

To build ns-3 downloaded, open the terminal to ns-3-allinone directory and enter the following command :

./build.py

Now clone the repository to your local machine.

git clone https://github.com/joe019/Implementation-of-TCP-LoLa-in-ns-3.git

Replace the contents in ns-3-dev directory with the cloned directory files. Then configure examples and tests in ns-3 using :

./waf configure --enable-examples --enable-tests

TCP Lola module has been provided in:

src/internet/model/tcp-lola.cc src/internet/model/tcp-lola.h

Once ns-3 has been built, we can run the example file as:

./waf --run "examples/tcp/tcp-variants-comparison --transport_prot=TcpLola"

References

[1] TCP LoLa: Congestion Control for Low Latencies and High Throughput (http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8109356)

[2] TCP LoLa implementation in the Linux Kernel (https://git.scc.kit.edu/TCP-LoLa/TCP-LoLa_for_Linux)