 Research
 Open Access
Formal modelling of TCP congestion control mechanisms ECN/RED and SAPLAW in the presence of UDP traffic
 Mazhar H. Malik^{1}Email author,
 Mohsin Jamil^{2},
 Muhammad N. Khan^{3} and
 Mubasher H. Malik^{1}
https://doi.org/10.1186/s1363801606469
© Malik et al. 2016
 Received: 13 January 2016
 Accepted: 3 June 2016
 Published: 2 July 2016
Abstract
Congestion avoidance mechanisms are used to prevent the saturation of the gateway which represents a bottleneck of the system. Recently, a new method for the congestion avoidance has been proposed: the smart access point with limited advertised window (SAPLAW). The main idea is to hijack at the gateway the acknowledge packets in the transmission control protocol (TCP) connections in order to artificially reduce the advertised destination window according to some bandwidth allocation policy. Therefore, the flux control mechanism is artificially exploited to control the congestion at the bottleneck. The advantage of this approach is that it does not drop any packet and does not require any modification in the TCP implementations at the clients. While the most popular congestion avoidance mechanisms are the explicit congestion notification (ECN) and the random early detection (RED). In this paper, we propose stochastic models for the ECN/RED and SAPLAW mechanisms in order to compare their performances under different scenarios. The models are studied in mean field regime, i.e. under a great number of TCP connections and UDPbased transmissions. Different from previous work for the ECN/RED, in this paper, we consider the presence of UDP traffic with bursts and the case of not greedy TCP connections. The models for SAPLAW are totally new. The comparison is performed in terms of different performance indices including average queue length, system throughput, and expected waiting time.
Keywords
 Congestion control
 TCP/UDP
 RED/ECN
 Mean field regime
 Formal methods
