Parallel LEACH Algorithm for Wireless Sensor Networks

Yi Zhu1, Qingmei Yao1, Glover George2, Shaoen Wu2, and Chaoyang Zhang2

School of Computing, University of Southern Mississippi, Hattiesburg, MS, U.S.A

Abstract - Hierarchical-based protocols are some of the most popular routing schemes used in wireless sensor networks due to their favorable, energy-saving properties. However, when it comes to large-scale wireless sensor network applications, these algorithms suffer from an increase in computational complexity and latency. In this paper, a parallel algorithm for the hierarchical-based protocol has been designed based on the Low-Energy Adaptive Clustering Hierarchy (LEACH) algorithm in order to improve the routing efficiency of wireless sensor networks. This algorithm was implemented in parallel using the C programming language and mpich2, an implementation of the Message Passing Interface (MPI) specification. The routing algorithm was evaluated for large-scale sensor networks on both a shared memory supercomputer and two Linux Beowulf clusters. The results show that the parallel implementation of the hierarchical-based protocol improves the overall performance of the routing computations, while still maintaining high energy efficiency levels compared to previous hierarchical-based methods.

Keywords: LEACH, parallel algorithm, wireless sensor networks, routing protocol

1 Introduction In recent years, wireless sensor networks (WSNs) have been widely used in a variety of applications ranging from home and industry to civilian and military. Technological advances in electronics have enabled the development of small, low-cost wireless sensors with signal processing and communication capabilities that are used to sense various types of information among adjacent regions. These properties have made large-scale deployments of WSNs much more possible. Large-scale WSNs consist of base stations and hundreds or thousands of small sensors with sensing, computing and wireless communications capabilities. A greater number of sensors allow for monitoring physical and environmental conditions, such as temperature, barometric pressure, presences of smoke, etc., over much larger geographical regions with both finer accuracy and an increase in resiliency through better fault-tolerance. However, sensor nodes are powered by batteries, which are constrained by their limited energy supply. Therefore, an energy-efficient approach is highly desirable in order to extend the lifetime of the sensors in the WSN.

A variety of network routing protocols for WSNs have been proposed in the literature [1], such as the direct communication protocol, the minimum-transmission-energy multi-hop routing, and the clustering-based routing protocols. In the direct communication protocol, each sensor node sends collected data directly to the base station. If the base station is very far away from the sensor nodes this kind of communication will drain the power of sensor nodes quickly, significantly reducing the system lifetime. In minimum-transmission-energy (MTE) routing, sensor nodes route data to the base station in a multi-hop routing fashion via intermediate nodes. In this case, the intermediate nodes act as routers for other nodes, in addition to sensing the environment. The drawback of MTE routing is that the nodes nearest the base station will act as routers for the majority of data sent to the base station. Thus, the power of these nodes will be drained quickly, resulting in a cascading effect on the entire network and shortening the lifetime of the WSN.

LEACH [2] is one of the first clustering based protocols for sensor networks, and it has inspired many other hierarchical routing protocols [3, 4, 5, and 7]. Even now, it is still one of the most popular hierarchical routing algorithms for WSNs. It is a self-organizing, adaptive clustering protocol that forms clusters of sensor nodes based on the received signal strength and uses local cluster heads as routers to the base station. Since clusters and routing cluster heads are adaptive (cluster heads change in each round), and only the head of the cluster transmits data to the base station, this kind of approach can balance the energy usage among all of the sensors and save significant amounts of energy across the entire WSN, increasing the lifetime of the network.

However, in the case of large-scale sensor networks which consist of hundreds or thousands of nodes, the computational and communication costs of dynamic routing protocols such as LEACH are increased significantly, and it quickly becomes a significant obstacle to energy efficiency. The less time and energy spent on routing decisions, the more time we have available for data transmissions. This necessitates high-performance, parallel algorithms and techniques applied to routing protocols. Unfortunately, little work has been done in the design and development of parallel routing schemes for sensor networks. In this work, we develop a novel, parallel hierarchical-based routing protocol based on the LEACH algorithm for sensor networks to achieve high routing efficiency. This approach has been developed using the C programming language and mpich2. The routing algorithm was evaluated for large-scale sensor

networks on both a shared memory supercomputer and two Linux Beowulf clusters. The performance of our approach has been analysed and evaluated based on simulations of a radio propagation model and a circuit energy cost model. The simulations show that the parallel hierarchical-based routing protocol, as compared to previous-work in this field, can significantly improve the performance of routing without a loss of energy-efficient properties.

