Local Voting: Optimal Distributed Node Scheduling Algorithm for Multihop Wireless Networks

TL;DR

This paper introduces Local Voting, a distributed node scheduling algorithm for multihop wireless networks that improves delay and fairness by load balancing, achieving near-optimal performance compared to centralized methods.

Contribution

The paper presents a novel distributed scheduling algorithm, Local Voting, which effectively balances load and enhances performance in multihop wireless networks.

Findings

Local Voting reduces average and maximum delays.

It improves fairness among nodes.

Performance is close to that of an optimal centralized algorithm.

Abstract

An efficient and fair node scheduling is a big challenge in multihop wireless networks. In this work, we propose a distributed node scheduling algorithm, called Local Voting. The idea comes from the finding that the shortest delivery time or delay is obtained when the load is equalized throughout the network. Simulation results demonstrate that Local Voting achieves better performance in terms of average delay, maximum delay, and fairness compared to several representative scheduling algorithms from the literature. Despite being distributed, Local Voting has a very close performance to a centralized algorithm that is considered to have the optimal performance.

Equations

$$X_{t}^{i,s}=\left\{\begin{array}[]{rl}1,&\mbox{ if a slot }s\in S\mbox{ is assigned to a node }i\in N\\ 0,&\mbox{ otherwise}\end{array}\right.$$

$$X_t^{i,s}{X}_t^{j,s}=0,\forall s\in S,i\in N,j\in N_i^{(2)},i\ne j$$

$$\begin{array}{rl}{q}_{t+1}^i& =\max \{0,q_t^i-p_t^i\}+z_{t+1}^i,i\in N,t=0,1,\dots ,\\ p_{t+1}^i& =p_t^i+u_{t+1}^i,\end{array}$$

$$p_t^i/\max \{1,q_t^i\}=p_t^j/\max \{1,q_t^j\},\forall i,j\in N.$$

Full text

I Introduction

Node scheduling algorithms in wireless networks assign each transmission opportunity to a set of nodes in a way that ensures that there is no mutual interference among any transmitting nodes. Some representative algorithms from the literature are DRAND [1], Lyui’s algorithm [2], Load-Based Transmission Scheduling (LoBaTS) [3], and Longest Queue First (LQF) [4]. These algorithms are distributed except LQF, and they have different specifications in terms of traffic and topology dependence.

We propose a distributed, traffic and topology dependent algorithm called Local Voting. This algorithm tries to equalize the load (defined as the ratio of the queue length and the number of allocated slots) through slot reallocation based on local information exchange between neighboring nodes. The number of reallocated slots is determined 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. Local Voting enables nodes with lower load to give slots to nodes with higher load, and, eventually the load between nodes reaches a common value, i.e. consensus is achieved [5].

II Network model and Optimal Strategy

Consider a network of $n$ nodes where $N=\{1,2,\ldots,n\}$ is the set of all wireless nodes that communicate over a shared wireless channel.The channel access follows a paradigm of time division multiple access. Time is divided into frames $t=1,2,\dots$, and each frame is divided into $S$ slots where the duration of a time slot is sufficient to transmit a single packet. There is no spatial movement of the nodes.

The transmission schedule of the network is defined as,

[TABLE]

for $t\geq 1$, with $X^{i,s}_{0}=0$ by convention.

The transmission schedule is conflict-free, if for any $t$,

[TABLE]

where $N_{i}^{(2)}$ denotes the two-hop neighborhood of node $i$, i.e. the set of all nodes that are neighbors to node $i$ or that have a common neighbor with node $i$. If we define $N_{i}^{(1)}$ as one-hop neighborhood of node $i$, there holds $N_{i}^{(1)}\subset N_{i}^{(2)}$.

The objective is to design a load-balancing node scheduling strategy that schedules transmissions such that minimum maximal (minmax) delivery time or delay is achieved.

At any time $t$, the state of each node $i$ is described by:

• •

$q_{t}^{i}$ is the queue length, counted as the number of slots needed to transmit all packets at node $i$ at time $t$;

• •

$p_{t}^{i}$ is the number of slots assigned to node $i$ at time $t$, i.e. $p_{t}^{i}=\sum\limits_{s=1}^{|S|}X_{t}^{i,s}$.

The dynamics of each node is described by

[TABLE]

where $z_{t}^{i}$ is the number of slots needed to transmit new packets received by node $i$ at time $t$, and $u_{t+1}^{i}$ is the number of slots that node $i$ gains or loses at $t+1$ due to the adopted strategy.

Lemma 1** (Optimal strategy)**

*Among all possible options for load balancing, minmax completion time is achieved when *

[TABLE]

III Local Voting Algorithm

Corresponding to the optimal strategy, if we take $x_{t}^{i}=p_{t}^{i}/\max\{1,q_{t}^{i}\}$ as the state of node $i$, then the goal is to keep this ratio equal, i.e. load balancing or $x_{t}^{i}=x_{t}^{j}$ for all $i,j\in N$.

The proposed Local Voting algorithm consists of two main functions: requesting and releasing time slots, and load balancing. For the first function (Fig. 1), nodes are examined sequentially at the beginning of each frame. If the queue of a node is not empty, then the first available slot which is not reserved by one-hop or two-hop neighbors is allocated to the node. If no available slot is found, then no slot is allocated to the node. On the contrary, if the queue is empty and the node has allocated slots, then one of the slots is released.

The load balancing function (Fig. 2) is invoked whenever a node has a non-empty queue and no free slots are available. Each node calculates a value $u_{t}^{i}$ (as explained in [6]), which determines how many slots the node should ideally gain or release by the load balancing function. If a node has a positive $u_{t}^{i}$ value, then it checks if any of its neighbors, which may give a slot to it without causing a conflict, has a $u_{t}^{j}$ value smaller than the $u_{t}^{i}$ value of the requesting node $i$. The neighbor with the smallest $u_{t}^{j}$ value gives a slot to node $i$. After the exchange, $u_{t}^{j}$ is reduced by one, and $u_{t}^{i}$ is recalculated. This procedure is repeated until $u_{t}^{i}$ is not positive, or until none of the neighbors of node $i$ can give slots to node $i$ without causing a conflict.

IV Results and Future Work

Fig. 3 and Fig. 4 demonstrate the minimum and maximum end-to-end delays, respectively. For each connection, 100 equally sized packets are generated at regular intervals (every $5$ slots) at the source and forwarded towards the destination. The source and the destination are chosen randomly. The simulation ends after all traffic has reached its destination. The delay is minimized with Local Voting compared to DRAND [1], Lyui  [2], LoBaTS [3], and LQF [4]. Although, Local Voting is a distributed algorithm, the maximum end-to-end delay is very close to the centralized LQF algorithm. We plan to apply Local Voting in Internet of Things and resource balancing in 5G networks.