1 Introduction
The wide use of Internet connectivity in modern communication networks has made the analysis of protocols designed to share one gateway among many devices more and more important. Different from the early usage of the Internet, now, the requirements in terms of bandwidth and responsiveness of many applications are very high and it is often the case that if these requirements are not met, then the application usability is not acceptable. A popular and remarkable example is given by online games whose requirements in terms of response time are very strict. When several devices share the same gateway, we have to address the problem of allocating the resources, i.e. the bandwidth. The mechanisms that are implemented to this end and that we consider in this paper are based on the transport protocols transmission control protocol (TCP) and user datagram protocol (UDP). According to many authors [1, 2], TCP is used mainly for reliable data transfer (including web browsing) and UDP in multimedia traffic or for applications with high requirements on responsiveness such as online gaming (obviously, there are exceptions). The reason why realtime applications usually prefer UDP is that it is a connectionless protocol, and it does not manage the retransmission of lost packets, guaranteeing minimum delays in data arrivals. On the contrary, TCP is a connectionoriented transport service: it provides reliable delivery and high throughput. For this reason, it is particularly adapted for applications whose predominant activity is downloading or uploading of files, as their main requirement is the complete and correct arrival of data.
TCP and UDP do not have an intrinsic mechanism to regulate the bandwidth when a gateway is shared, but the TCP (in its various versions) admits congestion and flux controls, while the UDP does not implement any of them. Every TCP connection keeps track of two window sizes: its own sending window and the destination window size. Congestion control is obtained by allowing the sender window size to increase when packets are properly sent and to decrease when the resources are not enough to satisfy the bandwidth request. Flux control is obtained by choosing a sending rate which is given by the minimum between the sender window size and the destination window size.
Popular approaches that use the builtin congestion mechanism to regulate the TCP transmission rates across a gateway are the random early detection (RED) [3] and the explicit congestion notification (ECN) [4, 5], while the smart access point with limited advertised window (SAPLAW) [6] is based on the flux control mechanism.
The SAPLAW has been presented in the context of integrated home server with shared access point [6]. In fact, due to the rapid evolution in the world of mobile devices, as well as the development of more and more advanced home entertainment systems, ensuring good performances to the applications sharing data with the World Wide Web has become a hard challenge.
In this paper, we study what happens when TCP and UDP are sharing the same link whose congestion is regulated by one of the mechanisms mentioned above: the ECN/RED and the SAPLAW. On one side, the UDPbased flows seem to be aggressive towards the TCPbased ones since UDP does not provide any flux or congestion control mechanism. However, it can be also demonstrated that it is the TCP’s congestion control mechanism which causes serious problems to the critical deterioration of UDPbased applications [6]. This is due to the fact that a queueing waiting time at the gateway is not a problem for TCP connections, whereas it is for UDP whose requirements for a fast response is usually of pivotal importance (e.g. for online gaming). Even if larger and larger bandwidths are offered today also to home consumers, the coexistence of TCP and UDP continues to present problems: due to its congestion control functionality, TCP continuously probes higher transfer rates, queuing packets on the buffer associated with the bottleneck of the connection, and consequently, the packets can be delayed in queue, causing heavy delays for realtime applications. In the literature, we can find different solutions to overcome the problem, and, in particular, different variations of TCP has been proposed, since the UDP is simpler and there are no many variable aspects [7, 8]. A large number of papers have studied the performance of TCP and ECN, see [9–12] as a not exhaustive list, but the main focus is on the behaviour of a single TCP connection under various scenarios. More similar to the analysis carried out here is that proposed in [13] where the authors consider the overall system performance in the mean field limit for ECN/RED. The theoretical results proposed here are then extended in [14]. Starting from these two papers, we extend the considered model in several directions, as discussed later on, and we propose new ones for SAPLAW. Mean field theory (see, e.g. [14–16]) is an important approach to study large stochastic models with a deterministic approximation thus overcoming the wellknown problem of the state space explosion.
The contributions of this paper are the extension of the mean field model presented in [14] in order to encompass the presence of UDP traffic and the introduction of a totally new model to analyse the SAPLAW congestion mechanism. Another novelty is the relaxation of the common assumption [6, 13, 14] that TCP connections are greedy, i.e. they always have packets to send so that the sender window is always completely used at each time slot. We will study models that allows TCP connections to send a geometrically distributed random number of packets and then finish their life cycle. Finally, we use these models to compare the performances of ECN/RED and SAPLAW with presence of UDP traffic. We consider both the cases of bursty and smooth UDP traffic.
The paper is structured as follows. Section 2 explains the ECN/RED and SAPLAW congestion mechanism, and Section 3 gives some background about mean field theory. In Section 4, we introduce our models and give the iterative schemes for the computation of the performance indices. Section 5 briefly discusses the validation of the models, and in Section 6, we compare the performance indices of the two congestion mechanisms under different scenarios. Finally, Section 7 concludes the paper and gives some final remarks.
2 ENC/RED and SAPLAW congestion control mechanisms
In this section, we review the congestion control mechanism that we study in this paper: the ECN/RED and the SAPLAW.
2.1 ECN/RED
ECN [5] is an extension of TCP, which avoids the packet drops due to the channel congestion. This scheme uses random early detection (RED) gateways and marks the packets instead of dropping them, when the queue size is inside a given interval. In particular, it fixes a minimum and a maximum queue threshold: when the number of packets in the queue is less than the minimum, the packets are not marked, when it is between the minimum and the maximum threshold, it marks the packets with a probability that depends on the queue length. Finally, if the number of the packets is larger than the maximum, all arriving packets are marked or dropped. In this paper, we approximate this behaviour by using an exponential law to decide the packet marking probability [17]. The weak point of this strategy is that it does not take in consideration the different requirements of realtime applications, for whom packets arrival delays may have catastrophic effects on the usability (e.g. for video streaming or online gaming).
2.2 SAPLAW
where UDP_{traffic}(t) is the amount of bandwidth occupied by the realtime applications at time t,C is the capacity of the bottleneck link, and #TCP_{flows}(t) is the number of TCP connections at time t.
3 Theoretical background
In order to analyse the performances of the different solutions examined in this paper, we use a model for interacting objects, with individual states and global memory, introduced by Le Boudec et al. in [14].
For each class c, the S _{ c }×S _{ c } matrix \({K^{N}_{c}}(\vec r)\) is the transition matrix for an individual object of class c and may depend on the population N and on the value \(\vec r\) of the global memory. \(K^{N}_{\textit {\text {c,i,c,j}}}\) is the transition probability from state i to state j; therefore, we assume \(K^{N}_{\textit {\text {c,ic,j}}}(\vec r) \geq 0\) and \({\sum }_{j=1}^{S_{c}} K^{N}_{\textit {\text {c,ic,j}}}(\vec r) =1\) for all 1≤i≤S _{ c }. We assume that
Assumption 1
∀c∈Γ,∀i,j∈ε _{ c }, for \(N \rightarrow \infty,K^{N}_{\textit {\text {c,i,c,j}}}(\vec r)\) converges uniformly in \(\vec r\) to some \(K_{\textit {\text {c,i,c,j}}}(\vec r)\), which is a continuous function of \(\vec r\).
A sufficient condition for this assumption to be satisfied is that transition matrix \(K^{N}(\vec r)\) does not depend on the number of objects N and that is continuous on \(\vec r\), which is always the case in our examples.
Theorem 1 has been introduced and proved in [14]. Roughly speaking, it states that as \(N \rightarrow \infty,{\vec M}^{N}(t)\) and \({\vec R}^{N}(t)\) can be replaced by deterministic approximations if the initial state is known. The proof of the correctness of the models that we propose in this paper widely depends on this theorem.
Theorem 1
4 Models for ECN/RED and SAP/LAW congestion mechanisms

The presence of UDP traffic as well as TCP. Specifically, we will be able to model both the case in which UDP traffic is smooth and the case in which it is bursty.

The case in which the TCP connections are not greedy, i.e. in case of an infinite capacity gateway, their windows would not tend to be at their maximum size. In practice, this is a frequent scenario which approximates the situation in which TCP connections are closed and new ones are newly opened maintaining the total number of active connections approximatively constant.
4.1 Modelling ECN/RED with UDP traffic and greedy TCP
In this section, we propose a mean field model for TCP and UDP connections sharing the same gateway. We assume that TCP connections are greedy, i.e. the process associated with the connection fills the entire window with data to be sent at each time slot. We assume the time slot to be a round trip time as in [13, 14].
According to the methodology described in Section 3, we annotate each object with a class c∈{p,u} where p denotes the TCP connections and u the UDP agents. Analogous to [14], each TCP connection has a state \(i \in \mathcal {S}_{p}\), where \(\mathcal {S}_{p}=\{1,\ldots,I_{p}\}\). At state i, the sending rate is \(s_{p}(i) \in \mathbb {N}\) and, without loss of generality, we assume i ^{′}>i ^{′′} ⇒ s _{ p }(i ^{′})>s _{ p }(i ^{′′}). Although UDP transmissions are stateless, we model them by using a probabilistic automaton whose transition probabilities are independent of the rest of the model (in particular of the queue length). This choice allows us to use the automata to model different behaviours of the transmission of a UDP agent, e.g. with smooth or bursty traffic. In practice, the transition probabilities may be decided with a modelfitting approach such as those proposed in [16]. The set of states associated with a process using a UDP transmission is denoted by \(\mathcal {S}_{u}=\{1,\ldots,I_{u}\}\), and the sending rate at state \(i\in \mathcal {S}_{u}\) is s _{ u }(i). Notice that the flexibility of this modelling choice is very high: it allows us to represent synchronised or partially synchronised UDP transmissions (such as those occurring during online gaming), the autocorrelation and the periodicity in the transmission bursts, as well as a simple smooth transmission of packets.
Thus, the state of an object is denoted by a pair (c,i) where c∈{p,u} and i∈{1,…,I _{ p }} if c=p and i∈{1,…,I _{ u }} otherwise. To avoid trivialities, we assume I _{ p }>1 and I _{ u }≥1.
Let \(N\in \mathbb {N}\) be the number of objects and \(C\in \mathbb {R}\) the bottleneck capacity for every connection.
where M _{ c,i } is the occupancy vector defined in Section 3. The proportion of TCP connections in state i at time t is then \(p_{p}^{1}M^{N}_{\textit {\text {p,i}}}(t)\) and, for UDP, we have \(p_{u}^{1}M^{N}_{\textit {\text {u,i}}}(t)\). The average normalised sending rate of TCP connections at time t is hence \({S^{N}_{p}}(t) = \sum _{i}^{I_{p}} s_{p}(i)M^{N}_{\textit {\text {p,i}}}(t)\), while for UDP, connection it is \({S^{N}_{u}}(t) = \sum _{i}^{I_{u}} s_{u}(i)M^{N}_{\textit {\text {u,i}}}(t)\).
Function d(i) is used to model the destination state in case of a marked packet. We may have d(i)=1 for all i or as in [15] d(i)=⌊i/2⌋ (and the number of packets sent s _{ p }(i) is proportional to i). Generally speaking, we require that d(i)=i only for i=1, while for i>1, we have that d(i)<i.
Remark 1
We observe that the proposed model for ECN/RED is novel with respect to the one proposed in [15] since it takes into account different classes of traffic, not only TCP. In [14], the authors propose a solution for different types of TCP connection. However, in their model, the ECN/RED mechanism is modelled in a simpler and less accurate way than what is proposed here: in fact, in [14], the probability of a TCP connection to reduce its window size depends only on the queue length, i.e. is the same for connections with a large and already small windows. We consider our approach more accurate since it takes into account that a TCP connection with a large window sends more packets than one with a small window and hence has higher probability to be selected for being slowed down.
Proposition 1
Iteration system for ECN/RED model with greedy TCP connections
\(\phantom {\dot {i}\!}\mu _{\textit {\text {p,i}}}(t+1)=(1q(\rho _{p}(t)))^{s_{p}(i1)}\mu _{\textit {\text {p,i}}1}(t)1_{\{i>1\}}\) 
\(+\sum \limits _{j:d(j)=i}\left (1(1q(\rho _{p}(t)))^{s_{p}(j)}\right)\mu _{p,j}(t)\quad 1<i<I_{p}\) 
\(\mu _{\textit {\text {p,I}}_{p}}(t+1)=(\!1\!q(\rho _{p}(t)))^{s_{p}(I_{p}1)}\!\mu _{\textit {\text {p,I}}_{p}1}(t) +(1q(\rho _{p}(t)))^{s_{p}(I_{p})}\mu _{\textit {\text {p,I}}_{p}}(t)\) 
\(\mu _{\textit {\text {u,i}}}(t+1)=\sum \limits _{j=1}^{I_{u}}\kappa _{(\textit {\text {u,j}}),(\textit {\text {u,i}})}\mu _{\textit {\text {u,j}}}(t)\) 
\(\sigma _{p}(t+1)=\sum \limits _{i=1}^{I_{p}}\mu _{\textit {\text {p,i}}}(t+1)s_{p}(i)\quad \quad \sigma _{u}(t+1)=\sum \limits _{i=1}^{I_{u}}\mu _{\textit {\text {u,i}}}(t+1)s_{u}(i)\) 
ρ _{ c }(t+1)= max (ρ _{ p }(t) + σ _{ p }(t + 1) + σ _{ u }(t + 1) − C, 0) ρ _{ p }(t+1)=ρ _{ c }(t) 
Proof.
The proof follows from the fact that Assumption 1 is satisfied and from Theorem 1.
4.2 Modelling SAPLAW with UDP traffic and greedy TCP
In our setting, we assume N _{ p }(t)=N _{ p },N=N _{ p }+N _{ u }, and the time interval that we use to estimates the instantaneous arrival rate for the UDP packets to be equal to a multiple Ys of the round trip time, i.e. \(\xi (t)=y({S^{N}_{u}}(tY),\ldots {S^{N}_{u}}(t1))\). The notation, unless differently specified, is that of Section 4.1. The packets sent by each TCP connection at each time slot depends on its state and on Eq. 13 and the granularity of the model. For the sake of simplicity, we assume that s _{ p }(i)=α i for some \(\alpha \in \mathbb {N}\), i.e. the maximum number of packets sent in a time slot by a TCP connection grows linearly with the state numbering. The memory \(\vec R^{N}(t)=({R_{c}^{N}}(t),{R_{p}^{N}}(t),\vec {R_{u}^{N}}(t))\) is a pair of real numbers (r _{ c },r _{ p }) followed by a vector of reals \(\vec r_{u}\) where r _{ c } denotes the normalised queue length at the bottleneck (counting both TCP and UDP packets) at a given time slot, r _{ p } is the normalised queue length at the previous time slot, and \(\vec r_{u}=(r_{u0},\ldots,r_{uY})\) denotes the normalised counting of the arrived UDP packets at the latest (Y+1)>1 time slots.
We can now give the mean field limit for N→∞.
Proposition 2
Iteration system for SAPLAW model with greedy TCP connections
\(\mu _{\textit {\text {p,i,j}}}(t+1)=\sum _{i^{\prime }=1}^{I_{p}} \sum _{j^{\prime }=0}^{i1}\mu _{\textit {\text {p,i}}^{\prime },j^{\prime }}(t)1_{f(i^{\prime },j^{\prime },h(\vec \rho _{u}(t)))=(\textit {\text {i,j}})}\) 
\(\mu _{\textit {\text {u,i}}}(t+1)=\sum _{j=1}^{I_{u}}\kappa _{(\textit {\text {u,j}}),(\textit {\text {u,i}})}\mu _{\textit {\text {u,j}}}(t)\) 
\(\sigma _{p}(t+1)=\sum _{i=1}^{I_{p}}\sum _{j=1}^{i1}\mu _{\textit {\text {p,i,j}}}(t+1)\min (s_{p}(i),s_{p}(h(\vec \rho _{u}(t))))\) 
\(\quad \quad \quad \quad \quad \times \sigma _{u}(t+1)=\sum _{i=1}^{I_{u}}\mu _{\textit {\text {u,i}}}(t+1)s_{u}(i)\) 
ρ _{ c }(t+1)= max(ρ _{ c }(t)+σ _{ p }(t+1)+σ _{ u }(t+1)−C,0) 
ρ _{ p }(t+1)=ρ _{ c }(t)ρ _{ ui }(t+1)=ρ _{ u(i−1)}(t),1≤i≤Y ρ _{ u0}(t+1)=σ _{ u }(t+1) 
Proof.
The proof follows straightforwardly from Theorem 1 after verifying Assumption 1.
4.3 Modelling ECN/RED with UDP and temporary TCP connections
When comparing the SAPLAW and the ECN/RED congestion mechanisms, we should take into account that the former tends to work better when the TCP sending windows are very large. Intuitively, if all the TCP connections are willing to send an infinite queue of packets, then the SAPLAW allows them to constantly increase their sending window (possibly slower that what happens in ECN/RED). In the long run, all the windows will be at their maximum size and the SAPLAW decides which actual rate they can send according to the estimated UDP traffic. However, the SAPLAW is fair with respect to the distribution of the bandwidth to each TCP connection as shown by Eq. 13; therefore, it may happen that part of the bandwidth is allocated to a TCP connection whose sending window is still small causing a waste of the resources.
In this and in the following section, we modify the previous models in order to take into account that a TCP connection has a random amount of packets to send. Once they are sent, we assume that the connection is closed and a new one restarts from the minimum window size.
We assume that once the connection is established, it has to send an amount of packets which is geometrically distributed with parameter w∈(0,1), i.e. the probability of sending exactly ξ packets is w(1−w)^{ ξ−1}, with an expected value of 1/w. We modify the model presented in Section 4.1 in order to take into account this aspect as follows (when not differently specified, the notation is inherited by the previous sections). Let L _{ f }(t) for 1≤f≤N _{ p } and t≥0 be a set of independent and identically distributed geometric random variables with parameter w∈(0,1) that represent the number of packets that TCP connection i has still to send at time t. The event of closure of TCP connection f occurs at time t _{0} if the number of packets that it sends at t _{0} is equal to L _{ f }(t _{0}). Notice that due to the memoryless property of the geometric random variable, the distribution of the number of packets sent by a TCP connection from its opening to its closing epoch is still geometric.
Notice that Eq. 17 is the key point to decide when a TCP connection finishes its transmission and a new one is created. Function τ is the density function of a truncated geometric random variable (r.v.), where the probability mass of outcomes greater that s _{ p }(I _{ p }) is concentrated in the last state, s _{ p }(I _{ p })+1.
Proposition 3
The number of packets which are sent from two consecutive observations of the transition given by Eq. 17 is geometrically distributed with mean 1/w.
Proof.
The proof follows from the memoryless property of the geometric random variable and by the observation that the transition described by Eq. 17 occurs with probability 1 from each state (i,s) such that s≤s _{ p }(i).
Proposition 4 states the mean field approximation for this model. Notice that the state space of each TCP object is rather large but we are interested only in the normalised population of a connection state, i.e., \(\tilde {\mu }_{\textit {\text {p,i}}}(t)=\sum _{s=1}^{s_{p}(I_{p})+1}\mu _{p,j,s}(t)\).
Proposition 4
Iteration system for ECN/RED model with temporary TCP connections
\(\hspace {16pt}\tilde {\mu }_{p,1}(t+1)=\sum _{j:d(j)=1}\left (1(1q(\rho _{p}(t)))^{s_{p}(j)}\right)\tilde {\mu }_{j}(t) (1w)^{s_{p}(j)}\) 
\(\qquad \qquad + \sum _{j=1}^{I_{p}} \tilde {\mu }_{p,j}(t) (1(1w)^{s_{p}(j)})~~~~~~~~~~~~~~~(18) \) 
\(\tilde {\mu }_{\textit {\text {p,i}}}(t+1)=\sum _{j:d(j)=i}\left (1(1q(\rho _{p}(t)))^{s_{p}(j)}\right)\tilde {\mu }_{j}(t) (1w)^{s_{p}(j)} \) 
\(~~~~~~~~~~+(1q(\rho _{p}(t)))^{s_{p}(i1)}\tilde {\mu }_{\textit {\text {p,i}}1}(t) (1w)^{s_{p}(i1)} \quad 1<i<I_{p} \) 
\(\tilde {\mu }_{\textit {\text {p,I}}_{p}}(t+1)=(1q(\rho _{p}(t)))^{s_{p}(I_{p}1)}\tilde {\mu }_{\textit {\text {p,I}}_{p}1}(t) (1w)^{s_{p}(I_{p}1)} \) 
\(\quad \qquad \quad + (1q(\rho _{p}(t)))^{s_{p}(I_{p})}\tilde {\mu }_{\textit {\text {p,I}}_{p}}(t) (1w)^{s_{p}(I_{p})} \) 
\(\mu _{\textit {\text {u,i}}}(t+1)=\sum _{j=1}^{I_{u}}\kappa _{(\textit {\text {u,j}}),(\textit {\text {u,i}})}\mu _{\textit {\text {u,j}}}(t) \) 
\(\sigma _{p}(t+1)=\sum _{i=1}^{I_{p}} \tilde {\mu }_{\textit {\text {p,i}}}(t+1) \frac {1\,\,(1\,\,w)^{s_{p}(i)}}{w} \quad \quad \sigma _{u}(t+1)\,=\,\sum _{i=1}^{I_{u}}\mu _{\textit {\text {u,i}}}(t+1)s_{u}(i) \) 
ρ _{ c }(t+1)= max(ρ _{ c }(t)+σ _{ p }(t+1)+σ _{ u }(t+1)−C,0) 
ρ _{ p }(t+1)=ρ _{ c }(t) ρ _{ up }(t+1)=ρ _{ uc }(t),i>0 ρ _{ uc }(t+1)=σ _{ u }(t+1) 
Notice that Theorem 1 is applicable to obtain the mean field approximation for \(\vec \mu \); however, the number of states of each component may grow very quickly and make the computation of the iterative model inefficient. In order to derive the interesting performance indices, we can use the iterative scheme of Table 3 which aggregates the TCP object states that share the same window size. We now prove its correctness.
Proof.
Now, Eq. 18 follows after some algebraic simplifications.
4.4 Modelling SAPLAW with UDP and temporary TCP connections
where \(\vec r=(r_{p}, r_{c}, r_{u0}, \vec r_{u})= (r_{p}, r_{c}, r_{u0}, r_{u1}, \ldots, r_{uY})\) is a value of the memory at a certain time slot, τ(s ^{′}) is defined in Eq. 16, and f(i,j,z) in Eq. 15. We can now state the mean field result that, similar to that proposed by Proposition (4) gives an iterative scheme whose computation is more efficient than that straightforwardly obtained by the application of Theorem 1 since it considers an aggregation of states for the TCP objects.
Proposition 5
Iteration system for ECN/RED model with temporary TCP connections
\(\tilde {\mu }_{p,1,1}(t+1)=\sum _{i^{\prime }=1}^{I_{p}}\sum _{j^{\prime }=1}^{i} \tilde {\mu }_{\textit {\text {p,i}}^{\prime },j^{\prime }}(t)\left (1(1w)^{\min (s_{p}(i^{\prime }),s_{p}(h(\vec \rho _{u}(t))))}\right) \) 
\(\tilde {\mu }_{\textit {\text {p,i,j}}}(t+1)= \sum _{i^{\prime }=1}^{I_{p}}\sum _{j^{\prime }=1}^{i}\tilde {\mu }_{\textit {\text {p,i}}^{\prime },j^{\prime }}(t)1_{f(i^{\prime },j^{\prime },h(\vec \rho _{u}(t)))=(\textit {\text {i,j}})} (1w)^{\min (s_{p}(i^{\prime }),s_{p}(h(\vec \rho _{u}(t))))} \) 
\(\sigma _{p}(t+1)=\sum _{i=1}^{I_{p}} \tilde {\mu }_{\textit {\text {p,i,j}}}(t+1) \frac {1(1w)^{\min (s_{p}(i),s_{p}(h(\vec \rho _{u}(t))))}}{w} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~(20) \) 
\(\quad \qquad \times \sigma _{u}(t+1)=\sum _{i=1}^{I_{u}}\mu _{\textit {\text {u,i}}}(t+1)s_{u}(i) \) 
ρ _{ c }(t+1)= max(ρ _{ c }(t)+σ _{ p }(t+1)+σ _{ u }(t+1)−C,0) 
ρ _{ p }(t+1)=ρ _{ c }(t) ρ _{ up }(t+1)=ρ _{ uc }(t),i>0 ρ _{ uc }(t+1)=σ _{ u }(t+1) 
Remark 2
Notice that there are some equivalence relations among the models specified in this section. Specifically, the ECN/RED, with greedy or temporary TCP connections is equivalent to the corresponding SAPLAW model when C≥ max{s _{ p }(i),1≤i≤I _{ p }}∪{s _{ u }(j),1≤j≤I _{ u }}. In fact, in this case, none of the two congestion mechanisms is applied and hence, the gateway is not a bottleneck for the system. Another interesting relation is that the model presented in Section 4.1 (Section 4.2) can be derived as the limit for w→0^{+} of the model presented in Section 4.3 (Section 4.4). In fact, when w is very small, the amount of data that each TCP connection sends is so high that its behaviour resembles the one of a greedy connection. Nevertheless, we think that having presented and described the four models should have helped the clarity of the exposition.
5 Validation of the model
We assume a bursty behaviour of UDP traffic. We model the state of each UDP object as a periodic DTMC consisting of I _{ u }=15 such that κ _{(u i),(u,i+1)}=1 for 1≤i<I _{ u }, and \(\phantom {\dot {i}\!}\kappa _{(u,I_{u}),(u,1)}=1\). Vector s _{ u }(i)=(0,…,700,800,700). The initial state of the TCP connections is chosen with uniform probability between 1 and I _{ p }, while all the UDP objects start from state 1. Figure 2 shows a comparison between the mean field limit and a simulation trace obtained with different numbers of objects in terms of normalised queue length. Notice the effects of the periodic bursts on the queue length and the reaction of the ECN/RED mechanism to contain the queue length.
Analogously, the SAPLAW mean field model has been validated against simulation.
6 Performance evaluation
In this section, we use the mean field models presented in Section 4 to compare the ECN/RED and the SAPLAW mechanisms in terms of expected queue length Q (expressed in normalised number of packets) and system’s throughput T (expressed in normalised sent packets per time slot). Assuming that no packet is discarded, i.e. the control mechanism for ECN/RED is performed by sending notification packets rather than by discarding some random packets, we also indirectly derive the expected waiting time using Little’s law W=Q/T (expressed in time slots) and assuming a simulation time horizon long enough to stabilise these values. Notice that W denotes the expected number of time slots that a packet has to wait in the queue before being sent. In all the models of our experiments, we use for SAPLAW Y=1 and function \(\tilde {y}\) is the identity, i.e., we use a time window of one round trip time to estimate the UDP traffic. Function d(i) for ECN/RED simply halves the size of the current window. The percentage of TCP objects is 70 % of the total. The finite horizon is fixed at 800 time slots.
6.1 Greedy TCP connections and smooth UDP traffic
Comparison of ECN/RED with SAPLAW under greedy TCP and smooth UDP. Parameters: I _{ p }=100,I _{ u }=10,s _{ p }(i)=10∗i, and C=600s _{ u }=(0,…,1000,3000,1000)
SAPLAW  ECN γ=5E−6  ECN γ=5E−7  

