Towards Optimal Distributed Node Scheduling in a Multihop Wireless Network through Local Voting

0.69 MB·

by  Dimitrios J. Vergados

1
Towards Optimal Distributed Node Scheduling
in a Multihop Wireless Network through Local
Voting
Dimitrios J. Vergados, Member, IEEE, Natalia Amelina, Member, IEEE,
7 Yuming Jiang, Senior Member, IEEE, Katina Kralevska, Member, IEEE,
1
0
2 and Oleg Granichin, Senior Member, IEEE

n
a
J

1
3

]
I Abstract
N
.
s Inamultihopwirelessnetwork,itiscrucialbutchallengingtoscheduletransmissionsinanefficient
c
[ and fair manner. In this paper, a novel distributed node scheduling algorithm, called Local Voting, is

1
proposed. This algorithm tries to equalize the load (defined as the ratio of the queue length over the
v
0 numberofallocatedslots)throughslotreallocationbasedonlocalinformationexchange.Thealgorithm
1
0 stems from the finding that the shortest delivery time or delay is obtained when the load is equalized
9
0 throughout the network. In addition, we prove that, with Local Voting, the network system converges
.
1 asymptoticallytowardstheoptimalscheduling.Moreover,throughextensivesimulation,theperformance
0
7 of Local Voting is further investigated, in comparison with several representative scheduling algorithms
1
fromtheliterature.Simulationresultsshowthattheproposedalgorithmachievesbetterperformancethan
:
v
i the other distributed algorithms, in terms of average delay, maximum delay, and fairness. Despite being
X
distributed, the performance of Local Voting is also found to be very close to a centralized algorithm
r
a
that is deemed to have the optimal performance.
Index Terms
D.J.VergadosiswiththeSchoolofElectricalandComputerEngineering,NationalTechnicalUniversityofAthenrs,Zografou
GR-15780, Greece. [email protected].
N. Amelina and O. Granichin are with the Faculty of Mathematics and Mechanics, Saint-Petersburg State University, St.
Petersburg, Russia emails {n.amelina, o.granichin}@spbu.ru.
Y. Jiang and K. Kralevska are with the Department of Information Security and Communication Technology, Norwegian
University of Science and Technology (NTNU), Trondheim, N-7491 Norway {jiang, katinak}@item.ntnu.no.
2
Multihop wireless networks, Scheduling algorithm, Wireless mesh networks.
I. INTRODUCTION
Multihop wireless networks are a paradigm in wireless connectivity, which has been used
successfully in a variety of network settings, including ad-hoc networks [1], wireless sensor
networks [2], and wireless mesh networks [3]. In such networks, the wireless devices may
communicate with each other in a peer-to-peer fashion and form a network, where intermediate
wireless nodes may act as routers and forward traffic to other nodes in the network [4].
Due to their many practical advantages and their wide use, there have been a lot of studies
on the performance of multihop wireless networks. For example, the connectivity of a multihop
wireless network has been studied under various channel models in [4], [5]. Furthermore, their
capacityhasbeenstudiedanalyticallyin[6]–[9].Inaddition,thestabilitypropertiesofscheduling
policies for maximum throughput in multihop radio networks have been studied in [10], [11].
Also, a centralized scheduling algorithm that emphasizes on fairness has been proposed in [12].
In [13], the authors focused on the joint scheduling and routing problem with load balancing in
multi-radio, multi-channel and multi-hop wireless mesh networks. They also designed a cross-
layer algorithm by taking into account throughput increase with load balancing. Algorithms for
joint power control, scheduling, and routing have been introduced in [14], [15]. In [16], the
load balancing problem in a dense wireless multihop network is formulated where the authors
presented a general framework for analyzing the traffic load resulting from a given set of paths
and traffic demands.
Some more recent literature works include [17]–[25]. In [17] the authors present the state of
the art in TDMA scheduling for wireless multihop network. Reference [18] proposes Genetic
Algorithm for finding Collision Free Set (GACFS) which is a co-evolutionary genetic algorithm
that solves the Broadcast Scheduling Problem (BSP) in order to optimize the slot assignment
algorithm in WiMAX mesh networks. It is a centralized approach and does not take into
consideration the traffic requirements or the load in the network. Another scheduling solution
for wireless mesh networks based on a memetic algorithm that does not consider the traffic
requirements is presented in [21]. An improved memetic algorithm is applied for energy-
efficient sensor scheduling [26]. Reference [20] investigates the mini-slot scheduling problem
in Time Division Multiple Access (TDMA) based wireless mesh networks, and it proposes a
3
decentralized algorithm for assigning minislots to nodes according to their traffic requirements.
The authors in [19] propose a scheduling scheme for multicast communications where a conflict-
free graph is created dynamically based on each transmission’s destinations. Reference [22]
presents a probabilistic topology transparent model for multicast and broadcast transmissions
in mobile ad-hoc networks. The novelty of the scheme is that instead of guaranteeing that at
least one conflict-free time slot is assigned to each node, it only tries to bring the probability
of successful transmission above a threshold. The authors show that this strategy may increase
the throughput compared with other topology transparent schemes. The authors have further
presented performance improvement for broadcasting in [27]. Another topology transparent
schedulingalgorithmispresentedin[24].Thealgorithmisnottrafficdependent,andtheachieved
throughput is lower than the optimal mainly due to the requirement for a guaranteed slot for
each node. Reference [23] proposes a distributed scheduling scheme for wireless sensor networks
(WSNs). Since it targets WSNs, which typically have low load, it does not consider traffic
requirements. Nevertheless, the authors present in detail the communication protocol that is used
for the distributed scheduling which can be easily adapted to fit network topologies with different
requirements such as wireless mesh networks. Finally, the NP-hardness of the minimum latency
broadcast scheduling problem is proved in [25] under the Signal-to-Interference-plus-Noise-Ratio
(SINR) model. Two distributed deterministic algorithms for global broadcasting based on the
SINR model are presented in [28].
Efficient traffic load balancing and channel access are essential to harness the dense and in-
creasingly heterogeneous deployment of next generation 5G wireless infrastructure [29]. Channel
access in 5G networks faces inherent challenges associated with the current cellular networks
[30],e.g.,fairness,adaptiveratecontrol,resourcereservation,real-timetrafficsupport,scalability,
throughput, and delay. For instance, being able to do frequency and time slot allocation enables
more adaptive and sophisticated multi-domain interference management techniques [31], [32].
In [32], TDMA is used to mitigate the co-tier interference from time domain perspective in
ultra-dense small cell networks. The authors in [33] developed a distributed algorithm for time-
frequency division multiple access to allow an efficient device-to-device (D2D) communication
in ad-hoc manner when network assistance is not available. Moreover, D2D can be viewed as
an offloading technique in ultra-dense 5G networks. The modeling and the optimization of load
balancing plays a crucial role in the resource allocation in the next generation cellular networks
4
[34]. IEEE 802.15.3c is a standard for wireless personal area networks in the mmWave band
that uses TDMA for scheduling [35].
In this paper, we focus on the problem of node scheduling in multihop wireless networks.
In the node scheduling problem, each transmission opportunity is assigned to a set of nodes
in a way that ensures that there will be no mutual interference among any transmitting nodes.
More specifically, under node scheduling, two nodes can be assigned the same time slot (and
transmit simultaneously) if they do not have any common neighbors. We introduce the Local
Voting algorithm. The idea behind the algorithm was originated by the observation that the total
delivery time in a network can be minimized, if the ratio of the queue length over the number
of allocated slots is equalized throughout the network. We call this ratio the load of each node.
The proposed algorithm allows for neighboring nodes to exchange slots in a manner that
eventually equalizes the load in the network. The number of slots that are exchanged is deter-
mined by the relation between the load of each node and its neighbors, under the limitation that
certain slot exchanges are not possible due to interference with other nodes. This algorithm is
the modification of the local voting protocol with non-vanishing to zero step-size which was
suggested in [36]. It belongs to the more general class of stochastic approximation decentralized
algorithms which early have been studied in [37], [38] for decreasing to zero step-size of the
algorithm. However, changing traffic leads to unsteady setting of the optimization problem. For
similar cases the stochastic approximation with constant (or non-vanishing to zero step-size) is
useful [39], [40].
The paper is organized as follows: Section II describes thoroughly the model of the network
that we are considering. Section III presents the proposed Local Voting algorithm, Section III-B
presents an analysis of the performance of the algorithm in terms of achieving consensus, and
the simulation results in Section IV compare the performance of the proposed algorithm with
other algorithms from the literature. Finally, Section V concludes the paper.
II. NETWORK MODEL AND OPTIMAL STRATEGY
Consider a network that can be represented by a graph G = (N,E). N is the set of all wireless
nodes that communicate over a shared wireless channel, i.e. N = {1,2,...,n}. E is the set of
directional but symmetric edges which exist between two nodes if a broadcast from one node
may cause an interference on the other node. We use the terms edges and links interchangeably.
5
The access on the channel is considered to follow a paradigm of time division multiple access.
There is no spatial movement of the nodes.
The scheduling algorithm that is considered is a node scheduling algorithm, i.e. each slot is
allocated to a node, instead of a communication link. A simple protocol interference model is
considered, where two nodes are neighbors as long as their distance is less than the communica-
tion range. The interference range is considered to be equal to the communication range, and both
values are considered constant throughout the network. According to the protocol interference
model, two nodes can be assigned the same transmission slot, with no collision, as long as they
do not have any common neighbors. Otherwise, a collision would happen, resulting in data loss.
Node scheduling tries to guarantee that no such collision will happen.
Each node contains a queue with packets to be transmitted, and the internal scheduling on
the queue is first-come-first-serve. The maximum length of each queue is considered infinite.
Each node also contains a set of slots that have been assigned to it, and neighboring nodes may
exchange slots.
Time is divided into frames, i.e. t = 1,2,.... In addition, each frame is divided into time
slots. The number of time slots in each frame is considered to be fixed, with all time slots having
the same duration. The duration of a time slot is sufficient to transmit a single packet. Let N
denote the set of nodes, and |S| the number of slots in each frame.
The transmission schedule of the network is defined as,

 1, if a slot s ∈ S is assigned to a node i ∈ N;
Xi,s = (1)
t
 0, otherwise.
for t ≥ 1, with Xi,s = 0 by convention.
0
The transmission schedule is conflict-free, if for any t,
Xi,sXj,s = 0,∀s ∈ S,i ∈ N,j ∈ N(2),i (cid:54)= j (2)
t t i
where N(2) denotes the two-hop neighborhood of node i, i.e. the set of all the nodes that are
i
neighbors to node i or that have a common neighbor with node i. If we define N(1) as one-hop
i
neighborhood of node i, there holds N(1) ⊂ N(2).
i i
The objective of this work is to design a load-balancing node scheduling strategy to schedule
nodes’ transmissions such that the minimum maximal (minmax) delivery time or delay is
achieved.
6
For reader’s convenience, we provide a list of the key notation used in this paper.
N Set of nodes in the network
|N| Number of nodes in the network
E Set of directional and symmetric edges between two non-interfering nodes
E Set of edges between nodes that can exchange slots at time t
t
S Set of slots in a frame
|S| Number of slots in a frame
s Elements of the set of slots S
Xi,s Transmission schedule for allocating slot s to node i at time t
t
N(1) Set of one-hop neighbors of node i
i
N(2) Set of two-hop neighbors of node i
i
xi State of node i at time t
t
qi Queue length of node i at time t
t
pi Number of slots assigned to node i at time t
t
zi Number of required slots to transmit new packets received by node i at time t
t
ui Number of slots that node i gains or releases at time t
t
N˜i Set of neighbors that can exchange slots with node i at time t
t
N˜(cid:48) Set of nodes with maximum state values at time t
t
A Adjacency matrix
t
ai,j Weight of edge (j,i) ∈ E
t
G Graph defined by the adjacency matrix A
At t
B Matrix of the local voting protocol
t
bi,j Weight parameter of the local voting protocol
t
E Maximal set of communication links
max
di(A) Weighted in-degree of node i (sum of i-th row of A)
D(A) Diagonal matrix of weighted in-degree of A
L(A) Laplacian matrix of the graph G
A
λ ,...,λ Eigenvalues of the matrix L(A)
1 n
E Mathematical expectation
E Conditional mathematical expectation with respect to the σ-algebra F
Ft t
7
A Adjacency matrix of the averaged system
max
ai,j Average value of ai,j
max t
λ (A ) Second eigenvalue of the matrix A ordered by absolute magnitude
2 max max
A. The Optimal Strategy
At any time t, the state of each node i in the network is described by two characteristics:
• qti is the queue length, counted as the number of slots needed to transmit all packets at node
i at time t;
|S|
• pit is the number of slots assigned to node i at time t, i.e. pit = (cid:80) Xti,s.
s=1
The dynamics of each node is described by
qi = max{0,qi −pi}+zi , i ∈ N, t = 0,1,...,
t+1 t t t+1
(3)
pi = pi +ui ,
t+1 t t+1
where zi is the number of slots needed to transmit new packets received by node i at time t,
t
and ui is the number of time slots that node i gains or loses at time t+1 due to the adopted
t+1
slot scheduling strategy.
Lemma 2.1: Among all possible options for load balancing, the minimum maximal (minmax)
completion time is achieved when
pi/max{1,qi} = pj/max{1,qj}, ∀i,j ∈ N. (4)
t t t t
Proof: We take xi = pi/max{1,qi} as the state of node i. For t = 0, the state of node i is
t t t
xi = 0.
0
The proof will be carried out by contradiction. Assume that for some optimal strategy the
states xi for all i ∈ N at time t are not equal to each other, i.e. there is a node with an index k
t
where k ∈ N, and a subset of nodes N˜ such that xk > xj, ∀j ∈ N˜ .
t t t t
Let N˜(cid:48) be the subset of nodes with a state equal to xk.
t t
Let the difference between the state of the k-th node and the j-th node with the biggest state
value of the nodes in the subset be equal to δ = xk −max xj, and denote
t t j∈N˜t t
(cid:15) = δ max{1,maxqi}/max{1,minqj} (5)
t t t t
i∈N˜t(cid:48) j∈N˜t
where N˜(cid:48) is the subset of nodes with a state equal to xk.
t t
8
We consider a new strategy for load balancing. Reduce controls ui of all |N˜(cid:48)| nodes which
t−1 t
have the maximum state on (cid:15)t (i.e. on (cid:15)t at all) and add (cid:15)t to any of |N˜(cid:48)| nodes controls of
2|N˜(cid:48)| 2 2 t
t
N˜(cid:48). For the new strategy we find that the time of load balancing in the system will be less than
t
the initial on the (cid:15)t , i.e. less than the minimum by the assumption. A contradiction.
2|N˜(cid:48)|
t
III. THE PROPOSED NODE SCHEDULING ALGORITHM: LOCAL VOTING
Corresponding to the optimal strategy, if we take xi = pi/max{1,qi} as the state of node i,
t t t
then the goal of this strategy is essentially to keep this ratio equal, i.e. load balancing or xi = xj
t t
for all i,j ∈ N, throughout the network (as much as possible). In other words, the number
of slots assigned to each node corresponds to the amount of backlogged traffic. A consequent
implication is that, in order to achieve this optimal strategy, we should be able to freely exchange
slots among any two nodes in the network. However, in reality, it is not always possible due to
the potential interference with other nodes in network. That is expressed through eq. (2).
In the following, we propose a novel algorithm that adopts the local voting control strategy.
For the proposed Local Voting algorithm, its consensus properties with respect to the local
balancing or xi = xj are proved in Section III-B. In addition, its performance is evaluated
t t
and compared with several representative node scheduling algorithms proposed in the literature
through simulation results in Section IV.
A. The Proposed Algorithm: Local Voting
The proposed Local Voting algorithm consists of two main functions: requesting and releasing
free time slots, and load balancing.
For the first function (Fig. 1) nodes are examined sequentially at the beginning of each frame.
If a node has a positive backlog (i.e. its queue is not empty), then it is given a time slot. All
time slots are examined sequentially, and the first available time slot that is found, which is not
reserved by one-hopor two-hop neighbors for transmission,is allocated to the node.The message
exchanges for requesting and releasing slots are considered equivalent to message exchanges in
the DRAND algorithm [41]. If no available slot is found (all slots have been allocated to one-hop
or two-hop neighbors of the examined node), then no new slot is allocated to the node. On the
contrary, if the queue of the node is found to be empty and the node has allocated slots, then
one of the slots is released.
9
Are there
For every Is queue no
allocated
yes
node empty?
slots?
no
yes
Is there a yes Allocate Release
free slot? a free slot a slot
no
Load
End
balancing
Fig. 1. Requesting and releasing time slots function for the Local Voting algorithm.
Start
Get a slot from node
(Re)calculate
j, where uj = minuk
ui t t
t k∈Ni
t
yes
yes ∃j ∈ Ni :
t
ui > 0?
t uj < ui?
t t
no
End
no
Fig. 2. Load balancing function for the Local Voting algorithm.
The load balancing function (Fig. 2) is invoked whenever a node has a non-empty queue and
no free slots are available. Every node in the network calculates a value ui (the calculation of ui
t t
10
is explained in the next paragraph), which determines how many slots the node should ideally
gain or lose by the load balancing function. If a node has a positive ui value, then it checks if
t
any of its neighbors, which may give a slot to it without causing a conflict, has a uj value smaller
t
than the ui value of the requesting node i. Note that this is not always the case, because the
t
requesting node may not be able to obtain a slot if one of its other one-hop or two-hop neighbors
has also allocated the same slot. The neighbor with the smallest uj value gives a slot to the
t
current node i. After the exchange uj is reduced by one, and ui is recalculated. This procedure
t t
is repeated until ui is not positive, or until none of the neighbors of node i can give any slots
t
to node i without causing a conflict. In this way, in general, slots are removed from nodes with
lower load and are offered to nodes with higher load, and, eventually the load between nodes
will reach a common value, i.e. consensus will be achieved.
The ui value is calculated as follows: Each node uses its own state xi and the measurements
t t
of its neighbors’ states xj if Ni (cid:54)= ∅.
t t
Denote ai,j = 1 .
t |N˜i|
t
Let us consider the following modification in the already known Local Voting protocol [36]:
(cid:88)
ui = (cid:100)γ bi,j(pj −pi)(cid:101), (6)
t t t t
j∈N˜t
where γ is a constant, bi,j = ai,jmax{1,qti}, and (cid:100)·(cid:101) is a ceiling function (maps a real number to
t t max{1,qj}
t
the smallest following integer).
We set bi,j = 0 for other pairs i,j and denote the matrix of the protocol as B = [bi,j]. Note
t t t
that B can be written as
t
B = Q A Q−1,
t t t t
where Q is a diagonal matrix of the elements max{1,qi} and A is an adjacency matrix. The
t t t
elements ai,j in A are ai,j > 0 if node i can exchange slots with node j and the produced
t t t
schedule remains conflict-free; and ai,j = 0 otherwise.
t
Protocol (6) shows how many slots each node needs based on a comparison between the node’s
state and its neighbors’ states. Note that in the evaluation part of the paper (Section IV) this
protocol is used to define how many slots the node requires, and then the Local Voting algorithm
from Section III is used actually to obtain the required number of slots from the neighbors.
Eventually, node i gains a slot in the following scenarios: