Modeling the Throughput of the Linux-Based Agile-SD Transmission Control Protocol

TL;DR

This paper develops a mathematical model for Agile-SD, a TCP congestion control algorithm, validating its performance through analysis and optimizing its parameters to enhance throughput over high-speed networks.

Contribution

It introduces a Markov chain-based throughput model for Agile-SD and proposes an automated parameter tuning method to optimize its performance.

Findings

Model accurately predicts Agile-SD throughput

Parameter tuning improves network performance

Validated model against simulation results

Abstract

Agile-SD is one of the latest versions of loss-based congestion control algorithm (CCA), which has been proposed to improve the total performance of transmission control protocol (TCP) over high-speed and short-distance networks. It has introduced a new mechanism, called agility factor mechanism, which shortens the epoch time to reduce the sensitivity to packet losses and in turn to increase the average throughput. Agile-SD has only been tested via simulation; however, it has not been mathematically proven or evaluated. The contribution of this paper is twofold. First, a new mathematical model for the throughput of NewReno and Agile-SD is proposed. This model is designed using the well-known Markov chains to validate the correctness of Agile-SD and to show the impact of buffer size, multiplicative decrease factor, and maximum limit of agility factor ({\lambda}max ) on the total performance. Second, an automated algorithm configuration and parameter tuning (AACPT) technique is employed to optimize and automate the configuration of {\lambda}max . Furthermore, the numerical results for both NewReno and Agile-SD are compared with the simulation results, in which the validity of the proposed model is confirmed. Moreover, the output of the AACPT is exploited to formulate a new equation, which calculates the optimal {\lambda}max from a given \b{eta} in order to conserve the standard interface of the TCP. This equation increases the scalability of Agile-SD and improves its total performance.

Tables

Table 1. TABLE I: The Setting of Model Parameters.

Parameter	Value(s)
Buffer size ($b$)	From 4 to 128 packets
Loss rate ($R$)	From ${10}^{-8}$ to ${10}^{-3}$
Packetsize ($\theta$)	1000 bytes
Link capacity ($C$)	1Gbps
2-way Link delay (RTT)	10ms
Minimum allowed window ($\check{w}$)	2
Maximum allowed window ($W$)	$\left(C\times \mathrm{RTT}/\theta \right)+b$
System states ($N$)	$\left(W-\check{w}\right)+1$
Sample space of the system ($S$)	$\{\check{w},\check{w}+1,\dots ,W\}$
Iterations ($I$)	10,000 state transitions
Congestion control algorithms	Agile-SD	NewReno
Multiplicative decrease factor $\left(\beta \right)$	0.5	0.5
Minimum $\lambda$ $\left({\lambda }_{\min }\right)$	1	1
Maximum $\lambda$ $\left({\lambda }_{\max }\right)$	5	1

Table 2. TABLE II: The Setting of Simulation Parameters.

Parameter	Value(s)
CCAs	Agile-SD, NewReno
$\beta$	0.5
${\lambda }_{\min },{\lambda }_{\max }$	1, 5 only for Agile-SD
Buffer size	From 4 to 128 packets
Packet size	1000 bytes
Link capacity	1Gbps
2-way Link delay	10ms
Loss rate (PER)	From ${10}^{-8}$ to ${10}^{-3}$
Queuing Algo	Drop-Tail
Traffic type	FTP
SACK, FACK	Disabled
Simulation time	100 seconds
Simulator version	NS-2 ver2.35

Equations

$$W=\frac{\mathrm{BDP}}{\theta }.$$

$$W\approx \frac{\mathrm{BDP}}{\theta }+b,$$

$$w_i^j=w_{i-1}^j+\frac{1}{w_{i-1}^j},$$

$$w_i^j=w_{i-1}^j+\frac{{\lambda }_i^j}{w_{i-1}^j},$$

$${\lambda }_i^j=\max \left({\lambda }_{\max }\times \left(\frac{w_k^{j-1}-w_{i-1}^j}{w_k^{j-1}-w_0^j}\right),{\lambda }_{\min }\right),$$

$${\mathrm{Tr}}_i^j\text{(Packets/s)}=\frac{\lfloor w_i^j\rfloor }{\mathrm{RTT}}.$$