In this paper, we first give an introduction to the serial LEACH algorithm in Section 2. Parallel hierarchical-based routing design is given in Section 3. Section 4 mainly describes the implementation environment. Section 5 describes the simulation model. Performance Evaluations and Analysis are done in Section 6. Finally, we conclude our work in Section 7.

2 Serial Hierarchical-Based Routing Protocol

Hierarchical-based routing protocols cluster the nodes so that cluster heads with relatively high energy can collect data from other low energy nodes and transmit data to the base station. In this way, hierarchical-based routing is able to achieve the goals of energy savings and lifetime extension. LEACH is one of the first and the most popular hierarchical routing approaches for sensor networks. We choose it as our basic serial program. To better describe the parallel algorithm, we first briefly introduce the LEACH algorithm and then elaborate on the decomposition and task scheduling involved with designing parallel hierarchical-based routing.

The following description is the main idea behind the LEACH algorithm. Cluster heads change randomly over time in order to balance the energy consumption of the sensor nodes. The optimal percentage of nodes to be chosen as cluster heads is 5%. Each node will randomly choose a number between 0.0 and 1.0. If the number is less than some predefined threshold, the node is chosen to be a cluster head for the current round. The equation is as follows:

11 *( mod )( )

0

p

pp r if n F

R notherwise

−∈

=⎧⎪⎨⎪⎩

(1)

where p is the desired percentage of cluster heads, r is the current round, and F is the set of nodes which have not been chosen as cluster heads in the last 20 rounds. Each elected cluster head then broadcasts a message to the rest of the nodes in the network to notify them that they are the new cluster heads. After receiving the message, all non-cluster head nodes will chose the cluster with the closest cluster head and join the cluster. When the setup phase is stable, the sensor nodes can begin sensing and forwarding data to the cluster heads. The cluster heads receive data from each of the nodes in the cluster, aggregate this data, and subsequently send it to the base station. After a certain period of time, the network will go back into the setup phase, performing another round of choosing cluster heads, and then returning to the stable

phase in which data transmission can occur. This process continues, until all of the nodes in the network have exhausted their energy supply.

There are three steps in one round of the serial LEACH algorithm.

STEP 1: Select heads

The head node selections are based on two requirements. If the node meets the two requirements, it will be selected as a head node.

The two requirements are:

