 Research
 Open Access
 Published:
Formal modelling of TCP congestion control mechanisms ECN/RED and SAPLAW in the presence of UDP traffic
EURASIP Journal on Wireless Communications and Networking volume 2016, Article number: 156 (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.
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.
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.
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).
SAPLAW
SAPLAW is a solution proposed in [6] with the specific aim of reducing the problems caused by the simultaneous presence of both TCPbased and UDPbased applications. The basic idea is to find the optimal tradeoff between throughput and time delays by working on a dynamic modification of the TCP flow sending rate, in order to avoid the utilization of the buffer, but at the same time, to guarantee a full utilization of the bandwidth. The key factor is to determine the upper bound for the TCP flow sending rate as a function of the amount of UDP traffic. In this way, we are always sure to reserve enough bandwidth to the realtime applications activity, without limiting too much of the TCP flows. The general formula proposed by Palazzi et al. is
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.
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].
In order to present a selfcontained paper, we summarise the results proposed in [14]. We consider a heterogeneous population of N objects whose states are in the form (c,i), where c∈Γ is the class of the object and i∈{1,…,S _{ c }} is its internal state. At each time epoch, the objects interact with the environment and they can undergo a state transition (in this paper, we do not consider the possibility that an object changes its class). \({X_{n}^{N}}(t)\) indicates the state of the nth object at time slot t, while \(K_{(\textit {\text {c,i}}),(\textit {\text {c,j}})}^{N}(t)\) describes the probability that an object of class c goes from state i to state j during time slot t. The object state transitions depend on the current state of the objects and on the memory \({\vec R}^{N}(t) \in \mathbb {R}^{P}\) where P is the dimension of the vector. \({\vec M}^{N}(t)\) is the occupancy measure, i.e. the row vector where each component \(M^{N}_{\textit {\text {c,i}}}(t)\) is the proportion of objects that are in state (c,i) at time t, i.e.
where 1_{ x=(c,i)}=1 when x=(c,i) and 0 otherwise. If we want to consider the single classes of objects, the proportion of class c objects in state i at time t is \(\frac {1}{p_{c}}M_{\textit {\text {c,i}}}^{N}(t)\), where \(p_{c}=\sum _{i=1}^{S_{c}} M_{\textit {\text {c,i}}}(t)\) at some time slot t. Function g is a deterministic continuous function \(g: \mathbb {R}^{d} \times \mathbb {P}(\varepsilon) \mapsto \mathbb {R}\) such that, for t≥0:
The role of function g is to govern the evolution of the model’s memory. Hence, ∀n we have
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
Assume that the initial occupancy measure \(\vec {M}^{N}(0)\) and memory \(\vec R^{N}(0)\)converge almost surely to deterministic limits \(\vec \mu (0),\vec \rho (0)\) and for t≥0
Then, for any fixed time t, almost surely
Models for ECN/RED and SAP/LAW congestion mechanisms
In this section, we propose different models for the ECN/RED and SAP/LAW congestion mechanisms. Different from other approaches previously addressed by the literature, we consider the following:

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.
The study is done under the mean field regime, where large numbers of users are interacting with each other. Figure 1 gives a conceptual overview of the topology where S1, S2, S3,.... are the stations which are connected with the access point. We assume that there are large number of access points which are handling stations requests and AP is managing congestion issues via the proposed techniques which are modelled.
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.
Since we do not admit class switching during the system activity (TCP connections cannot turn into UDP connections, and vice versa), we define N _{ p } as the number of TCP connections and N _{ u } the number of UDP transmissions, i.e. for all t≥0
where \(\vec X^{N}(t)\) is the stochastic process underlying the model and \({X_{n}^{N}}(t)\) is the state of object n at time t. Clearly, N=N _{ p }+N _{ u }. Let p _{ p } (p _{ u } respectively) be the proportion of TCP (respectively UDP) connections, then we have
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)\).
We now define the memory of the system, \(\vec R^{N}(t)=({R^{N}_{c}}(t), {R^{N}_{p}}(t))\), that consists of a pair of real numbers that represents the normalised population of packets enqueued at the bottleneck at the end of time slot t and t−1, respectively. The update equation is
We approximate the behaviour of the ECN/RED mechanisms as proposed in [13]: as soon as a packet arrives at the bottleneck, it is marked for being discarded or sent. The marking of each packet is independent of the others arriving during the same time slot and cannot be changed. The marking of packets at time slot t depends only on the queue length seen by the packets immediately before their arrival, i.e. on the memory at time t via function \(q(\vec R^{N}(t))\). According to [4], we define function q as follows:
i.e. the probability of discarding a packet grows exponentially with the total queue length. Observe that the marking policy is coherent with that proposed in [16] where the packets are marked according to the queue length that they find at their arrival epoch, while in [14], the queue length after their departure is used. Parameter γ is a positive real number whose value will be specified in the following sections. Finally, the transition matrix for each object is
where \(\vec r=(r_{c},r_{p})\) is a value of \(\vec R^{N}(t),\kappa _{(\textit {\text {u,i}}),(\textit {\text {u,j}})} \in \, [\!0,1]\) and for all i∈ [ 1,I _{ u }], we have
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
If \(\vec M^{N}(0)\) and \(\vec R^{N}(0)\) converge almost surely to \(\vec \mu (0)\) and \(\vec \rho (0)\), respectively, as N→∞, then for any finite horizon t, we have that
almost surely, where \(\vec \mu (t)\) and \(\vec \rho (t)\) are defined by the iterative scheme of Table 1.
Proof.
The proof follows from the fact that Assumption 1 is satisfied and from Theorem 1.
Modelling SAPLAW with UDP traffic and greedy TCP
The SAPLAW is a solution to the problem of congestion at a bottleneck proposed in [6] with the specific aim of reducing the problems caused by the simultaneous presence of both TCPbased and UDPbased applications. The key aspect of this scheme is a manipulation of the TCP acknowledge packets forwarded by the gateway. The idea is to artificially reduce the value of the receiving window size of the destination in the acknowledge packets. Basically, if the ECN/RED uses the TCP congestion detection and resolution algorithm to handle the bottleneck, the SAPLAW uses the flux control algorithm that imposes the sender to use a window which is the minimum between its sending window and the destination’s receiving window (see, e.g. [2]). According to [6], the gateway counts the arrived UDP packets in a time interval and hence estimates the total instantaneous UDP arrival rate at time t,ξ(t). Let NC be the total capacity of the gateway and N _{ p }(t) the number of TCP connections at time t, then the maximum window size which is sent back to the TCP transmitters is the same for all the TCP connections and equal to
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.
The transitions for UDP objects are the same as those shown in Section 4.1. Each TCP connection has a state represented by a pair of numbers \((\textit {\text {i,j}}) \in \mathbb {N}^{2}\), where i denotes the state corresponding to the sender window size s _{ p }(i), while j takes into account the number of received acknowledges. Indeed, the SAPLAW mechanism does not allow the sender to use its full window size and consequently the growth of the sender window size is in generally slower than what would be observed with a gateway with infinite capacity. Formally, the state of each object in our model is \((\ell, \vec x)\) where ℓ∈{p,u} (where p stands for TCP and u for UDP) and
The dynamic of the memory is specified by the following equation:
Function \({S_{u}^{N}}(t)\) is specified as shown in Section 4.1, while \({S_{p}^{N}}\) is defined as
where
and \(\tilde {y}(\vec r_{u})=y(r_{u1}, \ldots, r_{uY})\). Given a state (i,j) of a TCP connection, and the state z corresponding to the maximum sending window obtained by Eq. 14, the following state of the connection is f(i,j,z) defined as follows:
We can now give the mean field limit for N→∞.
Proposition 2
If \(\vec M^{N}(0)\) and R ^{N}(0) converge almost surely to \(\vec \mu (0)\) and \(\vec \rho (0)\), respectively, as N→∞ then for any finite horizon t we have that
almost surely, where \(\vec \mu (t)\) and \(\vec \rho (t)\) are defined by the iterative scheme of Table 2.
Proof.
The proof follows straightforwardly from Theorem 1 after verifying Assumption 1.
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.
The state (i,s) of each TCP object consists of an integer i∈ [ 1,I _{ p }] that denotes the connection state and an integer s∈ [ 1,s _{ p }(I _{ p })+1] that denotes the number of packets that still have to be sent. So the transition probabilities are given by the following equations:
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).
The memory of the system is still a pair of reals \(\vec R^{N}(t)=(R_{c}(t),R_{p}(t))\) that denotes the normalised queue length at the gateway at epoch t and t−1, respectively. The update rule for the memory is
where
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
If \(\vec M^{N}(0)\) and R ^{N}(0) converge almost surely to \(\vec \mu (0)\) and \(\vec \rho (0)\), respectively, and ∀i=1,…,I _{ p }, it holds that \(M_{\textit {\text {p,i,s}}}^{N}(0)/\sum _{s^{\prime }=1}^{s_{p}(I_{p})+1}M_{\textit {\text {p,i,s}}^{\prime }}\) converge almost surely to τ(s), as N→∞, then for any finite horizon t we have that
almost surely, where \(\tilde {\mu }_{\textit {\text {p,i}}}(t),\mu _{\textit {\text {u,i}}}(t)\), and ρ(t) are defined by the iterative scheme of Table 3.
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.
Let \({X^{p}_{i}}(t)\) be the r.v. describing the state of TCP object i at time slot t. The support of \({X^{p}_{i}}(t)\) is [ 1,I _{ p }]×[ 1,S _{ p }(I _{ p })+1]. Let \(X^{p}_{i1}(t)=j\) if and only if \({X^{p}_{i}}(t)=(j,s)\) for s∈ [ 1,S _{ p }(I _{ p })+1] and \(X^{p}_{i2}(t)=s\) if and only if \({X^{p}_{i}}(t)=(j,s)\) for some j∈ [ 1,I _{ p }]. By definition, we have
Notice that r.v. \({X^{p}_{j}}(t)\) are asymptotically independent (the proof is analogue to that of [13, Theorem 1]) and are identically distributed; therefore, for the law of large numbers, we have that for N→∞,μ _{ p,i,s } almost surely converges to \(p_{p}E[\!1_{{X^{p}_{j}}(t)=(\textit {\text {i,s}})}]=p_{p}\mathbb {P}\{{X^{p}_{j}}(t)=(\textit {\text {i,s}})\}\) for some j. Noting that by model definition \(X^{p}_{j1}(t)\) and \(X^{p}_{j2}(t)\) are independent, we have
We now prove the correctness of Eq. 18, the other ones’ proofs follow the same line. By definition of \(\tilde {\mu }_{\textit {\text {p,i}}}(t)\) and by Theorem 1 we have
that by Eq. 19 becomes
Now, Eq. 18 follows after some algebraic simplifications.
Modelling SAPLAW with UDP and temporary TCP connections
The last model we propose considers the SAPLAW mechanism with temporary TCP connections. We start from the basic model of Section 4.2 and maintain the definition of the memory \(\vec R^{N}(t)\) and the transition matrix \(K_{(\textit {\text {u,i}}),(\textit {\text {u,j}})}(\vec r)\) for UDP objects (see the last equation of Eq. 12). The state of an object associated with a TCP connection consists of four components \((p,\vec x,s)\) where p marks the TCP object, \(\vec x\) has the same meaning given in Section 4.2 and s denotes the number of packets that has to be sent. Similar to what we proposed in Section 4.3, we assume that the number of packets sent by a TCP connection before being closed and restarted is geometrically distributed with mean 1/w and hence, by exploiting the memoryless property of geometric random variables (see Proposition 3), we obtain the following transition matrix for TCP objects
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
If \(\vec M^{N}(0)\) and R ^{N}(0) converge almost surely to \(\vec \mu (0)\) and \(\vec \rho (0)\), respectively, and ∀i=1,…,I _{ p }, it holds that \(M_{\textit {\text {p,i,j,s}}}^{N}(0)/\sum _{s^{\prime }=1}^{s_{p}(I_{p})+1}M_{\textit {\text {p,i,j,s}}^{\prime }}\) converge almost surely to τ(s), as N→∞, then for any finite horizon t we have that
almost surely, where \(\tilde {\mu }_{\textit {\text {p,i,j}}}(t),\mu _{\textit {\text {u,i}}}(t)\), and \(\vec \rho (t)\) are defined by the iterative scheme of Table 4 and function h is defined by Eq. 14.
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.
Validation of the model
The models for ECN/RED have been validated using MATLAB which is proposed in [13] by setting p _{ p }=1 and p _{ u }=0. In Fig. 2, we show the convergence to the mean field of the ECN/RED model with increasing number of objects. The parameters for the TCP connections and the gateway used for the simulation are as follows: I _{ p }=100, s _{ p }(i)=10·i, p _{ p }=0.7, C=600, and γ=5·10^{−8}, and function d halves the size of the windows.
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.
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.
Greedy TCP connections and smooth UDP traffic
In this section, we study the models for ECN/RED and SAPLAW under the scenario of greedy TCP connections, i.e. they tend to use all the size of their sending windows, and smooth UDP traffic. The behaviour of each UDP connection is that described in Section 5, but in order to smooth the UDP packet sending, we set the initial state of a connection with uniform probability on the object’s state. The results of the experiment and its parameters are shown in Table 5.
Figure 3 shows the queue length trace for the two ECN/RED models obtained with different values of γ.
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.
Greedy TCP connections and bursty UDP traffic
In this part, we compare the ECN/RED and the SAPLAW congestion control mechanisms under bursty UDP. We still use the models presented in Sections 4.1 and 4.2. In this case, the SAPLAW model shows an instable behaviour that proves that this mechanism alone is not sufficient to safely prevent the congestion in any scenario. The issue raises when the UDP traffic is very bursty and the monitor window is small as in our case. The SAPLAW policy does not take into account the actual queue length but only estimates the instantaneous UDP traffic. Therefore, this parameter must be chosen carefully when implementing this congestion control mechanism. Figure 4 shows the traces of the queue lengths in the ECN/RED and SAPLAW. The graphs have been obtained with the same parameters of the experiment run in Section 6.1 but with all identical UDP objects’ initial states.
Table 6 shows the performance measures for ECN.
It is worthy of notice that the burstiness of the UDP activity strongly deteriorates the performance measures of TCP traffic. In Table 7, we show the behaviour of the two congestion mechanisms under bursty UDP traffic but in stability.
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.
Temporary TCP connections
In this section, we assume that each TCP connection has to send a number of packets modelled by an independent geometric random variable with mean w ^{−1}. After sending this amount of packets, the connection restarts from state 1. The models that are studied have been presented in Sections 4.3 and 4.4. The results of the analysis are shown in Table 8. The table shows that SAPLAW pays a reduction of the throughput because the mechanism is fair in dividing the residual bandwidth among the TCP connections not considering that some of them may be in their initial phase. This does not happen for ECN/RED since it tends to reduce the window size of fast connections and allows the new ones to grow.
This is even more evident when we introduce UDP burstiness. Figures 5 and 6 compare the queue length and the bottleneck’s throughput for different sizes of w. We assume w(ω)=10^{3}2^{ω} and C=300,I _{ p }=100,s _{ p }(i)=10i,I _{ u }=15,s _{ u }=(0,0,…,500,600,500). Notice that for low values of w, ECN/RED shows its benefits in the queue length control policy as discussed above, whereas when w grows, SAPLAW takes advantage of being more aggressive in the bandwidth usage and this compensates the assignment of bandwidth to slow connections.
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.
References
 1