$${\mathrm{EATr}}^j(\mathrm{Kbps})=\theta \times \frac{\sum _{i=0}^k\frac{\lfloor w_i^j\rfloor }{{\lambda }_i^j}}{\sum _{i=0}^k\frac{\mathrm{RTT}}{{\lambda }_i^j}},\forall j\in \{1,2,\dots ,n\},$$

$$\mathrm{TATr}(\mathrm{Kbps})=\theta \times \frac{\sum _{j=1}^n\sum _{i=0}^k\frac{\lfloor w_i^j\rfloor }{{\lambda }_i^j}}{\sum _{j=1}^n\sum _{i=0}^k\frac{\mathrm{RTT}}{{\lambda }_i^j}},w_i^j\le W.$$

$$\displaystyle P_{x}(w)=\left\{\begin{array}[]{ll}\dfrac{(Rw)^{x}e^{-Rw}}{x!}&,x=0,1,2,...\\ \\ 0&,\text{otherwise}\end{array}\right.$$

$$N=W-\check{w}+1,$$

$$T=\left[\begin{array}{ccccc}{}_{v[1,1]}& {}_{v[1,2]}& \dots & {}_{v[1,N-1]}& {}_{v[1,N]}\\ {}_{v[2,1]}& {}_{v[2,2]}& \dots & {}_{v[2,N-1]}& {}_{v[2,N]}\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ {}_{v[N-1,1]}& {}_{v[N-1,2]}& \dots & {}_{v[N-1,N-1]}& {}_{v[N-1,N]}\\ {}_{v[N,1]}& {}_{v[N,2]}& \dots & {}_{v[N,N-1]}& {}_{v[N,N]}\end{array}\right],$$

$$\displaystyle v[i,j]=\left\{\begin{array}[]{ll}P_{x}(w)&,j=\lfloor\beta\times i\rfloor\\ &,i=[1,N-1]\\ \\ 1-P_{x}(w)&,j=i+1\\ &,i=[1,N-1]\\ \\ 1&,j=\lfloor\beta\times i\rfloor\\ &,i=N\\ \\ 0&,\text{otherwise},\end{array}\right.$$

$$\displaystyle v_{i}=\Big{[}v[i,1],v[i,2],\ldots,v[i,N]\Big{]},$$

$$\sum _{j=1}^{N}v[i,j]=1,\forall i\in \{1,2,\dots ,N\}.$$

$$v^{(t)}=v^{(t-1)}\times T,\forall t\in \{1,2,\dots ,\infty \},$$

$$\displaystyle v^{(0)}[j]=\left\{\begin{array}[]{ll}1&,j=\lceil\beta N\rceil\\ \\ 0&,\text{otherwise}\end{array}\right.,\forall j\in\{1,2,\ldots,N\},$$

$$\mathrm{ATh}(\mathrm{Kbps})=\theta \times \frac{\sum _{t=1}^I\frac{(v^{(t-1)}\times T)\times S^{{}^{\prime }}}{{\lambda }^{(t)}}}{\sum _{t=1}^I\frac{\mathrm{RTT}}{{\lambda }^{(t)}}},\mathrm{ATh}\le \frac{W}{\mathrm{RTT}},$$

$$\displaystyle\lambda^{(t)}=\max\left(\lambda_{\rm max}\times\left(\frac{W-\Big{(}(v^{(t-1)}\times T)\times S^{{}^{\prime}}\Big{)}}{W-(\beta W)}\right),\lambda_{\rm min}\right),$$

$$\displaystyle\overrightarrow{\beta\lambda^{\prime}_{i}}=\Big{[}(\beta_{i},\lambda^{\prime}_{1}),(\beta_{i},\lambda^{\prime}_{2}),\ldots,(\beta_{i},\lambda^{\prime}_{n})\Big{]},\forall i\in\{1,2,\ldots,m\}.$$

$${\lambda }_{\mathrm{opt}}^{\prime i}=$$

Full text

11footnotetext: Department of Communication Technology and Network, Universiti Putra Malaysia, 43400 UPM, Serdang, Selangor D.E., Malaysia.22footnotetext: Department of Computer and Communication Systems Engineering, Universiti Putra Malaysia, 43400 UPM, Serdang, Selangor D.E, Malaysia.33footnotetext: The author is an associate researcher at the Computational Science and Mathematical Physics Lab, Institute of Mathematical Science, Universiti Putra Malaysia.

Corresponding authors:

mohamed.asnd@gmail.com (Mohamed Alrshah),

mothman@upm.edu.my (Mohamed Othman).

Introduction

One of the most predominant protocols of the Internet is the Transmission Control Protocol (TCP), which provides a high level of reliability on end-to-end connections. It regulates the transmission rate between the two ends of a connection based on the changes of the underlying network. In other words, it estimates the condition of the connection and adjusts its congestion window (cwnd) accordingly.

In order to enhance the total performance of TCP over high-speed networks, many Congestion Control Algorithms (CCAs) have been proposed in the literature such as Scalable TCP [1], HS-TCP [2], H-TCP [3], BIC [4], TCP Africa [5], TCP Compound [6], Fusion [7], YeAH [8], TCP illinois [9], Cubic, [10] and HCC [11]. The main three approaches, which are employed by these CCAs, are either loss-based, delay-based or loss-delay-based approach [12].

The delay-based approach relies on the variation of delay resulted by big buffers and/or long RTTs, which are presented in high-BDP networks. However, the low-BDP networks employ small buffer sizes and generate very short RTTs resulting in a very trivial delay variation, which makes it worthless to use a delay-based approach. These characteristics of such networks allow TCP to rely only on packet losses since it is the only indicator to congestion. In turn, this behavior makes TCP very sensitive to packet losses, which negatively affects its total performance.

One of the latest versions of loss-based TCP CCA is Agile-SD [13], which has been proposed with a view to mitigating the sensitivity to packet losses. It proposes Agility Factor ($\lambda$), which is used to shorten the epoch time (the epoch is the time needed by a CCA to increase its $cwnd$ from the time of reduction to the time of attaining the maximum utilization of the link), as shown in Fig.1. The unique Agility Factor Mechanism (AFM) of Agile-SD has been evaluated by extensive simulation experiments, which confirmed that Agile-SD has the ability to reduce the sensitivity to packet losses and to improve the performance of TCP to a reasonable extent, especially over low-BDP networks.

In the literature, many mathematical models have been proposed in order to study and evaluate the performance of TCP. The authors of [14, 15] proposed a clear model to calculate the steady-state throughput of TCP as a function of RTT and loss rate. Also, The authors of [16] evaluated the throughput of TCP using periodic loss based model. The authors of [17] used the Markov chains and the stationary distribution to predict the behavior of TCP dealing with RED-based routers. The authors of [18] used the random matrix model to evaluate the performance of multiple AIMD TCP flows via drop-tail queue management system. The authors of [19] derived the stationary distribution of Markov chains to calculate the steady-state throughput of TCP Cubic.

As aforementioned, the models in [14, 15, 16, 17, 18, 19] calculate the steady-state throughput of TCP as a function of RTT and loss rate, while they did not take the buffer size into account. In order to calculate the throughput of TCP as a function of buffer, RTT and loss rate, we propose a novel mathematical model to calculate the average throughput of both NewReno and Agile-SD over high-speed networks. The main contributions of this model are: First, to validate the simulation results of Agile-SD by comparing it to the numerical results of this model and to the results of NewReno as a benchmark. Second, to study the impact of $\lambda_{\rm max}$ parameter on the throughput and epoch time, where the epoch time is a period of time confined between two consecutive losses. Third, to formulate an equation for automating the configuration of optimal $\lambda_{\rm max}$ based on the given system parameter $(\beta)$ in order to increase the scalability of Agile-SD.

I System Model for AFM-Based Agile-SD TCP

Consider a link between two computers and suppose that the link speed is C (in Kbps) and the source has a large file to send to the destination. Assume that the Packet Size is $\theta$ (in Kbits). Also, assume that the RTT (in seconds) is constant, which is a common assumption in loss-based TCP mathematical models [14, 15, 19]. Since the Bandwidth-Delay Product (BDP) of a link is equal to the multiplication of C by RTT, consequently, the maximum congestion window size $W$ is calculated as Equation (1) [20],

[TABLE]

As for the buffer size, we necessarily need to understand its impact on the behavior of TCP to know how it could affect this model. Based on Equation (1), suppose that we have a scenario in which the maximum window size is 100 packets, which allows 100 packets, maximum, to be in-flight. Then, let us say that the buffer size used in this link is 20 packets, which allows the maximum packets in-flight to be 120 packets. Accordingly, we can conclude that the buffer size is playing a role in extending the capacity of the link, thus, Equation (1) can be reformulated as below,

[TABLE]

where $b$ is a constant indicates to the buffer size in packets.

I-A Congestion Control of Agile-SD

At the congestion avoidance stage, Agile-SD increases its congestion window $w$ by a small fraction after every reception of acknowledgment, similarly like the standard NewReno. However, NewReno calculates this increase as 1 over $w$, which gives:

[TABLE]

while in Agile-SD this increase is calculated as $\lambda$ over $w$, which gives:

[TABLE]

where the cycle index $i$ $\in\{1,2,\ldots,k\}$, $k$ is the amount of degradation in congestion window after loss, $k=W(1-\beta)$, $\beta$ is the multiplicative decrease factor of TCP, the epoch index $j$ $\in\{1,2,\ldots,n\}$ and $n$ is the number of epochs needed for TCP connection to finish its data transmission, where $n=\frac{\rm TT}{k}$ and TT is the total transmission time, as shown in Fig.1. As for $\lambda^{j}_{i}$, it represents the agility factor of Agile-SD at the cycle $i$ in the epoch $j$, which is calculated as in Equation (5) below,

[TABLE]

where $\lambda_{\rm min}$ and $\lambda_{\rm max}$ are system parameters, $\lambda_{\rm min}=1$, $\lambda_{\rm max}>1$, $\lambda^{j}_{i}\in[\lambda_{\rm min},\lambda_{\rm max}]$, $w_{0}^{j}$ is the congestion window on the time of reduction of the previous epoch, where $w_{0}^{j}=\max(\beta w_{k}^{j-1},\check{w})$, $w_{k}^{j-1}$ is the congestion window just before the time of reduction of the previous epoch and $\check{w}$ is a system parameter representing the minimum allowed congestion window. As for max() function, it is used to always guarantee that $\lambda^{j}_{i}\geq\lambda_{\rm min}$.

From Fig.1, it is very clear that the epoch is a period of time confined between two consecutive losses [19]. Each epoch $j$ contains a number of sequent cycles and every cycle $i$ is a sub-period of time confined between two consecutive increases or between a consecutive degradation and increase. As known, the standard TCP variants are RTT-dependent; in which TCP needs to receive all Acks of the previous cwnd to increase their cwnd by one. Consequently, these TCP variants consume a complete RTT per cycle in order to achieve that increase. Since the operating systems allow their cwnd to be only an integer number, we use the flooring function during the assignment of a new value to the cwnd of the operating system. Thus, the Transmission Rate (Tr) of data at cycle $i$ in epoch $j$ is,

[TABLE]

Differently, Agile-SD is an RTT-independent, which consumes only $\frac{1}{\lambda}{\rm RTT}$ to increase its cwnd by one. Thus, Agile-SD consumes shorter time than the time needed by the RTT-dependent TCP variants to reach the maximum cwnd. In other words, Agile-SD shows shorter epoch time than RTT-dependent TCPs, as shown in Fig.2(a) and Fig.2(b).

In fact, Agile-SD is still subject to the same transmission rate of standard TCP as Equation (6), however, Agile-SD sends only $\frac{w}{\lambda}$ packets in every cycle, where the cycle duration time is only $\frac{\rm RTT}{\lambda}$ seconds. This behavior does not increase the transmission rate per cycle, but it controls the period of transmission time given to every cycle. Thus, it shortens the time given for the cycles with low rates and lengthens the time given to the cycles with high rates, which results in shorter epochs (as in Fig.2(b)) than the RTT-dependent TCP variants (as in Fig.2(a)).

Let us now calculate the transmission rate per epoch, which is equal to the total data sent, in an epoch, over its duration time. Since the data sent at a cycle $i$ is equal to $\frac{\lfloor w_{i}\rfloor}{\lambda_{i}}$ and the duration time of a cycle $i$ is equal to $\frac{\rm RTT}{\lambda_{i}}$, thus, the Epoch Average Transmission Rate (EATrj) is equal to the summation of data sent over all cycles in epoch $j$ divided by the duration time of the epoch cycles, as in Equation (7) below,

[TABLE]

where $n=\frac{\rm TT}{k}$, TT is the total transmission time, $k$ is the number of cycles in epoch $j$, $k=W(1-\beta)$, $\theta$ is the packet size, $w_{0}^{j}$ is the congestion window at the time of reduction of the previous epoch where $w_{0}^{j}=\max(\beta w_{k}^{j-1},\check{w})$, $\lambda_{0}^{j}=\lambda_{\rm max}$, and $\beta$ is the multiplicative decrease factor of TCP.

However, calculating the transmission rate per epoch is not a final target, it is only to be used for calculating the Total Average Transmission Rate (TATr) of a connection. Fundamentally, any connection passes through an $n$ epochs, where every epoch $j$ sends an amount of data equal to $\sum_{i=0}^{k}({\lfloor w_{i}^{j}\rfloor}/{\lambda_{i}^{j}})$ over a duration time equal to $\sum_{i=0}^{k}({\rm RTT}/{\lambda_{i}^{j}})$. Thus, the TATr of a connection can be calculated as the summation of total data sent through the connection over the total duration of its transmission time, as in Equation (8) below,

[TABLE]

I-B Congestion Loss and Random Packet Loss

Assume that packet losses are either congestion loss or random packet loss. Congestion loss happens when the transmission rate attains the maximum capacity $C$ of the bottleneck link or the maximum window size $W$, and it also happens when the buffers are overflowed. As for random packet loss, it can be caused by collision, interference and/or fading, where the random packet loss is subject to the Poisson distribution with rate R [19, 21]. Thus, the probability density function $P_{x}$ for a given congestion window $w$ is:

[TABLE]

where $P_{x}(w)$ is the probability of occurrence of $x$ packet losses in congestion window $w$.

I-C Markov Chain Formulation

Let $\{w_{1},w_{2},\ldots,w_{N}\}$ denote the range of congestion window size, which represents a system with an $N$ states, where $w_{1}=\check{w}$ and $w_{N}=W$, which results in,

[TABLE]

where $W$ and $\check{w}$ are the maximum and minimum allowed congestion window, respectively.

Let $T$ denote the transition probability matrix of the Markov chains for the system of $N$ states, given as,

[TABLE]

where $v[i,j]$ represents the transition probability of the system to move from the $i^{th}$ state to the $j^{th}$ state, where $i,j\in\{1,2,\ldots,N\}$. If the cwnd size is in the $i^{th}$ state, it is denoted by $w_{i}$. This finite set of cwnd sizes corresponds to the Markov Chain with $N$ states.

Let us consider an example of a system with $W=6$ and $\check{w}=2$. Based on Equation (13), the system has only 5 states ($N=5$), where the finite set of the system states is $w_{i}\in\{2,3,4,5,6\}$ where $i\in\{1,2,\ldots,N\}$. Also, let us suppose that $\beta=0.75$. Thus, the transition diagram of the system can be drawn as shown in Fig.3, where the transition probabilities are calculated based on the probability distribution shown in Equation (25) [22, 23] below:

[TABLE]

where $w$ is the congestion window, $v[i,j]$ is the transition probability of the system to move from the $i^{th}$ state to the $j^{th}$ state, and $i,j\in\{1,2,\ldots,N\}$.

Let us now put the probabilities of all represented transitions shown in Fig.3 into their relevant places in the transition matrix $T$. Then, let us fill the unrepresented transitions by zeros. Thus, the resulted transition matrix $T$ will be as shown in Fig.4.

Let $v_{i}$ be the $i^{th}$ row vector in $T$, which represents the probabilities for the system to move from the $i^{th}$ state to all possible N states of the system,

[TABLE]

where every element represents the probability to move from the $i^{th}$ state to one $j^{th}$ state.

From Fig.4, we can see that the $v_{5}$ is a special case, in which the system will transit from $w_{5}$ to $w_{3}$ due to a random loss with $P(w_{5})$ probability or a congestion loss with $(1-P(w_{5}))$. Thus, the total probability will be $P(w_{5})+1-P(w_{5})=1$.

In order to validate the distribution of these probabilities in the matrix $T$, the summation of the probabilities in every row vector must always be equal to one.

[TABLE]

Let $v^{(t)}$ be the probability distribution of the system states at the transition $t$, where $v^{(t)}$ is equal to the product of the previous probability distribution of the system states at the transition $(t-1)$ and the matrix $T$, as follows,

[TABLE]

where $v^{(0)}$ is the initial state, which is the transition probability distribution of system states at the time zero.

Since this model is for the average throughput, we set the initial cwnd of the system to $\lceil\beta W\rceil$, which represents a system in the state of loss degradation at the congestion avoidance stage. Thus, the initial state row vector of the Markov chain is denoted by $v^{(0)}$, in which the probabilities are distributed as below:

[TABLE]

where $j$ is the item index in $v^{(0)}$.

In order to calculate the Average Throughput (ATh) of the system while taking the congestion and random losses into account, we employ Equation (28) into Equation (8) to count all data packets received at the destination over the given connection. Since the source sends $w^{t}$ data at transition $t$ and the destination receives only $(v^{(t-1)}\times T)\times S^{{}^{\prime}}$ data at the same transition, therefor, the ATh can be calculated as in Equation (33) below,

[TABLE]

where $I$ is the number of iterations needed for the system to reach the steady-state, $S^{{}^{\prime}}$ is the transpose of the sample space vector $S$, where $S=[w_{1},w_{2},\ldots,w_{N}]$, and $\lambda^{(t)}$ is the agility factor at $\forall t\in\{1,2,\ldots,\infty\}$, as,

[TABLE]

where $\lambda_{\rm min}$ and $\lambda_{\rm max}$ are system parameters, $\lambda_{\rm min}=1$, $\lambda_{\rm max}>1$, $\lambda^{(t)}\in[\lambda_{\rm min},\lambda_{\rm max}]$.

Indeed, another Markovian model to account for the changing agility factor ($\lambda$) is needed to be integrated with Equation (33) to find the stationary distribution of the system states, by calculating the eigenvector of $T$ with eigenvalue 1. However, the integration of two Markovian models will increase the complexity of the main model and may hinder the process of understanding the model. In order for us to avoid this complexity and since $\lambda^{(t)}$ is easy to be determined at every transition $t$ in the main Markov chain of this model, we account for $\lambda^{(t)}$ using Equation (34) at every cycle in Equation (33). Based on observation, we found that the system starts entering to the steady state after about 4 thousand iterations, however, 10 thousand iterations are used in order to increase the precision of results.

II Performance Evaluation

In this section, we compare the numerical results for both NewReno and Agile-SD to the simulation results in order to confirm the validity of the proposed model. Indeed, our mathematical model is able to represent both NewReno and Agile-SD, where the numerical results of NewReno can be obtained using this model with $\lambda_{\rm max}=1$. Using simulation, we confirmed that Agile-SD would exactly perform like NewReno if $\lambda_{\rm max}$ was set to 1, as shown in Fig.5.

In order to obtain the numerical results, we use Octave version 4.0, which is a major free alternative software to MATLAB. More specifically, we run our model with both $\lambda_{\rm min}$ and $\lambda_{\rm max}$ equal to 1 to obtain the results of NewReno. Thereafter, we run it again with $\lambda_{\rm min}$ and $\lambda_{\rm max}$ equal to 1 and 5, respectively, to obtain the results of Agile-SD. For better understanding, Table I shows the setting of the model.

Further, we present the impact of some parameters, such as buffer size and $\lambda_{\rm max}$, on the epoch time and average throughput of Agile-SD. At the end, an Automated Algorithm Configuration and Parameter Tuning (AACPT) [24] process is exploited to automate the calculation of the optimal $\lambda_{\rm max}$ for a given multiplicative decrease factor $\beta$, instead of configuring it manually by the system administrators as a preset parameter.

II-A Model Validation via Simulation

For simplicity, a node-to-node topology, as shown in Fig.6, is used to validate the results of this mathematical model using NS2 simulator version 2.35. The sender-node (S1) sends an FTP data to the receiver-node (D1) for 100 seconds over a full-duplex TCP connection, in which the bandwidth is 1 Gbps, the two-way propagation delay is 10 milliseconds, and the buffer size in each node is varied from 4 to 128 packets subject to Drop-tail, while the PER is varied from $10^{-8}$ to $10^{-3}$. Furthermore, $\beta$ and $\lambda_{\rm max}$ are set to 0.5 and 5, respectively. In fact, these setting (as shown in Table II) are used to mimic the worst short-distance network configurations, where the buffer sizes are very small and the PERs are very high.

In order to obtain the simulation results shown in Fig.7, where the buffer size is fixed to $4$ packets, we run the simulation for 10 times to calculate the average throughput for every PER. As for the simulation results shown in Fig.8, where the PER is fixed to $10^{-8}$, we also run the simulation for 10 time to calculate the average throughput for every buffer size. Additionally, the numerical results are collected using the proposed model under the same conditions used in the simulations in order to present a fair comparison.

As it is clear in Fig.7, the simulation and mathematical results are very close to each other. However, the mathematical curve slightly diverges from the simulation curve, due to neglecting the slow start phase in our model and also due to the additional processing overhead occur during the simulation. Nevertheless, the results in Fig.7 confirms the validity of this model supported by the results in Fig.8 and Fig.9, which compare between the throughput of Agile-SD and the standard NewReno under different conditions of buffer size and RTT, respectively.

II-B Average Throughput of Agile-SD

As shown in Fig.8, Agile-SD overcomes the standard NewReno in all cases. Nevertheless, both algorithms show the same pattern for a proportional relationship between throughput and buffer size, which supports our assumption in Equation (2). As well as, Agile-SD can perform better than the standard NewReno in most RTT cases, especially when the RTT and the used buffer size are very small, as shown in Fig.9. Since these network characteristics are seen in short-distance and near-zero buffer networks (such as fiber optic networks), thus, the behavior of Agile-SD would be promising for improving TCP performance if such networks are targeted.

II-C The Impact of Agile-SD on Epoch Time

Due to its unique Agility Factor Mechanism (AFM), Agile-SD shows shorter epoch time than the standard NewReno, as shown in Fig.10. This behavior reduces the underutilized area of bandwidth and, in turn, it improves the average throughput of TCP, as shown in Equation (33), where the epoch time is represented by $\frac{\rm RTT}{\lambda}$ at the denominator.

As shown in Fig.11, it is very clear that the epoch time is inversely correlated to the value of $\lambda_{\rm max}$ parameter, while the average throughput is positively correlated to $\lambda_{\rm max}$. Thus, the greater $\lambda_{\rm max}$, the shorter epoch time and the higher average throughput, and vice versa. Hence, it can be deduced that the main player, which directly affects the performance of Agile-SD, is the parameter $\lambda_{\rm max}$. Thus, this parameter $(\lambda_{\rm max})$ must be carefully configured based on the value of $\beta$.

III The AACPT Process

The designers and system users of parameterized algorithms routinely encounter a problem of how to find the optimum configurations or parameter settings to obtain the best possible results. In this section, an AACPT [24] technique is used to find the optimal parameter settings of $\lambda_{\rm max}$ based on a set of problem instances of $\beta$. The optimum value of $\lambda_{\rm max}$ should reflect the minimum setting to obtain the maximum average throughput for a given $\beta$.

Henceforth, $\lambda_{\rm max}$ will be denoted by $\lambda^{\prime}$ for the sake of simplifying the presentation. Let $\overrightarrow{\lambda^{\prime}}$ donate the set of possible configurations of $\lambda^{\prime}$, and let $\overrightarrow{\beta}$ denote the set of problem instances of $\beta$, where $\overrightarrow{\lambda^{\prime}}=[\lambda^{\prime}_{1},\lambda^{\prime}_{2},\ldots,\lambda^{\prime}_{n}]$ and $\overrightarrow{\beta}=[\beta_{1},\beta_{2},\ldots,\beta_{m}]$. Let $\beta\lambda^{\prime}$ be the parameter configuration combination matrix with the size $[m\times n]$, which contains all possible $\beta\lambda^{\prime}_{ij}$ combinations, where $\beta\lambda^{\prime}_{ij}=(\beta_{i},\lambda^{\prime}_{j})$, $\beta_{i}\in\overrightarrow{\beta}$, $\lambda^{\prime}_{j}\in\overrightarrow{\lambda^{\prime}}$, $i\in\{1,2,\ldots,m\}$, and $j\in\{1,2,\ldots,n\}$. Thus, each row $\overrightarrow{\beta\lambda^{\prime}_{i}}$ in $\beta\lambda^{\prime}$ merely denotes the possible $\overrightarrow{\lambda^{\prime}}$ configurations for a given problem instance $\beta_{i}$, as shown in Equation (35),

[TABLE]

Let us now calculate the Average Throughput (AT) of Agile-SD for each configuration combination $\beta\lambda^{\prime}_{ij}$ using Equation (33), where the result is stored into the relevant ATij element in AT, which is an $[m\times n]$ matrix. Let us also track $\lambda^{\prime i}_{\rm opt}$, which is the optimal $\lambda^{\prime}$ configuration in $\overrightarrow{\lambda^{\prime}}$ for a given $\beta_{i}$. Then, let us save every $\lambda^{\prime i}_{\rm opt}$ into the relevant position in the vector of the optimum setting ($\overrightarrow{\lambda^{\prime}_{\rm opt}}$), which is an $[1\times m]$ matrix. For more understanding, Algorithm 1 explains the process of AACPT in detail. Afterward, the AT results matrix of Agile-SD under all possible configurations is drawn as a 3-Dimensional graph, as shown in Fig.12, to show the complete perspective behind this AACPT.

The circled points in Fig.12 reflect the vector of the optimal configurations $(\overrightarrow{\lambda^{\prime}_{\rm opt}})$ for the given $\overrightarrow{\beta}$. For each $\beta_{i}$ in problem instance space $\overrightarrow{\beta}$, the optimal $\lambda^{\prime}$ configuration is $\lambda^{\prime i}_{\rm opt}$ from $\overrightarrow{\lambda^{\prime}_{\rm opt}}$. The 2-Dimensional relationship between the problem instance space $\overrightarrow{\beta}$ and its optimal configuration space $\lambda^{\prime i}_{\rm opt}$, as shown in Fig.13 is directly extracted from Fig.12.

In order to facilitate the process of formulating an equation to fit this relationship, the free on-line tool, namely MyCurveFit [25], is used to find the trend line of the optimal points. Eventually, the employment of MyCurveFit tool produces a simple linear equation, which is able to directly calculate $\lambda^{\prime i}_{\rm opt}$ based on a given $\beta_{i}$, as shown in Equation (36),

[TABLE]

where $m$ is the length of $\overrightarrow{\lambda^{\prime}_{\rm opt}}$, $\beta_{i}\in\overrightarrow{\beta}\text{ and }\lambda^{\prime i}_{\rm opt}\in\overrightarrow{\lambda^{\prime}}$. Fortunately, the result of this equation is identical to the result of the aforementioned AACPT process, as shown in Fig.13.

It is very clear that Equation (36) has the ability to improve the average throughput of Agile-SD compared to NewReno without the need for manually configuring the $\lambda^{\prime}$, as shown in Fig.14. Thus, this equation is highly recommended to be used in Agile-SD since it can automate the calculation of the optimum value of $\lambda^{\prime}$ parameter based on the preset value of $\beta$, where $\beta$ is one of the main parameters in the standard TCP interface. This automation of $\lambda^{\prime}$ increases the scalability of Agile-SD and maximizes its throughput. More importantly, it helps for keeping the standard interface of TCP as it is, which facilitates the implementation of Agile-SD into the real operating systems.

IV Conclusion

In this paper, we propose a mathematical model to calculate the average throughput of Agile-SD and NewReno. This model is designed based on Markov chains, in which the congestion loss and packet error rate are considered. In order to validate the correctness of this model, a number of simulation experiments are carried out, in which the results are compared to the outputs of this model to validate the results presented in [13]. Besides, this model evaluates the average throughput of Agile-SD under different PERs, RTTs, and buffer sizes, in which Agile-SD overcomes NewReno even in the cases of small buffers and short RTTs. Based on this results, Agile-SD could be a promising congestion control algorithm for the short-distance networks, especially that with near-zero buffers such as fiber optic networks.

Also, the proposed model shows that the average throughput is positively correlated to the values of $\beta$ and $\lambda^{\prime}$. Thus, the greater the $\beta$ and $\lambda^{\prime}$, the higher the throughput and vice versa. From the other side, there must be an inverse correlation between $\beta$ and $\lambda^{\prime}$ in order to keep the aggressiveness of Agile-SD balanced. In other words, whenever $\beta$ is increased, $\lambda^{\prime}$ must be decreased and vice versa. For more robustness, an AACPT process is exploited to formulate an equation, which calculates the optimal configuration of $\lambda^{\prime}$ based on a given $\beta$, as in Equation (36). For future work, we plan to implement this equation in Agile-SD to make its interface compatible with the standard TCP interface.

Acknowledgment

This work has been partially supported by the Malaysian Ministry of Education under the Fundamental Research Grant FRGS/1/2014/ICT03/UPM/01/1 for financial support.