T  591.27  585.69  594.23 
Q  0  5.73  53.72 
W  0  0.098  0.0901 
This scenario is ideal especially for the SAPLAW mechanism. In fact, the smoothness of the UDP traffic (in the limit, it tends to become constant) allows the gateway to accurately predict the bandwidth to reserve for UDP. On the other hand, the greedy behaviour of TCP connections prevents the SAPLAW mechanism to overestimate the bandwidth needed by each connection since, after some time, all the sending windows will be opened at their maximum sizes. For this reason, in this ideal scenario, SAPLAW gives the best performances by obtaining a high throughput with no waiting time.
6.2 Greedy TCP connections and bursty UDP traffic
Comparison of ECN/RED with SAPLAW under greedy TCP and bursty UDP. Parameters: I _{ p }=100,I _{ u }=10,s _{ p }(i)=10∗i, and C=600s _{ u }=(0,…,1000,3000,1000)
SAPLAW  ECN γ=5E−6  ECN 5E−7  

T  n/a  276.00  428.85 
Q  n/a  64.52  155.34 
W  n/a  0.234  0.3622 
Comparison of ECN/RED with SAPLAW under greedy TCP and bursty UDP. Parameters: I _{ p }=100,I _{ u }=10,s _{ p }(i)=10∗i, and C=800s _{ u }=(0,…,1000,3000,1000)
SAPLAW  ECN γ=5·^{1}0−6  ECN γ=5·10^{−7}  