LL Peterson, BS Davie, Computer Networks: A Systems Approach (Elsevier, Amsterdam, Netherlands, 2007).
 2
AS Tanenbaum, Computer Networks (PrenticeHall, New Jersey, USA, 2003).
 3
S Floyd, TCP and Explicit Congestion Notification. SIGCOMM Comput. Commun. Rev. 24(5), 823 (1994).
 4
S Floyd, V Jacobson, Random early detection gateways for congestion avoidance. IEEE/ACM Trans. Netw. 1(4), 397–413 (1995).
 5
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).
 6
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).
 7
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.
 8
S Liu, T Başar, R Srikant, TCPIllinois: A loss and delaybased congestion control algorithm for highspeed networks. Perform. Eval. 65:, 417–440 (2008).
 9
E Altman, K Avrachenkov, C Barakat, in Proc. of SIGMETRICS. TCP in presence of bursty losses (Santa Clara, CA, USA, 2000), pp. 124–133.
 10
T Bonald, M May, JC Bolot, in Proc. of INFOCOM, 3. Analytic evaluation of RED performance (Tel Aviv, Israel, 2000), pp. 1415–1424.
 11
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.
 12
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.
 13
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.
 14
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.
 15
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).
 16
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.
 17
R Srikant, The Mathematics of Internet Congestion Control (Springer, New Delhi, India, 2004).
Author information
Affiliations
Corresponding author
Additional information
Competing interest
The authors declare that they have no competing interests.
Rights and permissions
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.
About this article
Cite this article
Malik, M.H., Jamil, M., Khan, M.N. et al. Formal modelling of TCP congestion control mechanisms ECN/RED and SAPLAW in the presence of UDP traffic. J Wireless Com Network 2016, 156 (2016). https://doi.org/10.1186/s1363801606469
Received:
Accepted:
Published:
Keywords
 Congestion control
 TCP/UDP
 RED/ECN
 Mean field regime
 Formal methods