^{1}

^{*}

^{2}

^{*}

^{3}

^{*}

The Distributed Queuing (DQ) algorithm is predicted as one of the solutions to the issues currently found in IoT networks over the use of Aloha based algorithms. Since recently, the algorithm has been of interest to many IoT researchers as a replacement of those Aloha variants for channel access. However, previous works analyzed and evaluated the DQ algorithm without any consideration of the stability of its queues, assuming it is stable for any given number of nodes in the network. In this paper, we define the DQ stability condition in a single-channel M2M environment considering a traffic model of periodic and urgent frames from each node in the network. Besides, a steady-state evaluation of the algorithm’s performance metrics is also presented. In general, the DQ algorithm, when it is stable, was observed not to efficiently use the contention slots for the collision resolution. In a single-channel environment, the DQ algorithm is found to outperform the Aloha based algorithms only in an idle-to-saturation scenario.

Massive connectivity is certainly one of the critical challenges in the deployment of the Internet of Things (IoT) networks [

By stability of the DQ algorithm, we aim to define the maximum number of sensors or other nodes allowed contending in an IoT network in the long run, so that the DQ algorithm queues do not grow without bound over time each new contention. The DQ algorithm is stable in the sense that a sensor does not wait for an indefinite time in any of the queues [

In general, the heterogeneity of data from M2M networks have led to a diversity of traffic models in the literature [

In [

The rest of this paper is organized as follows: in Section 2, the system model, together with a brief description of the DQ algorithm, are given. In Section 3, we present the analytical derivation of the stability condition for the DQ algorithm for a network with several applications. Section 4 is dedicated to the steady-state performance analysis of the DQ algorithm, and both analytical and numerical results are presented. Lastly, in Section 5, we give a conclusion and present our future work where a steady-state performance analysis of the DQ algorithm in a multichannel environment will be of interest.

In this section, we describe the system model used to define the stability condition for the DQ algorithm and the evaluation of its steady-state performance metrics. We also present a brief description of the DQ algorithm.

The system model is a star network topology comprised of a base station and n sensors. The sensors are in the vicinity of the base station and can communicate with the network coordinator. We assume that N applications may exist in the network leading to heterogeneous traffic. However, a sensor can only belong to one application. Sensors from the same application, exhibit similar traffic characteristics. Thus, a sensor may be in three different states: normal, alarm, and off. In the normal state, a sensor generates periodic frames at regular ith application time interval T_{i} (with i = 1 , 2 , ⋯ , N ). In contrast, in the alarm state, it generates urgent frames following a Poisson arrival process with an ith application rate of λ_{i}. In the off state, the sensor is in sleep mode and does not generate any frames.

Sensors contend for access to the wireless channel following the rules of the DQ algorithm. The DQ protocol is a tree-splitting algorithm used for channel access. It virtually divides the contending sensors into two different queues. These are the collision resolution queue (CRQ) and the data transmission queue (DTQ). The first queue contains sensors that have not secured a place in the DTQ, and the second queue is for the sensors that are waiting their turn to transmit their data. A DQ frame is divided into two parts (

slots. At the end of DQ frame, active sensors know their position in both the CRQ and the DTQ. A detailed description of the DQ algorithm can be found in [

At the beginning of the contention process, the CRQ and the DTQ are empty. Besides, there are no sensors scheduled for channel access or data transmission. We only consider the up-link channel in our analysis, because the downlink channel is reserved for the base station and is contention-free. Sensors have a perfect slot and contention slot synchronization. Thus, they can contend either in a synchronized or unsynchronized manner per application. In the synchronized scenario, sensors from the same application are scheduled to contend during the same slot at a regular time interval. However, in a massive M2M network, a synchronized scenario is not easy to achieve across a large number of sensors and could lead to a more complex sensor. Therefore, we assume that sensors contend asynchronously. On its incorporation into the network, a sensor from an ith application chooses randomly a slot j for j = 1 , 2 , ⋯ , T i and regularly generates periodic frames at j + T_{i}. k slots for k = 0 , 1 , 2 , ⋯ . Moreover, each frame is assumed to have a timeout period after which it is dropped. A frame is dropped if a new frame is generated before it is sent. The type of the frame defines the timeout period: periodic or urgent. We assume that a sensor requires only one frame for its data transmission. It should also be noted that no sensors enter the CRQ before it is emptied.

In the long run, following the fundamental Palm-Khintchine theorem [_{tot}.

Theorem 1 (Palm-Khintchine Theorem). Let { N j ( t ) , t ≥ 0 } be independent renewal processes for j = 1 , 2 , ⋯ with identically and independent distributed times T j for each renewal process. The superposition N ( t ) = ∑ j = 1 n { N j ( t ) , t ≥ 0 } is asymptotically a Poisson process for n → ∞ , if:

1) Overall load is finite, k = n / ∑ j = 1 n E [ T j ] ,

2) No single process dominates the superposition E [ T j ] ≪ 1 / k .

Let assume that the application time periods are T 1 < T 2 < ⋯ < T N − 1 < T N . Therefore, in the long run for a time interval T_{N}, the total traffic load λ_{tot} from n sensors in a network with N applications is defined by the traffic from both the periodic and urgent frames from all the sensors during that interval of time:

λ t o t = ∑ j = 1 n T N T j + ∑ j = 1 n λ j T N (1)

where T_{j} and λ_{j} are the application period and the rate parameter for the jth sensor. For all j = 1 , 2 , ⋯ , n , we have T_{j} = T_{i} and λ_{j} = λ_{i} if a sensor j belongs to an application i.

The DQ algorithm is comprised of two subsystems: the collision resolution subsystem and the data transmission subsystem. The former deals with frames from sensors trying to get access to the channel. The latter contains frames from sensors waiting for their turn for data transmission. These two subsystems are related in series as two queues in tandem with the first being the CRQ and the second the DTQ. Thus, for the DQ algorithm to be stable, both queues need also to be stable. The DQ algorithm is stable if the algorithm never reaches a point where a frame may wait in the system an infinite time before the complete transmission [

The total waiting time t_{DQ}_{/frame} for any given frame in the DQ system is composed of three components:

t D Q / f r a m e = t w / f r a m e + t c r q / f r a m e + t d t q / f r a m e (2)

where t_{w}_{/frame} is the waiting time before the contention, t_{crq}_{/frame} is the time spent contending in the CRQ, and t_{dtq}_{/frame} is the waiting time in the DTQ. The first two components of the total waiting time in the DQ system are both finite. The upper limit of the waiting time before the contention t_{w}_{/frame} corresponds to the timeout period before a frame is dropped, depending on whether the frame is periodic or urgent. The CRQ waiting time t_{crq}_{/frame} is also stable because once a frame is granted access to the channel, it is assured to secure a place in the DTQ [_{dtq}_{/frame}, it is defined by the number of frames entering and leaving the DTQ. Consequently, the waiting time in the DTQ is stable only if the speed of frames leaving the DTQ is not less than the speed of frames leaving the CRQ. Therefore, only the data transmission subsystem defines the stability of the DQ algorithm [

In

1) when the DQ algorithm is unstable, the length of the DTQ tends to grow linearly with each new contention. Consequently, in the long run, the time each sensor waits in the DTQ increases without bound.

2) when the algorithm is stable, the length of the DTQ is quasi-periodic and does not grow linearly with each new contention; thus, the waiting time in the DTQ is finite.

Let CRQ_{out} be the service rate from the CRQ, DTQ_{in} the arrival rate in the DTQ and DTQ_{out} the service rate from the DTQ. In a single-channel environment, the DQ algorithm can service only one frame during a slot time:

D T Q o u t = 1 (3)

The arrival rate DTQ_{in} in the DTQ corresponds to the CRQ service rate CRQ_{out} because when a frame finishes the channel contention it is sent in the DTQ. Thus, we have:

D T Q i n = C R Q o u t (4)

Therefore, in the long run, the DQ algorithm, in a single-channel network, is stable if and only if the arrival rate in the DTQ (i.e., the service rate from the CRQ) is not longer than the service rate from the DTQ:

C R Q i n < 1 (5)

Following the Equation (1), it can be noted that, in the long run, for a network with n sensors from N applications, the total traffic load corresponds to λ_{tot} for an interval of time T_{N}. In _{out} from the CRQ during the average collision resolution time t_{crq}. The results are obtained through a DQ performance analysis executed in Matlab. The average service rate is evaluated during the collision resolution time for a network with n (n ≥ 2) frames at the initial collision and for m contention slots.

Number of contention slots | t_{crq}, slots | CRQ_{out}, frame/slot |
---|---|---|

m = 3 | 0.91n | 1.10 |

m = 4 | 0.72n | 1.39 |

m = 8 | 0.48n | 2.08 |

m = 12 | 0.41n | 2.44 |

m = 16 | 0.35n | 2.86 |

From _{out} from the CRQ is over a frame per slot when the initial number of contending frames is greater than unity. Therefore, in a single-channel setting, the DQ algorithm is stable if the average initial number of frames contending per CRQ session is not greater than unity.

n c r q < 1 (6)

Let us define n_{x} the average number of frames generated in a slot during the period T_{N}, i.e., the average traffic load. The probability for a sensor choosing a given slot for its periodic or urgent frame during the period T_{N} follows a discrete uniform distribution with the probability mass function:

p = 1 T N (7)

The probability of having x sensors generated during a given slot (X is the corresponding random variable) follows a binomial distribution with parameters p and λ_{tot}:

p x ( X = x ) = ( λ t o t x ) p x q λ t o t − x (8)

where q = 1 − p. The average number of frames n_{x} generated in a slot during the period T_{N} is:

n x = ∑ x = 0 λ t o t x p x = λ t o t T N (9)

Taking into consideration the Equations (6) and (9), in the long run, the stability condition for the DQ algorithm, for a network with n sensors from N different applications and a traffic comprised of periodic and urgent frames from each sensor, is:

v 1 n s , 1 + v 2 n s , 2 + ⋯ + v ( N − 1 ) n s , ( N − 1 ) + v N n s , N < T N (10)

where:

1) v i = T N / T i are constants;

2) T_{i} is the application period for the ith application;

3) n_{s,i} is the total number of frames generated during the period T_{i} for the ith application:

n s , i = n p , i + n u , i (11)

where n_{p,i} and n_{u,i} represent respectively the number of periodic and urgent frames for the ith application.

Therefore, n p , 1 , n p , 2 , ⋯ , n p , ( N − 1 ) and n p , N are the maximum number of sensors in the network from the first, the second, ..., the (N − 1)th and the Nth application before the DQ algorithm is unstable. The number of urgent frames for the ith application is defined as follows:

n u , i = λ i n p , i T i (12)

where λ_{i} is the ith application rate parameter.

Let us consider a network with n sensors from N applications, and sensors from the same application have similar traffic characteristics. As stated earlier, a sensor from an ith application generates periodic frames at regular period T_{i}, and urgent frames following a Poisson arrival process with parameter λ_{i}. Moreover, sensors are unsynchronized because such scenario guarantees a low complex, low cost, low power and small in size sensor.

The DQ algorithm is evaluated under the condition that it is stable following the criterion presented in Equation (10). Therefore, on average, only one sensor is contending at any moment in a given slot in the long run. The condition presented in Equation (6) implies that on average for any type of frame from any application, we have:

{ t w / f r a m e = 0 t c r q / f r a m e = 0 t d t q / f r a m e = 0 a t t e m p t s = 1 (13)

here t_{w}_{/frame}, t_{crq}_{/frame}, t_{dtq}_{/frame}, and attempts are respectively the average waiting time before the contention, the average waiting time in the CRQ, the average waiting time in the DTQ, and the average number of attempts before accessing the channel for any frame in the network. The first three metrics are measured in slots. Thus, a frame is transmitted in the same slot as it is generated as no concurrent sensor tries to access the wireless channel at the same time.

As for the average channel throughput, it is defined through the average number of successful frames accessing the channel during the period T_{N}. A frame is successful if it has been assigned a DQ data slot for its transmission. Therefore, the average number of successful frames is:

T h r o u g h p u t = λ t o t T N (14)

Moreover, as for the contention slots in DQ slot, they are allocated as follows:

{ s C s = 1 e C s = m − 1 c C s = 0 (15)

where sCs, eCs, and cCs are respectively the average number of successful, empty and collided contention slots in a DQ slot. As it can be noticed, an increase in the number of the contention slots m in the DQ slot leads to an inefficient allocation because only the average number of empty contention slots is increased.

In order to validate our analytical results, a steady-state event-driven simulation model has been developed and executed in Matlab for the evaluation of the performance metrics of the DQ algorithm. The sample averages of the considered metrics are obtained over a single replication. We use the method of batch means for the estimation of the throughput because it is less susceptible to the initial effects of the simulation [

In

1) From _{DQ}_{/frame} = 0). The average waiting time in the DQ system for any given frame in the network is obtained as given in Equation (2). It should be noted that for n x = 1 , the overall waiting time in the DQ system is limited by the simulation time; otherwise, it would increase without bound over time.

2) From _{x} tends to unity, the average number of attempts per sensor increases significantly compared to its value when n x < 1 .

3) From _{x} to reach its maximum when n x = 1 .

4) From the

From

In general, the numerical results validate our analytical assumptions. However, as it can be observed, when the average number of frames n_{x} generated during a slot in the network tends to unity, the DQ algorithm begins to be unstable. The average waiting time per frame in the DQ system and the average number of attempts per frame vary significantly from their average values compared to the

case when n x < 1 , whereas the average throughput is at its maximum. Moreover, except for the average distribution of the contention slots, other performance metrics vary slightly with the number of contention slots m.

In a single-channel M2M environment, where sensors are asynchronous in their contention and the traffic model is comprised of periodic and urgent frames, the DQ algorithm behaves like a Time Division Multiple Access (TDMA) algorithm where sensors are allocated frames for transmission randomly. In such a setting, the DQ network performance would be similar to those of Aloha based algorithms in terms of contention resolution. However, in case of an idle-to-saturation scenario in which sensors try to access the channel simultaneously and in a synchronized manner, the DQ algorithm would outperform the Aloha algorithms as the later becomes unstable as the number of contending sensors increases [

In this paper, we have presented a derivation of the stability condition for the DQ algorithm in a single-channel M2M communication environment. Moreover, a steady-state evaluation of the DQ performance metrics has also been conducted when the algorithm is stable. To achieve those goals, we considered a traffic model where each sensor from an ith application generates periodic frames at regular time interval T_{i} and urgent frames following a Poisson arrival process with the rate parameter λ_{i}. It was assumed there are N applications in the network with T 1 < T 2 < ⋯ < T N − 1 < T N and that the sensors are asynchronous in their channel contention. Sensors from the same application were considered to exhibit similar traffic characteristics.

The DQ algorithm is unstable if the DTQ increases without bound over time after each new contention process. Therefore, we found that the maximum number of periodic and urgent frames generated during the period T_{N} from all the applications needs to be less than the Nth application period in the long run. That number was also observed to be independent of the number of contention slots m when the aggregated network traffic from the sensors is considered to be a Poisson process. In a single-channel communication setting, the DQ algorithm is stable only if on average sensors are allowed to contend individually per slot. Therefore, for any type of frame, a sensor requires on average one attempt to get access to the channel and is guaranteed to transmit its frame instantaneously. However, such an environment does not efficiently use the contention slots for the collision resolution. Therefore, in a low power wide area network, the DQ algorithm and the Aloha based algorithms would perform equally. Nevertheless, the DQ protocol outperforms the Aloha algorithms in case of an idle-to-saturation scenario. Additionally, numerical simulations were used to validate the analytical results.

In the future, we plan to perform a steady-state evaluation of the algorithm metrics in a multichannel M2M communication network.

The Pan African University funded this research.

The data used to support the findings of this study are available from the corresponding author upon request.

The authors declare no conflicts of interest regarding the publication of this paper.

Nibitanga, R., Mwangi, E. and Ndung’u, E. (2020) Steady-State Analysis of the Distributed Queueing Algorithm in a Single-Channel M2M Network. Journal of Computer and Communications, 8, 28-40. https://doi.org/10.4236/jcc.2020.89003