T  713.27  333.29  529.4077 
Q  153.95  35.20  83.79 
W  0.2000  0.1056  0.1583 
We can see that although the throughput of SAPLAW is much higher than that of ECN, also the queue length tends to be higher, so reducing the benefits that we observed in the scenario with smooth UDP.
6.3 Temporary TCP connections
Comparison of ECN/RED with SAPLAW under greedy TCP and smooth UDP traffic. Parameters: I _{ p }=100,I _{ u }=10,s _{ p }(i)=10∗i, and C=800s _{ u }=(0,…,1000,3000,1000),w=10^{4}
SAPLAW  ECN γ=5E−6  ECN γ=5E−7  

T  219.17  300.06  295.50 
Q  0.2160  361.1346  39.335 
W  0.85E−4  1.2035  0.133 
7 Conclusions
In this paper, we have compared the performances of two mechanisms for the congestion control at a shared gateway in a TCP/IPbased network: the ECN/RED and the SAPLAW. The comparison is performed assuming a large number of TCP and UDP transmissions and considering two different behaviours for the TCP connections (greedy or temporary) and for the UDP traffic (smooth or bursty). We showed that the SAPLAW gives better performances (in terms of expected queue length and throughput) than ECN/RED in case of greedy TCP connections and smooth UDP traffic. When the first condition is violated, SAPLAW shows worse performances because it allocates part of the available bandwidth to TCP connections that are in their initial phases. The impact of burstiness on SAPLAW can be dangerous: we showed that a wrong choice of the time interval used to estimate the intensity of the UDP traffic may lead to instability. As concerns the ECN/RED mechanism, the performances of its congestion control mechanism are not affected by temporary TCP connections since when a potential congestion is detected, the fastest TCP connections are with the highest probability are slowed down. On the other hand, the impact of burstiness on the UDP traffic can strongly reduce the throughput. This happens because during the peak of UDP traffic, the ECN/RED marks the packets with high probability thus reducing the associated connections’ window size and does not take into account that the burst is a shorttime phenomenon (if there where only TCP connections, it would be correct to expect that a high queue length at time t is followed by a worse situation at time t+1 if countermeasures are not adopted). It is worthy of mentioning that the mean field analysis supports the fast simulation that allows to study the detailed performance indices associated with a single object in the mean field regime in a very efficient way.
Declarations
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
Authors’ Affiliations
References
 LL Peterson, BS Davie, Computer Networks: A Systems Approach (Elsevier, Amsterdam, Netherlands, 2007).MATHGoogle Scholar
 AS Tanenbaum, Computer Networks (PrenticeHall, New Jersey, USA, 2003).MATHGoogle Scholar
 S Floyd, TCP and Explicit Congestion Notification. SIGCOMM Comput. Commun. Rev. 24(5), 823 (1994).MathSciNetView ArticleGoogle Scholar
 S Floyd, V Jacobson, Random early detection gateways for congestion avoidance. IEEE/ACM Trans. Netw. 1(4), 397–413 (1995).View ArticleGoogle Scholar
 I Han, HS Park, YK Jeong, KR Park, An integrated home server for communication, broadcast reception, and home automation. IEEE Trans. Consumer Electron. 52(1), 104–109 (2006).View ArticleGoogle Scholar
 CE Palazzi, S Ferretti, M Roccetti Pau, What’s in that magic box? The Home Entertainment Center’s special protocol potion, revealed. IEEE Trans. Consumer Electron. 52(4), 1280–1288 (2006).View ArticleGoogle Scholar
 M Jeonghoon, R La, V Anantharam Walrand, in Proc. of INFOCOM 1999, 3. Analysis and comparison of TCP Reno and Vegas (New York, USA, 1999), pp. 1556–1563.Google Scholar
 S Liu, T Başar, R Srikant, TCPIllinois: A loss and delaybased congestion control algorithm for highspeed networks. Perform. Eval. 65:, 417–440 (2008).View ArticleGoogle Scholar
 E Altman, K Avrachenkov, C Barakat, in Proc. of SIGMETRICS. TCP in presence of bursty losses (Santa Clara, CA, USA, 2000), pp. 124–133.Google Scholar
 T Bonald, M May, JC Bolot, in Proc. of INFOCOM, 3. Analytic evaluation of RED performance (Tel Aviv, Israel, 2000), pp. 1415–1424.Google Scholar
 W Kang, F Kelly, NH Lee, RRJ Williams, in Proc. of CDC 2004, 4. Fluid and Brownian approximations for an Internet congestion control model (Atlantis Paradise Island Bahamas, 2004), pp. 3938–3943.Google Scholar
 MH Malik, M Aydin, Z Shah, S Hussain, in Industrial Electronics and Applications (ICIEA) 2014 IEEE 9th Conference on. Stochastic model of TCP and UDP traffic in IEEE 802.11 b/g (IEEEHangzhou, China, 2014), pp. 2170–2175.View ArticleGoogle Scholar
 P Tinnakornsrisuphap, A Makowski, in Proc. of INFOCOM 2003, 2. Limit behavior of ECN/RED gateways under a large number of TCP flows (San Francisco California, USA, 2003), pp. 873–883.Google Scholar
 JY Le Boudec, D McDonald, J Mundinger, in Proc. of QEST 2007. A generic mean field convergence result for systems of interacting objects (IEEEEdinburgh, Scotland, 2007), pp. 3–18.Google Scholar
 F Baccelli, M Lelarge, D McDonald, in 42nd Annual Allerton Conference on Communication Control, and Computing. Mestable regimes for multiplexed TCP flows (University of Illinois at UrbanaChampaign, 2004).Google Scholar
 A Bobbio, M Gribaudo, M Telek, in Proc. of QEST 2008. Analysis of large scale interacting systems by mean field method (St Malo, France, 2008), pp. 215–224.Google Scholar
 R Srikant, The Mathematics of Internet Congestion Control (Springer, New Delhi, India, 2004).View ArticleMATHGoogle Scholar