1. Generate a random number uniformly from 0.0 to 1.0. If the random number is less than )(nR as in formula (1), where p is the desired percentage of heads then we designate it as a head node. We set p as 0.05, and r is the current round.

2. The node has not been selected as a head node in the past 20 rounds.

STEP 2: Clustering

Check the distance from each node to each head node (based on received signal strength). Then choose the nearest head node as its cluster head. The number of clusters equals the number of head nodes.

STEP 3: Transmission

Every node in the cluster transmits data to its respective cluster head. Each cluster head then gathers and compresses all of the information and sends it to the base station.

3 Parallel Hierarchical-Based Routing In the routing of large-scale sensor networks, which have hundreds or thousands of sensor nodes, the serial LEACH algorithm will have to go through every sensor node to select the heads of clusters and solve a large clustering problem. This can have a severe impact on the performance of a time sensitive routing procedure such as LEACH. Therefore, it is desirable to decompose the head selection and clustering tasks onto multiple processors, and have each processor perform a sub-task to improve the performance.

3.1 Data Decomposition The initial data of every sensor node consists of four parts:

1. The location_coordinate.

2. The flag_head that indicates whether it is the head of the cluster.

3. The flag_head_log which indicates whether it is chosen to be a head in the last 20 rounds.

4. The flag_cluster indicating which cluster it belongs to.

These data are gathered in an array, where each element has four attributes as described above. The input data array is partitioned into equal-size sub-arrays, which are sent to each processor. Figure 1 shows the data decomposition scheme.

Figure 1. Data decomposition scheme

3.2 Task Dependency The two main tasks in each round are head selection and clustering. Head selection is an independent task but clustering highly depends on the results of head selection, which can be illustrated by the analysis of the requirements and results of the two tasks. The head selection procedure requires the data array, but not necessarily the entire data array, because it does not depend on other sensors whether a sensor will be selected to be a head or not. In other words, it does not depend on other elements of the data array. Results of head selection are stored in the flag_head attribute of the data array. The clustering procedure requires all the results of head selection, since it has to check the distance from each sensor node to each head in order to determine which head is the closest one. The results of clustering are stored in flag_ cluster in the data array. The two main tasks are summarized as follows:

Head Selection Task:

Requirements: Partial data array, not necessarily the entire data array Results: The decisions about which sensors are heads Task dependency: Selection is an independent task

Clustering Task:

Requirements: All the results of head selection task Results: The decisions about which head or cluster it belongs to. Task dependency: Clustering highly depends on the results of head selection.

3.3 Parallel LEACH Algorithm Design STEP 1: Data Decomposition

Assume there are n sensor nodes, data array (data_array (i), i = 1, 2… n) and p processors. The data array with length n is partitioned into p sub_arrays with equal length n/p

(sub_array(j,i), j = 1,2,…,p i = 1,2,…, n/p). The sub-arrays are scattered to each of the p processors.

STEP 2: Head Selection

Each processor selects head nodes from its own local sub-array according to the same selection process as defined in the serial implementation of LEACH, and save the result in the flag_head attribute of the local sub-array. We must also record the history of whether it has been chosen as a head node in the flag_head_log.

For each processor If every element in flag_head_log is 0 Generate a random number r from [0.0, 1.0] uniformly. R∶= 0.05/ (1-0.05(r mod 20)) If R<threshold flag_head = 1

flag_head_log for current round = 1 Else flag_head = 0

STEP 3: Gather and Update data_array

Gather all the local sub-arrays from each processor into the data_array. Then scatter the data_array to every processor. At this step, each parallel task holds the information of all head nodes.

STEP 4: Clustering

Each processor completes the clustering task on their own local sub-arrays based on the information of all head nodes. The results are stored in flag_cluster.

For each node in sub-arrays Calculate the distance between itself and every head node

Choose the head node with minimum distance This node belongs to the cluster of this head flag_cluster = cluster_index

STEP 5: Gather All Results and Go to the Next Round

Gather all the local sub-arrays from each processor into the global data array. Then go to STEP 1 to repeat the above steps.

4 Parallel Implementation Environment LEACH was first simulated in serial by Wendi, et al using Matlab. Our parallel approach was implemented using the C programming language and the mpich2 implementation of MPI. The Simulations were conducted on two platforms available to students of the University of Southern Mississippi (USM). One is the Albacore cluster which is the primary HPC cluster in the School of Computing at USM [6]. The cluster consists of 256 processor cores, 300GB of RAM and 1Gbit Ethernet interconnects. Albacore is a hybrid, distributed-shared memory cluster, consisting primarily of Intel Xeon 56xx processors, Intel Xeon 55xx processors. The second platform available to our research group was Sequoia, an HPC Linux cluster at the University of Mississippi’s Center for

Super Computing Research (MCSR) [8]. Sequoia is a hybrid, distributed-shared memory system, consisting of. 84 compute nodes, 22 Altix XE 310, 24 Altix 320 and 38 Rackable computing nodes. The overall memory of Sequoia is 2.1 TB.

5 Simulation Model In this section, we describe the simulation model used for performance analysis of our parallel implementation. In order to maintain a similar comparison, the same simulation model is used for both the serial and parallel implementations. The environment configuration and energy cost model for the sensor networks are described.

5.1 Environment Configuration

Figure 2 The coordinates of sensor areas and base station

The sensors are deployed uniformly in a 100-by-100 meter area. Figure 2 shows an example of a sensor area, along with its corresponding base station, along with coordinates. The base station is allocated 100 meters away from the sensing area, which is specifically at the location of (0, -100) in Figure2.

5.2 Energy Cost Model The initial energy of each sensor node is 50J. In each round, every sensor node sends 2000 bits data. The energy cost of transmission consists of two parts:

1. The energy cost of transmitter and receiver circuit 50 /elecE nJ bit= (2)

Every bit the circuit transmits and receives will cost 50nJ energy.

2. The energy loss of radio propagation 100 2/pJ

amp bit mε = (3) The energy loss of radio propagation is inversely proportional to the square of the distance it travels. In addition to this loss, the total energy consumed is also proportional to the number of bits transmitted.

The formulas of energy cost at both transmitter and receiver side are given below.

2( , ) * * *Tx elec ampE k d E k k dε= + (4)

( ) *Rx elecE k E k= (5)

TxE and RxE denote the energy cost at transmitter and receiver respectively. k is the number of bits transmitted.

6 Performance Evaluations and Analysis 6.1 System life time The hierarchical-based routing protocol's main advantage is its high energy-efficiency, which supports a much longer system lifetime than other routing protocols. Therefore, the parallel hierarchical-based routing solution should reflect the same energy saving advantages as the serial algorithm. There are two important attributes that indicate the system stability and lifetime. One attribute is the number of head nodes in the sensor network at each round, as the energy cost of the network is highly dependent on the number and length, both distance and bit-wise, of the data transmissions. Since only the head nodes of the system do the majority of transmissions, it is important to keep track of how many of these are active at any time in the system. Although the nodes have data compression capability, the head nodes still have to transmit a relatively large amount of data, which is usually a long distance, energy consuming transmission. The other attribute is the number of sensor nodes at each round which have not exhausted their energy supply. The definition of system lifetime is the period of time that there is at least one live sensor node.

Figure 3 Number of live nodes in every round of both serial and parallel

programs

Both the parallel and serial programs use the same header selection strategy, which involved a random procedure. Therefore the number of head nodes in each round can be slightly different, but the trend should be similar. In Figure 3, the number of live nodes decreases over time as the overall number of nodes decreases due to drained batteries. The variations in the number of live nodes between the serial and parallel plots are due

to the random selection of head nodes. However, the general trends of the two plots match well. In addition, the initial total energies of both the sensor networks are the same so that the lifetimes of system are the same, i.e. 200.

6.2 Performance Analysis To evaluate the performance of our parallel hierarchical-based routing algorithm, the simulation method presented in Section 5 is employed. The parallel program was executed on Albacore and Sequoia separately using four different initial node counts (320, 640, 960 and 1280). The location and environmental conditions, including the initial energies of the sensors, were consistent across all simulation runs. The serial and parallel run times, denoted as pT and sT , are recorded from the experiment and shown in Tables 1 and 2, as well as in Figure 4 and 5. Derived variables used to analyse the performance are the speedup and efficiency [9, 10]. The speedup is defined as /s pS T T= ; the efficiency is defined

as /S p , where p is the number of processors. The reasons why the speedup and efficiency are chosen are that, for speedup, it delineates how much performance gain is achieved via parallel design over serial design; and for efficiency, it describes how much time spent on the computation, not on idle time or communication, for each processor.

Table 1: The execution times with different number of processors on Sequoia (p is the number of processors and column N is the data size)

P=1 P=2 P=4 P=8 P=12 N=320 2.672 1.514 1.140 1.204 0.809 N=640 10.161 5.476 3.188 2.907 2.839 N=960 22.252 11.764 6.417 5.748 5.063

N=1280 39.331 20.451 11.008 6.662 6.706 N=1600 60.958 31.655 17.005 9.501 7.742

Table 2: The execution times with different number of processors on Albacore (p is the number of processors and column N is the data size)

p=1 p=2 p=4 p=8 p=12 N=320 2.727 1.706 1.193 1.005 1.001 N=640 9.249 5.245 3.094 2.408 2.210 N=960 19.974 10.808 6.186 3.880 3.830

N=1280 34.720 18.479 10.151 6.637 6.113 N=1600 53.644 28.396 15.409 9.811 8.668

Table 3: Speedup with different number of processors on Sequoia (p is the number of processors and column N is the data size)

p=1 p=2 p=4 p=8 p=12 N=320 1.000 1.765 2.343 2.218 3.300 N=640 1.000 1.855 3.186 3.494 3.578 N=960 1.000 1.891 3.467 3.870 4.394

N=1280 1.000 1.923 3.572 5.902 5.864 N=1600 1.000 1.925 3.584 6.415 7.873

Table 4: Speedup with different number of processors on Albacore (p is the number of processors and column N is the data size)

p=1 p=2 p=4 p=8 p=12 N=320 1.000 1.597 2.284 2.713 2.723 N=640 1.000 1.763 2.989 3.841 4.184 N=960 1.000 1.848 3.228 5.146 5.214

N=1280 1.000 1.878 3.420 5.230 5.679 N=1600 1.000 1.889 3.481 5.467 6.188

Table 5: Efficiency with different number of processors on Sequoia (p is the number of processors and column N is the data size)

p=1 p=2 p=4 p=8 p=12 N=320 1.000 0.882 0.585 0.277 0.275 N=640 1.000 0.927 0.796 0.436 0.298 N=960 1.000 0.945 0.866 0.483 0.366

N=1280 1.000 0.961 0.893 0.737 0.488 N=1600 1.000 0.962 0.896 0.801 0.656

Table 6: Efficiency of programs with different number of processors on Albacore (p is the number of processors and column N is the data size)

p=1 p=2 p=4 p=8 p=12 N=320 1.000 1.597 2.284 2.713 2.723 N=640 1.000 1.763 2.989 3.841 4.184 N=960 1.000 1.848 3.228 5.146 5.214

N=1280 1.000 1.878 3.420 5.230 5.679 N=1600 1.000 1.889 3.481 5.467 6.188

Figure 4 The execution time with different number of processors on Sequoia

Figure 5 The execution time with different number of processors on Albacore

Figure 6 The speedup with different number of processors on Sequoia

Figure 7 The speedup with different number of processors on Albacore

Figure 8. The efficiency with different number of processors Sequoia

Figure 9 The efficiency with different number of processors Albacore

Figure 10 The execution with different number of processors on Sequoia (up

to 32 processors)

From Figures 4 and 5, we can see that the execution time drops very fast for large problem size, for instance, 1280 and 1600. Nevertheless, when the number of processors is above 8, the decreasing of the execution time is less significant than that below 8. This is consistent with the speedup. Figures 6 and 7 show that, for different numbers of nodes, the speedup increases as the number of processors increases. However, the slope decreases, when the number of processor is over 8. The reason is that the communication time increases as the number of processors increases. Figures 8 and 9 show that the parallel LEACH algorithm have almost the same efficiency [11] on both Albacore and Sequoia systems. This is because these two systems have nearly identical specifications in memory and processors. Figure 10 shows that the execution time increases when the number of processors is greater than 12. This is due to the fact that both Sequoia and Albacore are hybrid, distributed-shared memory systems. Each node in the cluster consists of a single motherboard with dual-six core Intel Xeon 56xx class processors. Therefore, when executing this algorithm, the communication costs are negligible within a single node (where memory is shared), but cross-node communication costs, which occurs over 1Gbit Ethernet, is much higher than that within a single node.

7 Conclusion The parallel hierarchical-based routing algorithm was designed and implemented in MPI based on the serial LEACH algorithm to achieve high performance routing. The task is partitioned and scheduled among all the available processors to improve the performance. The simulation results show that the high-performance computing techniques and parallel implementation can achieve a significant speedup while maintaining the energy-efficient properties of hierarchical-based routing protocols.

8 Acknowledgement Thanks to the School of Computing at USM and the Mississippi Center for Supercomputing Research (MCSR) for providing state-of the art, high performance computing facilities and excellent services for supporting this research.

9 References [1] K. Akkaya and M. Younis, “A survey on routing protocols for wireless sensor networks,” Ad Hoc Networks, vol. 3, no. 3, pp. 325--349, May 2005.

[2] W. Heinzelman, A. Chandrakasan, and H. Balakrishnan, “Energy-effcient communication protocol for wireless microsensor networks,” Proceedings of the 33rd Hawaii International Conference on System Sciences (HICSS ’00), Hawaii, January 2000.

[3] V. Loscri, G. Morabito, and S. Marano, “A Two-Level Hierarchy for Low-Energy Adaptive Clustering Hierarchy,” DEIS Department, University of Calabria.

[4] S. Lindsey and C. S. Raghavendra, “PEGASIS: power efficient gathering in sensor information systems,” in the Proceedings of the IEEE Aerospace Conference, Big Sky, Montana, March 2002.

[5] S. Lindsey, C. S. Raghavendra, and K. Sivalingam, “Data gathering in sensor networks using the energy*Delay metric,” in the Proceedings of the IPDPS Workshop on Issues in Wireless Networks and Mobile Computing, San Francisco, CA, April 2001.

[6] http://albacore.st.usm.edu:8080/platform.

[7] Y. Jia, L. Zhao, and B. Ma, “A hierarchical clustering based routing protocol for wireless sensor networks supporting multiple data aggregation qualities,” International Journal of Sensor Networks. vol. 4, no. 1/2, pp. 79-91, 2008

[8] Mississippi Center for Supercomputing Research, Available: http://www.mcsr.olemiss.edu.

[9] A. Grama, A. Gupta, G. Karypis, and V. Kumar, Introduction to Parallel Computing, Addison-Wesley, 2003.

[10] C. P. Kruskal, L. Rudolph, and M. Snir. “A complexity theory of efficient parallel algorithms,” Technical Report RC13572, IBM T. J. Watson Research Center, Yorktown Heights, NY, 1988.

[11] V. Kumar and A. Gupta. “Analysing scalability of parallel algorithms and architectures,” Journal of Parallel and Distributed Computing, 22(3):379–391, 1994.