ENERGY-EFFICIENT SINK MOBILITY
ALGORITHMS FOR WIRELESS SENSOR
NETWORKS
a dissertation submitted to
the graduate school of engineering and science
of bilkent university
in partial fulfillment of the requirements for
the degree of
doctor of philosophy
in
computer engineering
By
Metin Ko¸c
September, 2015
ENERGY-EFFICIENT SINK MOBILITY ALGORITHMS FOR WIRELESS SENSOR NETWORKS
By Metin Ko¸c September, 2015
We certify that we have read this dissertation and that in our opinion it is fully adequate, in scope and in quality, as a dissertation for the degree of Doctor of Philosophy.
Assoc. Prof. Dr. ˙Ibrahim K¨orpeo˘glu(Advisor)
Prof. Dr. ¨Ozg¨ur Ulusoy
Prof. Dr. U˘gur G¨ud¨ukbay
Prof. Dr. Adnan Yazıcı
Assist. Prof. Dr. Mehmet K¨oseo˘glu Approved for the Graduate School of Engineering and Science:
Prof. Dr. Levent Onural Director of the Graduate School
ABSTRACT
ENERGY-EFFICIENT SINK MOBILITY ALGORITHMS
FOR WIRELESS SENSOR NETWORKS
Metin Ko¸c
Ph.D. in Computer Engineering
Advisor: Assoc. Prof. Dr. ˙Ibrahim K¨orpeo˘glu September, 2015
A wireless sensor network consists of a large number of tiny sensor nodes which are capable of sensing an environment and sending the collected data to a sink node. For most scenarios, sensor nodes are powered with irreplaceable batteries and this dramatically limits the lifetime of the network, especially due to overloading of the sensor nodes neighboring sink node. Such nodes need to forward more traffic than other nodes in the network. Moving sink node and in this way distributing forwarding-load evenly among sensor nodes is one of the important techniques for improving lifetime of sensor networks. We propose different mobility algorithms for single-sink and multiple-sink mobility problem to efficiently move sink nodes through a predefined set of sink sites.
We first provide packet-load and energy-load based sink mobility algorithms, called PLMA and ELMA, in which node-load parameters are incorporated into a table and this table is used to determine which sink site to visit in each round. We also give an integer programming model to get optimal results and do bench-marking. Since routing topology is an important component of sink mobility schemes, we also propose centralized and distributed routing topology construc-tion algorithms to further increase network lifetime. Addiconstruc-tionally, we propose an adaptive energy-load based sink movement algorithm, called A-ELMA, which does not require an initial training phase to learn about network topology. It incrementally constructs and updates energy-load table each time it visits a site location.
Finally, besides proposing algorithms for single-sink mobility problem, we also propose two different algorithms for multiple-sink mobility problem. Our Multiple Sink Movement Algorithm (MSMA) is a centralized algorithm and effectively lim-its the sink site combinations to reduce computation and communication overhead in scheduling sink movements without harming network lifetime significantly. Our Prevent and Move Away (PMA) algorithm is a fully distributed algorithm and does not require topology information to be collected. It selects sites based on
iv
remaining energy values and distance metrics.
We evaluated our algorithms and compared them to some basic approaches in the literature by conducting extensive simulation experiments. Our simulation results show that our algorithms can perform better than some other alternatives in terms of network lifetime, latency and travel distance. We also identify under which conditions our algorithms perform better for each of these metrics. We ob-served that our algorithms provide simple-to-use, efficient, and effective solutions for single- and multiple-sink mobility problems in wireless sensor networks.
Keywords: wireless sensor network, energy-efficiency, sink-mobility, network life-time improvement, routing tree construction.
¨
OZET
KABLOSUZ ALGILAYICI A ˘
GLAR ˙IC
¸ ˙IN ENERJ˙I
VER˙IML˙I ALICI HAREKETL˙IL˙IK ALGOR˙ITMALARI
Metin Ko¸c
Bilgisayar M¨uhendisli˘gi, Doktora Tez Danı¸smanı: Do¸c. Dr. ˙Ibrahim K¨orpeo˘glu
Eyl¨ul, 2015
Kablosuz algılayıcı a˘g, bir ortamı algılayabilen ve toplanan veriyi alıcı d¨u˘g¨ume ileten ¸cok sayıda k¨u¸c¨uk algılayıcı d¨u˘g¨umden olu¸sur. C¸ ogu senaryoda algılayıcı d¨u˘g¨umler de˘gistirilemez pillerle ¸calıstırılırlar ve bu durum alıcı d¨u˘g¨ume kom¸su algılayıcı d¨u˘g¨umlerin a¸sırı y¨uklenmesine ba˘glı olarak a˘g ya¸sam s¨uresini ¨onemli ¨
ol¸c¨ude sınırlar. Alıcı d¨u˘g¨um¨u hareket ettirme ve bu yolla algılayıcı d¨u˘g¨umler arasındaki iletme y¨uk¨un¨u e¸sit olarak da˘gıtmak, algılayıcı a˘gların ya¸sam s¨uresini iyile¸stirmek i¸cin ¨onemli tekniklerden biridir. Alıcı d¨u˘g¨umleri, ¨onceden tanımlanmı¸s bir dizi alıcı yerine do˘gru etkili bi¸cimde hareket ettirmek ¨uzere tek ve ¸coklu alıcı hareketlilik problemleri i¸cin farklı hareketlilik algoritmaları ¨oneriyoruz.
¨
Oncelikle, PLMA ve ELMA adı verilen d¨u˘g¨um y¨uk¨u parametrelerinin bir tabloda birle¸stirildi˘gi ve bu tablonun her bir tur i¸cin hangi alıcı yerine gidilece˘gini belirlemek i¸cin kullanıldı˘gı, paket ve enerji y¨uk¨u bazlı alıcı hareketlilik algo-ritmaları ¨oneriyoruz. Ayrıca en iyi sonu¸cları elde etmek ve kar¸sıla¸stırmalı de˘gerlendirme yapmak amacıyla bir tamsayı do˘grusal programlama modeli de veriyoruz. Y¨onlendirme topolojisi alıcı hareketlilik planlarının ¨onemli bir bile¸seni oldu˘gundan, a˘g ya¸sam s¨uresini daha da artıran merkezi ve da˘gıtık y¨onlendirme topoloji olu¸sturma algoritmaları da ¨oneriyoruz. ˙Ilaveten, a˘g topolojisini ¨o˘grenmek i¸cin ba¸slangı¸cta ¨o˘grenme a¸samasına gerek duymayan A-ELMA adlı enerji-y¨uk bazlı alıcı hareketlilik algoritması ¨oneriyoruz. Bu algoritma bir yeri her ziyaret etti˘ginde enerji y¨uk tablosunu a¸samalı olarak olu¸sturup g¨uncellemektedir.
Son olarak, tek alıcı hareketlilik problemi i¸cin ¨onerilen algoritmalar dı¸sında ¸coklu alıcı hareketlilik problemi i¸cin de iki farklı algoritma ¨oneriyoruz. MSMA adlı ¸coklu alıcı hareket algoritması a˘g yasam s¨uresine ¨onemli ¨ol¸c¨ude zarar ver-meyecek ¸sekilde alıcı hareketlerinin zamanını programlarken hesaplama ve ileti¸sim ek y¨uk¨un¨u azaltmak i¸cin alıcı yer kombinasyonlarını etkili bi¸cimde sınırlayan merkezi bir algoritmadır. PMA algoritması ise topoloji bilgisinin toplanmasını gerektirmeyen tamamen da˘gıtık bir algoritmadır. Bu algoritma, yerleri, kalan
vi
enerji de˘geri ve uzaklık metriklerine g¨ore se¸cmektedir.
Algoritmalarımızı de˘gerlendirmek ve literat¨urdeki bazı temel yakla¸sımlarla kar¸sıla¸stırmak i¸cin kapsamlı benzetim deneyleri ger¸cekle¸stirdik. Benzetim sonu¸cları algoritmalarımızın a˘g ya¸sam s¨uresi, gecikme ve katedilen mesafe a¸cısından bazı di˘ger se¸ceneklerden daha iyi sonu¸c verdi˘gini g¨ostermektedir. Ayrıca algoritmalarımızın bu metriklerin her biri i¸cin hangi ko¸sullarda daha iyi sonu¸c verdi˘gini belirliyoruz. Algoritmalarımızın kablosuz algılayıcı a˘glardaki tek ve ¸coklu alıcı hareketlilik problemi i¸cin kullanımı kolay, etkin ve verimli ¸c¨oz¨umler sa˘gladı˘gını g¨ozlemledik.
Anahtar s¨ozc¨ukler : kablosuz algılayıcı a˘g, enerji verimlili˘gi, alıcı hareketlili˘gi, a˘g ya¸sam s¨uresi geli¸stirme, y¨onlendirme a˘ga¸c yapılandırması.
Acknowledgement
First of all, I would like to express my sincere gratitudes to my advisor Assoc. Prof. Dr. ˙Ibrahim K¨orpeo˘glu. Dr. K¨orpeo˘glu not only guided me to find my way in this long academic journey, but also taught me how to be strong against difficulties in life. I will be grateful for the things he has patiently taught me.
I would like to thank members of the thesis progress committee, Prof. Dr. ¨
Ozg¨ur Ulusoy and Prof. Dr. Adnan Yazıcı for their valuable comments and discussions for the last four years. I would also like to thank Prof. Dr. U˘gur G¨ud¨ukbay and Assist. Prof. Dr. Mehmet K¨oseo˘glu for being on my thesis defense jury and their useful feedback.
I have had several people around during this long journey who made me feel special. I definitely learnt a lot from the discussions we had during lunchtime with my dear friends ¨Ozg¨ur S¸anlı and ¨Ozg¨ur Erg¨ul. Levent, my brother, has always been there when I needed to talk despite the physical distance and time difference. Finally, I am grateful to my parents for their continuous love and support which kept me walking in life.
Lastly, I can’t emphasize enough how grateful I am to my beloved wife, Buket, who has an incredible support to put a happy ending to this story. She encouraged me every single time I felt desperate during these years. I apologize from my children, Deniz and Ali Aras, for all this time that we couldn’t spend together. I’m hoping that we will make up this time together from now on.
Contents
1 Introduction 1
1.1 Contributions . . . 7
1.2 Outline of the Dissertation . . . 8
2 Related Work 9 2.1 Single-Sink Mobility . . . 9
2.2 Tree-based Topology Construction . . . 13
2.3 Multiple-Sink Mobility . . . 16
3 Traffic and Energy-Load–Based Sink Mobility Algorithms for Wireless Sensor Networks 19 3.1 System Model . . . 21
3.2 Proposed Algorithms . . . 22
3.2.1 Packet-Load Based Movement Algorithm (PLMA) . . . 23
3.2.2 Energy-Load–Based Movement Algorithm (ELMA) . . . . 25
3.2.3 Mathematical Model . . . 27 3.3 Multiple-Sink Case . . . 28 3.4 Performance Evaluation . . . 29 3.4.1 Simulation Parameters . . . 30 3.4.2 Simulation Results . . . 33 3.5 Conclusion . . . 41
4 Adaptive Routing Topology Construction and Sink Mobility Al-gorithms 43 4.1 Energy-Efficient Tree Topology Construction Algorithms . . . 44
CONTENTS ix
4.1.2 Centralized Topology Construction Algorithm (CTCA) . . 47
4.1.3 Distributed Topology Construction Algorithm . . . 49
4.2 Adaptive Load Based Sink Mobility Algorithms for WSN . . . 53
4.2.1 Algorithm Details . . . 54
4.3 Simulation Results . . . 55
4.4 Conclusion . . . 67
5 Coordinated Movement of Multiple Mobile Sinks 69 5.1 System Model . . . 70
5.2 Proposed Algorithms . . . 72
5.2.1 Multiple-Sink Movement Algorithm (MSMA) . . . 72
5.2.2 Prevent and Move Away (PMA) Algorithm . . . 76
5.3 Performance Evaluation . . . 82
5.3.1 Simulation Parameters . . . 82
5.3.2 Simulation Results . . . 83
5.4 Conclusion . . . 90 6 Conclusions and Future Work 91
List of Figures
3.1 Neighbor-based sink-site determination . . . 32
3.2 Network lifetime versus number of nodes . . . 33
3.3 Network lifetime versus number of nodes under skew deployment . 34 3.4 Network lifetime versus transmission ranges . . . 35
3.5 Latency versus transmission ranges . . . 36
3.6 Network lifetime versus number of nodes . . . 37
3.7 Network lifetime versus number of sinks . . . 38
3.8 Latency versus number of sinks . . . 39
3.9 Network lifetime versus number of sink sites . . . 40
3.10 Network lifetime versus number of sinks under skew deployment . 40 3.11 Distance traveled versus number of sinks . . . 41
4.1 Parent selection in Load Based Topology Construction Algorithm 48 4.2 Network lifetime versus transmission ranges . . . 57
4.3 Network lifetime versus transmission ranges . . . 58
4.4 Latency versus transmission ranges . . . 59
4.5 Network lifetime versus number of nodes (DTCA) . . . 59
4.6 Network lifetime versus number of nodes (CTCA) . . . 60
4.7 Latency versus number of nodes . . . 61
4.8 Distance traveled for various number of nodes . . . 62
4.9 Network lifetime versus transmission ranges (DTCA) . . . 62
4.10 Network lifetime versus transmission ranges (CTCA) . . . 63
4.11 Latency versus transmission ranges . . . 64
4.12 Network lifetime versus tmin values (DTCA) . . . 65
LIST OF FIGURES xi
4.14 Distance traveled for various tmin values . . . 66
5.1 Network lifetime versus number of sinks . . . 84
5.2 Latency versus number of sinks . . . 84
5.3 Distances traveled for various number of sinks . . . 85
5.4 Network lifetime versus transmission ranges . . . 86
5.5 Network lifetime versus number of sink sites . . . 87
5.6 Network lifetime versus tminvalues . . . 88
5.7 Distances traveled for various tminvalues . . . 88
List of Tables
3.1 Simulation parameters . . . 32
3.2 Average running times (in seconds) of the two approaches. . . 37
4.1 Sample parent list . . . 51
Chapter 1
Introduction
A wireless sensor network (WSN) is generally composed of numerous tiny sensor nodes and a more powerful special node called a sink node [1]. Sensor nodes are low-cost and low-power devices that are composed into a network to sense the environment, process the data, and send the information to the sink node. Each sensor node typically has a micro-controller (processing data, controlling other components), one or more sensors (sensing the environment), a memory chip (storing program and data), a transceiver (sending and receiving data), and a power source (mostly batteries).
Network-enabled sensor nodes are being produced starting from 2000s and the technology is constantly evolving. To give an example, some industrial sensor nodes have 512 KB program memory and 16 MB data memory on board [2]. These nodes support 802.15.4/ZigBee or Bluetooth for data communication. Al-though built-in sensors on these nodes differ according to the application, they can typically be temperature, humidity, light and acoustic sensors.
Sinks, or base stations, have similar but more powerful units on them. Sinks are generally attached to a computer and are mains-powered, therefore do not have energy problem. A sink node acts as a gateway between sensor nodes and an application (end user). There can be either one or multiple sinks in the
environment depending on the application WSNs are used for.
Sensor networks have various applications. Although different taxonomies are done for these applications, an important category is monitoring and tracking ap-plications [3,4]. Sensor networks apap-plications in the sectors of military, environ-ment, healthcare and industrial automation have both monitoring and tracking features [5]. Military applications include border surveillance, monitoring friendly forces, or tracking enemy soldiers. Environment applications include detecting forest fires, detecting chemical material leakage, and animal tracking. Industrial applications include guided vehicle tracking and manufacturing process moni-toring. Healthcare applications mainly include patient monitoring and tracking. Using sensor nodes for healthcare applications is one of the important emerging markets for WSNs [3].
Sensor nodes have different power sources, like batteries, micro-fuel cells, ra-dioactive power sources, and micro heat engines [6]. Energy harvesting is another possible power source and becomes popular in recent years [7–9]. However, in most cases, batteries are the main source of power supply. Most of the sensor nodes in the industry use AA batteries (3.0 Volt) for power source. These bat-teries have very limited capacity and need to be changed or recharged regularly to have an extended lifetime. However, in typical sensor network applications, like habitat monitoring, enemy tracking, or border surveillance, it is very hard to access the nodes and change their batteries when needed.
This limited energy problem is the major bottleneck for sensor networks which should be carefully considered when designing sensor network proto-cols, algorithms, or applications to prolong network lifetime. Different energy-efficient approaches in various network layers are proposed in the literature for improving network lifetime, such as power control mechanisms (physical layer) [10,11], energy–efficient MAC layer protocols (data-link layer) [12,13], and data-gathering/routing protocols (network layer) [14,15].
is no data aggregation applied in the network, sensor nodes transmit their mes-sages and relay the data packets of other nodes. This situation causes the nodes in the vicinity of the sink to deplete their energy faster than other nodes in the network, which is called the hot-spot problem [16]. Making the sink node mobile can help solving this problem via distributing the hot-spot load among all sensor nodes, in this way improving the network lifetime.
Sink mobility can be either uncontrolled or controlled, depending on the mobil-ity scheme used [17]. In uncontrolled mobilmobil-ity, data MULEs (Mobile Ubiquitous LAN Extensions) are used as a middleware between sinks and sensor nodes [18]. These MULEs collect data from sensor nodes when they come within range, then they buffer the data and send it to the sink [19]. This type of mobility is called uncontrolled, because MULEs do not consider current network conditions, but instead move randomly in the area. In controlled mobility, however, node and network conditions like remaining energy or node density are taken into consid-eration.
Until now, controlled sink mobility problem is generally handled as an op-timization problem and mathematical programming based solutions are given. Although it is important to see upper bounds on the network lifetime, most of these solutions do not scale and also cannot be run directly on the sensor nodes due to their high computation and space requirements. Therefore, it is important to give algorithms that can be run on the sensor devices directly, instead of doing calculations on powerful centralized machines and then configuring the network. In this thesis, our aim is to prolong the lifetime of sensor nodes and network using controlled sink mobility algorithms. We investigate both single-sink and multi-sink problems and propose centralized and distributed algorithms to coor-dinate sink movements. We also give energy-efficient tree-topology construction algorithms. Routing tree construction is an important component of protocols for sensor networks with a mobile sink, since the routing topology needs to be repeatedly re-constructed every time the sink changes its location.
Firstly, we investigate the single-sink mobility problem. We present two dif-ferent centralized algorithms, Energy-Load based Movement Algorithm (ELMA) and Packet-Load based Movement Algorithm (PLMA), to arrange sink move-ments that include determining the order of visits and the number of rounds to stay in a migration point. Knowing the number of packets each node sends to its parent or the amount of energy each node consumes while transmitting pack-ets in a round for each migration point can help the sink node to select next migration points in a way to balance the energy consumption in the network. This information can be obtained in two ways: by using node locations directly or by visiting each alternative site before network starts its operation. Energy-efficient tree topologies can be constructed since nodes’ neighbor relationships and logical levels can be extracted from location information for a specific sink site. However, this cannot be possible for most of the cases. So in our case, a sink node visits possible sites before network starts its operation and forms tree-based topologies to calculate the number of packets and energy expenditure values. Using these values the sink constructs traffic- or energy-load matrices. Our algorithms use these matrices together with node remaining energy values to select next migration points.
We also formulate the single-sink mobility problem as an integer program to obtain the optimal results. These results provide a benchmark for us to evaluate the performance of our proposed ELMA and PLMA algorithms. We performed extensive simulations to compare the performance of ELMA and PLMA with optimal, random and static sink approaches. Results showed that ELMA can perform up to five times more lifetime than static case and two times than ran-domly selecting the sink sites approach while it is just five percent below the optimal solution. ELMA and PLMA run faster than optimal algorithm, espe-cially when number of nodes increases. The memory that is needed to store these matrices can easily be supported with current sensor node technology.
Although ELMA and PLMA improve network lifetime, it is assumed that the same tree-topology is formed, i.e., each node selects the same parent, each time the sink visits the same location. Mechanical problems in sensor nodes or some obstacles in the field like an animal in a forest can prevent nodes to select the same
parent when sink visits the same site. Besides that, a training phase is required for sink to visit each site and construct tree-based topologies to populate traffic-and energy-load matrices. This phase delays the network to start its operation and can be quite long depending on the speed of the sink node. Such a delay cannot be tolerated in applications like forest fire detection or border surveillance. We propose an adaptive version of our ELMA algorithm, called A-ELMA, which does not require any network information a priori. A sink visits sites mostly randomly in the first rounds of the network operation, constructs topologies and learns traffic/energy loads of nodes. It also updates those values when visiting the same site again and does not restrict the nodes to select the same parent again and again. Instead, it takes advantage of constructing energy-efficient tree-topologies considering nodes’ residual energy values. Experimental results showed that A-ELMA performs better than ELMA and optimal algorithms.
When sink is mobile in a network, it changes its position frequently and recon-structs a topology each time it visits a site location. Constructing energy-efficient tree topologies can prolong the lifetime jointly with mobility [20]. Therefore, energy-efficient topology construction is a complementary component of mobility scheme and increases the effectiveness of mobility to improve network lifetime. We propose two algorithms, a centralized one (CTCA) and a distributed one (DTCA), to construct an energy-efficient routing topology each time sink changes its location.
In our Centralized Topology Construction Algorithm (CTCA), nodes send their parent list and level information to the sink node where balanced topology is constructed considering packet load and remaining energy values of the nodes. In our Distributed Topology Construction (DTCA) algorithm, however, each node selects a parent based on probabilities proportional with remaining energy values. The idea is to balance the load of the sink’s first-hop neighbors as much as possible without direct communication with neighbor nodes. Our results show that CTCA improves lifetime better than DTCA, however, CTCA algorithm incurs more delay during construction since all nodes spend time in sending their values to the sink node and wait for the configuration information to come back.
The controlled single-sink mobility problem is widely investigated in the lit-erature [20–26]. Mathematical programming formulations that can maximize the lifetime under various constraints are used in most works. However, the multiple-sink mobility problem has specific challenges compared to its single-sink counterpart, especially during the site selection process. In the single-sink mo-bility problem, there is no competition for sink sites. The sink chooses the most energy-efficient site among the alternatives and moves to it without considering whether it has been occupied already by another sink.
In the multiple-sink mobility problem, s sinks should choose different sites among p alternatives in a mutually exclusive manner so that any two sinks do not decide to move to the same location at the same re-configuration instance. In the single-sink case, the base station chooses one point out of p alternatives, but in the multiple-sink case, the number of possible combinations to select in each decision is ps. These make the multiple-sink problem more complex compared to the single-sink problem.
Although they should not be used in a real sensor node environment due to computational constraints, mathematical-programming based solutions are mostly preferred, as in single-sink case, for maximizing network lifetime using multiple-sink movements. Additionally, an exponential number of constraints can exist in these formulations, since all possible sink-site combinations are included. Solving these formulations can take several days even with current computation technology. These calculations must be done before the network begins opera-tion and the soluopera-tion, sink sojourn time for each sink site, should be given to the sinks. Obviously, these solutions are not dynamic and fail to adapt to changes, such as unavailable sites or node failures due to physical conditions, that can occur during network lifetime.
We propose Multiple-Sink Movement Algorithm (MSMA) and Prevent and Move Away (PMA) Algorithm for multiple-sink mobility problem. In MSMA, which is a centralized algorithm, we have a threshold value which determines how much load-related information (packet load or energy load) each sink can keep for scheduling their movements. Load-related information indicates the
energy consumed at a node or the traffic-amount a node should handle for a particular sink site combination for multiple sinks. We select a subset of sink-site combinations using the k-means algorithm, which does not exceed the threshold value. Sinks select sites randomly with a small probability to increase the number of combinations, again respecting the threshold value.
PMA is a distributed algorithm, on the other hand, in which each sink eval-uates the information coming from the nodes on its subtree and forbids some of the sites that are close to its descendants. Each sink selects its candidate sites that have nodes with more energy and shares this information with the other sinks to select s/2 sites that have global maximum value. The remaining s/2 sites are selected farthest from these sites to make a balance between energy and distance without global network parameter values. Simulation results show that MSMA performs better than MinDiff-RE [27], random movement and static sink approaches. Although PMA’s performance is worse than MSMA, it performs bet-ter than random movement and sinks travel less compared to other algorithms when PMA is used.
1.1
Contributions
Our contributions in this dissertation can be summarized as follows:
• We proposed two centralized single-sink mobility algorithms which consider nodes’ energy or packet load values to schedule sink movements for prolong-ing network lifetime.
• We also formulated the single-sink mobility problem as an integer program to determine the number of rounds sink should stay at each point to max-imize the lifetime. We used the results of this mathematical model as a benchmark for evaluating the results of our traffic- and energy-load based sink mobility algorithms.
environment in MATLAB and integrated IBM Cplex Optimizer to solve the problem in the same environment. We showed via simulations that our energy-load based algorithm is just five percent below the optimal solution while performing up-to five times better than static sink case and two times better than random movement approach.
• We proposed two energy efficient routing tree construction algorithms, CTCA and DTCA. CTCA uses network information to carefully arrange the loads of nodes, while in DTCA each node selects a parent in a probabilistic manner without communicating with its neighbors.
• We proposed an adaptive single-sink mobility algorithm (A-ELMA) that removes the assumptions used in our energy-load based algorithm. Our adaptive algorithm does not need to learn network parameters via a train-ing phase. Instead it learns these parameters while visittrain-ing the sites and updates them to take advantage of residual energy of sensor nodes.
• We proposed centralized and distributed mobility algorithms to coordinate the movement of multiple sinks. Our centralized MSMA algorithm limits the possible number of site combinations according to a threshold value to reduce complexity. Our PMA algorithm is fully distributed and does not require any prior network information.
1.2
Outline of the Dissertation
The rest of the dissertation is organized as follows. In the next chapter we give the related work about single-sink mobility, tree-topology construction and multiple-sink mobility problems. In Chapter 3, we give traffic- and energy-load based algorithms for single-sink mobility problem. Chapter 4 describes our energy efficient tree-topology construction algorithms and our adaptive sink mobility algorithm. We present our algorithms for multiple-sinks mobility problem in Chapter 5. Finally, we give our conclusions and future research directions in Chapter 6.
Chapter 2
Related Work
In this chapter we give a summary of the previous work related to our research problem. First, we give studies about single-sink mobility problem. Next, we discuss the energy-efficient data gathering schemes, logical topologies and con-structing tree-topologies without data aggregation. Lastly, we summarize some of the previous work about multiple-sink mobility problem.
2.1
Single-Sink Mobility
The most important characteristic of WSNs is the limited energy resources of sen-sor nodes. A typical sensen-sor node has generally an irreplaceable limited-capacity battery. Consuming the least amount of energy is the most critical criterion while designing any sensor-network protocol so that the energy of nodes and network is utilized as efficiently as possible.
Several approaches are proposed in literature to minimize a sensor network’s energy consumption and thus to improve network lifetime: adjusting the transmit power depending on the distance to the receiver when sending messages [28], developing energy-efficient MAC or routing protocols [29–34], minimizing the number of messages traveling in the network, and putting some sensor nodes
into sleep mode and using only a necessary set of sensor nodes for sensing and communication [35].
Moving the sink node in the deployment region is another approach to prolong network lifetime, because this eliminates the hot-spot problem around the sink node [25,26].
[36] examines the sink mobility problem with multiple base stations. The main motivation behind this choice is to have more options for routing, thus reducing the hop-count to prolong network lifetime. The study presents two different integer linear programming (ILP) formulations to relocate the sinks (there are three sinks), one which has the objective function to minimize the maximum energy spent by a sensor node, and the other which has the objective function to minimize the total energy consumption in a round, subject to some constraints. The authors also examine the impact of the number of available base stations over the network lifetime and find that increasing the number of base stations beyond a certain threshold does not improve lifetime. This is because when the number of base stations is increased to a sufficient number, each sensor node can transmit messages to one of the base stations by direct communication.
Mobility algorithms and routing are considered together in [20]. It is assumed that sensors are densely deployed within a circle with a Poisson distribution. The authors define the network lifetime as the time until the loss of coverage starts. They specify a linear programming (LP) formulation to minimize the load on each one of N sensor nodes. In their solution, they first find the optimal mobility strategy by fixing the routing strategy as shortest path, then using the resulting strategy they try to find a final routing scheme with better performance than shortest path. The authors prove that the optimal mobility strategy is the trajectory around the periphery of the network. They find a better routing strategy by concentrating on an inner circle in the network area and develop a heuristic based on this. However, since they do not compare their results to any other mobility approach, we are unable to judge the relative performance of their scheme. The main drawback of their work is the assumption that the network region is circular. There is no explanation of how the solution may be adapted
to other region types.
A work more similar to ours is presented in [21]. In this paper, N sensor nodes and a sink node are randomly deployed to an area of interest. It is assumed that each sensor node generates data with a constant rate and there is a certain set of locations where the sink can move. The authors present two complementary algorithms for solving the sink mobility and routing problem. One is a scheduling algorithm that determines the duration for each candidate sink site where the base station can stay, and the other is a routing algorithm that determines the most energy-efficient path from each sensor node to the sink. An LP formulation is given which maximizes the sum of sink sojourn times at all possible locations (subject to some constraints) and mobile and static sink approaches are compared with different routing schemes. The simulations use two scenarios, including just four and five sink sites. These are quite limited scenarios. The authors also perform experiments by adding a routing parameter.
In [37], the authors give a routing algorithm, mobiroute, to route data towards a mobile sink for improving network lifetime. Mobiroute extends MintRoute pro-posed by [38] by adding functions to perform some operations like notifying a node for link failures, informing all nodes about topology changes, and minimiz-ing the packet loss durminimiz-ing mobility. They propose a two-phase adaptive algorithm to control sink mobility. In initialization phase, mobile sink builds a power con-sumption profile for each anchor point and drops some of them if their weights are low. In operation phase, the mobile sink stays at chosen points and updates profiles. Simulation results show that making the sink mobile improves network lifetime without sacrificing reliability in packet delivery.
The work of [22] is a detailed study about controlled sink mobility. The au-thors present a centralized mixed integer linear programming (MILP) model that determines sojourn times and the order of visits to sink sites. Moreover, they de-velop a distributed and localized heuristic called greedy maximum residual energy (GMRE), as a solution to the problem. The network model is similar to the one given in [21], but unlike that model, the deployment area is divided into grids and the corners of these grids are determined as sink sites. The authors introduce
two parameters to make the model more realistic: a dmax parameter represents
the upper bound for the distance the sink can travel between the current and the next site, and a tmin parameter defines a mandatory time the sink is required to
stay at a site. The authors evaluate the performance of MILP, GMRE, random movement (RM), and static sink (STS) schemes. The first two give better re-sults than the others, with MILP performing 30% to 50% better than GMRE for increasing tmin values.
Optimal sensor deployment, scheduling, routing and sink mobility are all con-sidered together for maximizing lifetime in [39]. The authors give a mixed integer linear programming model, which considers the aforementioned parameters to-gether to maximize network lifetime. However, the authors present also two heuristics, since current state-of-the-art MILP solvers fail to solve problems with realistic size in an acceptable time frame. The period iteration heuristic (PIH) limits the number of total periods and increments it one by one up until no fur-ther improvement is achieved. The sequential assignment heuristic (SAH) solves three different subproblems for determining the values of sensor locations, activity schedules, and routing decision variables.
Although centralized algorithms are proposed in previous works, [40] presents a distributed algorithm for delay-tolerant wireless sensor networks. The authors aim to maximize the number of tours (T ), where each tour takes D (maximum delay tolerance) time units. They propose delay tolerant mobile sink model (DT-MSM) and decompose it into three subproblems. These algorithms are then combined to a main algorithm and convergence analysis is done. Experimental results are presented to verify the validity of the algorithm.
Previous works that use (M)ILP force the authors to limit the number of sink sites and the number of nodes in their simulations. For example, [36] uses maximum 30 nodes while [21] uses 100 nodes. Since solving IP or MILP is NP complete [41], increasing the number of nodes will cause a dramatic increase in deciding sink movements. WSNs, however, are likely to contain tens of thousands of nodes, especially as the cost of sensor nodes becomes cheaper. Additionally, since sensor nodes do not have large buffer capacities, most nodes will not be
able to tolerate long latencies, which will cause a large packet loss rate. In such cases, heuristic algorithms are more efficient and more effective than an optimal solution. Therefore, in this thesis, we focus and provide heuristic algorithms that can be used during network operation. Our algorithms maintain a node-load table and give decisions based on such a table instead of performing long and static pre-calculations for optimal results.
2.2
Tree-based Topology Construction
Data gathering/collection is an important task in wireless sensor networks, since nodes are mostly deployed to a region of interest to learn about some environ-mental parameters like temperature or humidity [42]. Several logical topology types are proposed in literature to collect information from sensor nodes to the sink. [43] classifies these topologies into five categories: flat/unstructured topolo-gies, chain-based topolotopolo-gies, cluster-based topolotopolo-gies, tree-based topolotopolo-gies, and cluster-tree topologies.
Flooding or gossiping is used in a flat topology to establish paths on demand to forward data packets toward the sink. SPIN [44] and Directed Diffusion [45] are well-known protocols that use flat/unstructured topologies. A chain is con-structed and a node is selected as the leader in a chain-based topology. Other nodes communicate with each other and with the sink using this chain. PEGA-SIS [46] is an example that uses chain-based topology. A hierarchical structure is constructed in a cluster-based topology (CBT). Cluster heads (CH) are elected and clusters are formed in the region. Sensor nodes become cluster members and send their data to CHs to be forwarded to sink. LEACH [47] and HEED [48] are important algorithms utilizing cluster-based topologies. In a tree-based topology, which is also used in our work, nodes select parents and construct a logical tree topology rooted at the sink node. Finally, cluster-tree topology (CTT) is a hybrid type, which combines clustering and tree formation. A designated device (DD), a special node with higher transmission power, is selected to act as a cluster head. Nodes are added to DD to form a cluster-tree using the beacons they receive
from the neighbors. Cluster-Tree Data Gathering Algorithm (CTDGA) [49] is a solution based on cluster-tree topology.
Tree-based topologies have pros and cons compared to other alternatives. Tree-based topologies consume less power than flat topologies and save more en-ergy compared to cluster-based topologies via avoiding packet flooding [43,50,51]. However, tree formation is costly and is not resilient to node failures. Therefore, tree maintenance has high overhead when sink changes locations.
Data aggregation, combining data and applying some aggregation functions like sum or average, is an important design parameter when designing a tree topology formation algorithm. Usage of data aggregation depends on application scenario. It can be applied when average temperature of a region is queried, for example. On the other hand, data aggregation cannot be considered when col-lecting images from different regions of a battlefield [52]. When data aggregation is used in a WSN, each node sends one packet to its parent at each round, re-gardless of its number of descendants. When aggregation is not used, however, nodes closer to the sink node suffer from unbalanced packet load, since they not only send their packets but also forward the packets of their descendants.
Lifetime improvement with data gathering and aggregation is widely investi-gated in the literature [53–62]. In this thesis, we assume that data aggregation is not used and therefore we provide solutions for no-aggregation scenarios. We will not go into details of works that assume data aggregation, however, [63] is no-table here, since the proposed algorithm gives near optimal results in constructing maximum-lifetime data gathering trees.
Constructing tree topologies without data aggregation is not investigated as much as the ones with data aggregation. [52] gives a Ω(log n/log log n) approx-imation algorithm to solve this problem. The authors formalize the problem as finding a maximum lifetime tree (min-max-weight spanning tree) among multiple trees to maximize the network lifetime via balancing the load in bottleneck nodes as much as possible according to their energy levels. This problem is similar to capacitated spanning tree problem, i.e., finding a minimum weight spanning tree
in which every subtree contains fewer than K vertices, which is an NP-complete problem. The authors give MITT algorithm, which is near-optimal, to solve con-structing maximum lifetime tree for data gathering without aggregation problem. The algorithm starts with an arbitrary tree by using breadth first traversal on the network. The capacity of each node in its ability in serving number of descendants proportional with its remaining energy value is calculated. MITT algorithm sorts the nodes with respect to their weights in decreasing order and the weights of the nodes with lower capacities are transferred to the nodes with higher capacities. Experimental results show that MITT provides better network lifetime compared to other data gathering algorithms, such as PEDAP, MNL, etc. However, its run-ning time is much longer than those algorithms, especially when number of nodes increases.
An exact algorithm for maximum lifetime data gathering tree is given in [64]. First, the authors prove that the problem cannot be approximated within a factor greater than 2/3. They decompose the problem into two subproblems to reduce the search space when scanning all spanning trees to find an optimal spanning tree. The algorithm has three parts. In the first part, a partial spanning tree is initialized. Graph is decomposed into several blocks, each block is solved and solutions are merged in the second part. In the last part, edges are tried to be included into the tree. The algorithm has O(nm) space complexity, where n is the number of nodes and m is the number of edges. However, the algorithm runs in exponential time in the worst case. Simulation results show that MITT algorithm [52] runs faster than the exact algorithm and gives results close to the optimal in most of the cases. However, MITT’s worst case is poor, since it can give results less than half of the optimal in some cases. The running time of the exact algorithm is considerably faster, taking a few seconds, than enumerating all spanning trees, which may take several hours.
[65] gives another centralized algorithm for constructing maximum-lifetime data gathering tree. The authors classify the nodes with respect to their packet loads: high, medium, and low. MLTTA algorithm starts with an initial tree. Each node level and initial parent are selected during this step. The class of each node, high, medium or low, is determined using load calculation formulas.
The descendants of high-load nodes are transferred to low-load nodes as much as possible to balance the load among the nodes. This transfer operation is repeated until each of the high-load node’s descendants are assigned to low-load nodes. The authors compare the performance of MLTTA algorithm with breadth first traversal (INITA) and randomly generated tree (NAIVE). Experimental results show that it improves the lifetime compared to INITA and NAIVE when sink is at the center, but the gap is closed when sink is located at the corners. Although [65] is not comparing its algorithm’s performance with MITT algorithm, results in [66] show that the lifetime achieved using MLTTA algorithm is about one third of MITT’s performance.
Aforementioned algorithms that are given for constructing energy efficient data gathering trees are all centralized. Weighted Spanning Tree Distributed Opti-mization (WSTDO) algorithm, which is a distributed algorithm performed lo-cally on the spanning trees, is given in [66]. Authors first categorize the nodes according to their load or energy levels. Red nodes are bottleneck nodes and have large load or low energy. Grey nodes can be bottleneck nodes if they would accept more load. Green nodes have low load or high energy. Weights can be transferred from red nodes to green nodes. WSTDO consists of four phases: ini-tialization, tree maintenance, tree optimization, and data transfer. Initial tree is constructed in initialization part. Current topology information is collected and possible cycles are detected and recycled in tree maintenance phase. Nodes’ loads are locally optimized by using capacity calculations. Finally, data is trans-ferred over the constructed tree in previous phases. WSTDO performs worse than MITT algorithm. Its performance is almost same when compared to MLTTA. However, it has less overhead, especially for sparse networks, and handles node and link failures locally.
2.3
Multiple-Sink Mobility
Although it has not been investigated as much as its single-sink counterpart, there are some studies about the multiple-sink mobility problem.
[67] presents one of the earliest works about the multiple-sink mobility prob-lem. The authors divide the sensor network lifetime into equal periods of time, called rounds, and relocate the sinks at the start of each round. They present an integer linear program (ILP) that minimizes the maximum energy spent in each round in order to determine the locations of the sinks. A variation of this model minimizes the total energy consumption in a round. They compare these two ILP formulations as well as the random and static-sink approaches. Minimizing the maximum energy spent increases network lifetime significantly compared to other approaches.
[27] also deals with the multiple-sink mobility problem. The authors choose feasible sink-site locations along the periphery of the field and propose three heuristics, Top-Kmax, Max-Min-RE, and MinDiff-RE, to determine the sojourn
points of the sinks in each round. In Top-Kmax, K sites are chosen, in which
the nearest neighbor nodes have maximum residual energies. The Max-Min-RE heuristic aims to maximize the minimum residual energy for all combinations of sink sites and sinks for a given routing algorithm. The MinDiff-RE method uses the same approach as Max-Min-RE, except the goal is to minimize the difference in residual energy. Experiments show that MinDiff-RE gives better network lifetime compared to other approaches. Although these heuristics are presented as energy-efficient and low-complexity algorithms, Max-Min-RE and MinDiff-RE need to process all combinations before selecting the next migration points. These methods can be practical for small values of number of sinks and sites. However, in typical scenarios, for instance for 30 sink sites and 8 sink nodes, there may be millions of sink-site combinations to consider, which makes these solutions impractical.
[68] proposes a linear programming (LP) model as well as centralized and heuristic algorithms for multiple-sink mobility problem. Any combination of s sinks occupying s locations among k sites is called a configuration. The authors define an LP model with the goal to find a sequence of configurations that maxi-mizes network lifetime. Although the LP has exponential number of constraints, the authors use a separation algorithm to resolve the LP a polynomial number of times. They also give a centralized heuristic that uses the output of the LP and
runs in polynomial time. Finally, authors define a deployable distributed heuris-tic for coordinating the motion of multiple sinks throughout the network. The simulation results show that the proposed schemes improve lifetime significantly compared to static-sink case and random mobility.
[69] formulates the network lifetime maximization for the h-hop constrained multiple-sink mobility problem such that the total travel distance of each sink is bounded by L and the maximum number of hops from each sensor to a sink is bounded by h, where h ≥ 1. The authors show that the problem is NP-hard and propose a three-stage heuristic for calculating the sojourn time at each location for K mobile sinks. In the first stage, the sojourn time profile at each h-feasible configuration is determined using a linear program. Then, optimal trajectories for each mobile sink are built via greedily adding h-feasible configuration if the benefit to the network lifetime is maximized. Finally, the exact sojourn time in each configuration is calculated using another linear program. The experimental results show that the proposed algorithm performs at up-to 93% of the optimal solution.
In [70], the authors propose a multi-sink relocation algorithm with several com-ponents. They adopt a centralized approach for the routing methodology. Link weights are computed using a cost function, and finally a mathematical model is given for determining optimal sink positions, i.e., network configuration. The authors use a local search algorithm for determining local optima in the solu-tion space. The experimental results are presented around emphasizing mobility utilization compared to stationary sinks.
Chapter 3
Traffic and Energy-Load–Based
Sink Mobility Algorithms for
Wireless Sensor Networks
Sink mobility is among the most effective solutions to improve network life-time [71]. This solution aims to solve the hot-spot problem, in which a sink’s first-hop neighborhood suffers from quick energy depletion due to high rate of message forwarding [16]. In order to distribute the load among sensor nodes in the network, it is common in the literature to move sinks (base stations) and change their first-hop neighbors periodically to balance energy consumption as much as possible.
In this chapter, we propose time and space efficient algorithms that incorporate different parameters into account while determining the next position the sink has to move. More specifically, our proposed algorithms consider parameters like distance among nodes or packet loads of nodes, and collect these parameter values into a matrix structure, i.e., a table, to schedule the movement of the sink.
Without loss of generality, we use tree-based deterministic routing such that each node sends its own packet and relays its children’s packets to the same parent
for a given sink site. Necessary parameters are learned by the sink node with a training phase so that the same routing tree is constructed in each visit of the sink node to the same location. This method enables us to construct a packet traffic load matrix structure T of sink locations (rows) and nodes (columns) such that each entry (tij) in the matrix lists how many packets node j would send
and relay for a given sink location i. This brings us to our first approach, the packet-load based movement algorithm (PLMA). This algorithm basically uses and updates the packet traffic load matrix to choose the next sink site.
In our second approach, i.e., in energy-load–based movement algorithm (ELMA), we use computed energy expenditure values in the matrix instead of only packet load values. This model is more accurate than the PLMA, since it differentiates between sending the same number of packets to a farther or nearer parent. Otherwise it uses the same approach as the PLMA in choosing the next sink site. We also give an IP formulation for the problem and we use its solution as a benchmark to judge the performance of our algorithms.
We performed extensive simulation experiments to compare our algorithms with random sink movement (RAND), with a min-max (MM) approach, in which the sink learns about the minimum remaining energy values of each site and moves to the one with the maximum energy, and static sink case (STS). The results show that ELMA algorithm performs up to 80% better than the random movement and 100% better than min-max approaches. It also provides more than a five times longer lifetime compared to the static sink case. ELMA is just below five percent of the optimal value, however, it has better latency compared to the optimal (OPT) and has shorter running time. Lastly, we adapt the solution to the multiple-sink case, where we have multiple mobile sinks that can move to utilize energy in a better manner. In this case, the rows of the matrix become possible combinations of sink sites. Our simulation results for this case show that ELMA algorithm performs better than the random movement method by up to a factor of 2.1. This ratio increases to 2.6 when the nodes are not uniformly deployed.
The rest of the chapter is organized as follows: In Section 3.1, we give the system model. We present our algorithms in Section 3.2 and 3.3. In Section 3.4,
we give and discuss our performance evaluation results. Finally, we conclude the chapter in Section 3.5.
3.1
System Model
We consider a wireless sensor network that has n static sensor nodes and a mobile base station (sink). We assume there are p different site alternatives that the sink node can visit and stay. Sensor nodes are deployed to the region of interest in a random manner. There is a training phase, as in [68], such that mobile sink visits all sink sites once before network starts its operation. After the mobile sink moves to a location i, it stays there for a while and constructs a routing tree by initiating the flooding of a control packet in the network. Each node receiving the packet sets its parent and re-broadcasts the packet after adding its ID to the packet. In this way a routing tree is formed. Each node saves this parent ID for that specific sink location to transmit its packets every time sink visits that location. Nodes also notify their parents about their decisions so that parents can calculate how many packets they will relay when sink is at that location i. Each node sends this packet count information to the sink during the training phase. Sink uses these values to construct matrix T , either directly for packet load matrix, or applying the energy model to calculate energy expenditure to obtain energy load matrix. When sink moves to a new location it does not initialize routing tree reconstruction process, instead sends the sink location ID to the nodes. Since nodes know which parent to select for each sink location, they send the packets destined to this node while sink stays at that location.
After tree formation, nodes start to sense the environment. Each sensor node generates packets with a rate Q. We assume that each sensor node has enough buffer size to avoid losing packets during the travel of the sink from the current site to the next one, or this time is ignored as in [21,22,40]. In this work, we define network lifetime as the period of time until the first node dies, which is a common definition in the literature.
3.2
Proposed Algorithms
As mentioned in the previous section, sink node moves to each possible sink migration point and constructs a tree-based routing topology rooted at itself for each point during training phase. In this way, a packet-load matrix T is constructed such that tij is the number of packets that node j (oj) would send
when the sink is at migration point i (pi).
T = o1 o2 . . . on p1 t11 t12 . . . t1n p2 t21 t22 . . . t2n .. . ... ... . .. ... pp tp1 tp2 . . . tpn
Before this matrix is constructed, we need to know the possible sink migra-tion posimigra-tions, which can be determined by various algorithms [72]. For example, the region can be considered a grid and each grid cell can be a migration point. Alternatively, neighborhood information can be used in determining possible mi-gration points, moving the sink to dense neighborhoods, for example. Once the migration points are determined, there will be one row in the matrix for each pos-sible migration point. For each migration point, we compute the pospos-sible routing tree rooted at that point and compute what the packet-load of each node will be in the tree.
After these computations we know for each point i and node j what the packet load of the node, i.e., tij value of the matrix, will be at that point. In this way
we can construct the load matrix and the sink can schedule its movement before network operation begins. Pre-scheduling the movement is useful in reducing the time needed to travel to the next sink position, hence reducing the buffer requirement at sensor nodes and reducing the delay that packets will experience. We also modify the algorithm to consider not only the packet load on a node but also the energy cost of transmitting those packets to the next node, i.e., the
parent. Hence, our second algorithm is based on nodes’ energy expenditures for a given sink position.
3.2.1
Packet-Load Based Movement Algorithm (PLMA)
Our first algorithm aims to minimize the maximum number of packets sent by a node in each round. A round is the time duration the sink stays constant at a position (migration point). The pseudo-code of our algorithm is given in Algorithm 1.
In the algorithm, after we determine the possible migration points, the sink constructs a routing tree for each sink candidate position and calculates the num-ber of packets that each node will send to its parent in each round. In this way, the packet-load matrix T is obtained. After that, the algorithm determines the maximum value in each row, selects the row with the minimum value, and takes this row as the current packet list (cpl). We call this min-max search. The se-lected row corresponds to the position to move next. After the sink migrates to that point, it will operate there for fixed number of rounds or until a certain amount of change in the energy of its first-hop neighbors is detected. Then the sink updates matrix T by adding the current packet list value to each row of T and in this way obtains a new matrix U each time it makes a decision to move. Values in each row i of matrix U estimate the packet loads of the nodes if sink moves to location i. Sink again runs the min-max search over U to determine the new packet list value. This iteration continues until a node depletes its en-ergy. Sink keeps both matrix T and U to determine next location to move. T is constructed before network starts its operation and not changed. U is calculated each time sink makes a decision by adding cpl to each row of T . The selected row of U becomes the new cpl and it will be used to calculate matrix U when the next decision time comes.
The algorithm has O(np) preprocessing time complexity to insert the data into the matrix. In each round, we need O(p) operations to determine the sink’s next migration point.
Algorithm 1 Packet-Load–Based Movement Algorithm (PLMA)
1: Input: Node coordinates and transmission range
2: Output: Schedule of sink movements
3: procedure PLMA(c, tx) . c: node coordinates, tx: transmission range 4: p ← getM igrationP oints(c, tx)
5: for i ← 1, size(p) do
6: tt ← constructT opology(c, tx, pi)
7: for j ← 1, n do . for each node
8: tij ← ki . ki: # of packets to send for oj 9: end for
10: end for
11: for i ← 1, size(p) do
12: mp(i) ← max(ti) . max element for each row 13: end for
14: r ← min(mp) . index of minimum of maximums
15: cpl ← tr . initialize current packet list 16: while e > 0 do . all nodes are alive
17: for each round do
18: for i ← 1, size(p) do
19: ui ← ti+ cpl . current packet matrix 20: end for
21: for i ← 1, size(p) do
22: mp(i) ← max(ui) . max for each row 23: end for
24: r ← min(mp) . index of min of max
25: cpl ← ur . update current packet list 26: end for
27: end while
Each node keeps parent IDs for each sink location. Since node IDs can be represented in log(n) bits and there are p locations in the area, space complexity becomes p log(n) bits. For 500 nodes and 30 sink sites, it requires around 34 bytes to keep this array. This is acceptable since most of the nodes have more than 32 KB program and data memory [73]. Sink maintains a matrix of p × n, which requires O(p n log(n)) space. For 500 nodes and 30 sink sites, it requires around 16 KB memory to store this matrix. Sink nodes have more resources than sensor nodes. For instance, a sink acting as a gateway can have more than 1 GB RAM [74].
3.2.2
Energy-Load–Based Movement Algorithm (ELMA)
Our second algorithm is a slight modification of the first one in that it uses the computed energy load/expenditure of each node instead of the packet load. The second algorithm constructs again a matrix T , but this time, for each candidate sink point i, i.e., for each row, it computes how much energy the nodes would consume to transmit their packets to the next node in the routing tree for that sink position i. Each node piggybacks the remaining energy value to the sink node periodically. Sink stores these values in a residual energy row e. It subtracts each row i of matrix T from e to construct row i of matrix U . So, each row i of matrix U estimates nodes’ remaining energy values if the sink would go to site i in the next round. Hence, our second algorithm is energy based, where energy consumption is considered to be related both to transmitted packet count and to where the packets are transmitted.
ELMA (see Algorithm 2) becomes the dual of our first algorithm such that we should use max instead of min (and vice versa) and subtraction instead of addition. Using the energy-based approach is more meaningful if it is possible for a sensor node not to send the expected number of packets in each round. For example, some nodes may send more packets if an important event is detected, or some packets might be lost due to some node or link failures in the network. This model is more accurate than the packet-based approach because it takes
distance into consideration as part of the energy consumption model when sending a packet. When a node sends, say two packets, to different parents for different sink sites, the energy-based model has different values for each sink site, while the packet-based scheme has the same value (namely two).
Algorithm 2 Energy-Load Based Movement Algorithm (ELMA)
1: Input: Node coordinates and transmission range
2: Output: Schedule of sink movements
3: procedure ELMA(c, tx) . c: node coordinates, tx: transmission range 4: p ← getM igrationP oints(c, tx)
5: for i ← 1, size(p) do
6: tt ← constructT opology(c, tx, pi)
7: for j ← 1, n do . for each node
8: tij ← txi+ rci . tx and rx cost for oj 9: end for
10: end for
11: for i ← 1, size(p) do
12: mp(i) ← max(ti) . max element for each row 13: end for
14: r ← min(mp) . index of minimum of maximums
15: sc← pr . set sink’s next coordinate 16: while e > 0 do . all nodes are alive
17: for each round do
18: u ← e − t . update current energy matrix
19: for i ← 1, size(p) do
20: mp(i) ← min(ui) . min for each row 21: end for
22: r ← max(mp) . index of max of mins
23: sc← ur . set sink’s next coordinate 24: end for
25: end while
26: end procedure
Like our first algorithm, our second algorithm requires O(np) preprocessing time to initialize the matrix with the energy loads of nodes at possible migration points. It needs O(p) time in each round to determine the next migration point for the sink. Sensor nodes’ overhead is same as in PLMA case. However, sink has to consume more space to keep the energy matrix. It requires p N log(E) bits, where E is the initial energy value in microjoule. For 500 nodes, 30 sink sites, and 10K microjoule it requires around 26 KB to store energy matrix.
3.2.3
Mathematical Model
We can consider this problem as a variant of the 0 − 1 knapsack problem. In this case, we want to visit each sink site (add item), each of which has a different value (energy consumption) in each dimension (node), as much as possible without exceeding the initial available energy value (knapsack capacity). Each sink site corresponds to a knapsack item, and each node represents a dimension of that item. In this way, the problem becomes an instance of the unbounded multi-dimensional knapsack problem [75]. In this version, each dimension (node) has the same limit (energy), and all profit values are the same (staying the equal number of rounds xi at different sink sites contributes equally to the network
lifetime).
We can formulate the problem also as an IP formulation:
max m X i=1 xi (3.1) s.t. m X i=1 tijxi ≤ e, j = 1, . . . , n
xi ≥ 0, xi integer, for all i = 1, . . . , m
It is shown that solving the unbounded multi-dimensional knapsack problem is NP-complete [76]. Finding a fully polynomial-time approximation scheme (FPTAS) for the problem exhibits the same hardness. We solved the above-formulated problem using the MATLAB CPLEX solver for obtaining optimal values for small networks to see how close our heuristics algorithms are to the optimum.
3.3
Multiple-Sink Case
We can also adapt our algorithm to sensor networks with multiple sinks. Instead of representing a single sink site, one row of the load matrix can be a combination of sink placements. For each combination of possible sink placement, sinks move to these points and routing trees are established using the approach mentioned in Section 3.1, with the only difference that each sink initiates a parallel broadcast process independent from other sinks. Each sensor node chooses the nearest sink and the shortest path to that sink after receiving the broadcast packets. At the end of this process, we have s different mutually exclusive (each node is connected to only one sink) and collectively exhaustive (no sensor node is disconnected) trees rooted at sink nodes.
If we have p migration points and s sinks in the environment, then the rows in matrix T become the enumeration of all possible ps sink placements:
T = o1 o2 . . . on {p1, . . . ps−1, ps} t11 t12 . . . t1n {p1, . . . ps−1, ps+1} t21 t22 . . . t2n .. . ... ... . .. ... {pm−s+1, . . . pm−1, pm} tm1 tm2 . . . tmn
The number of rows in matrix T is no longer m, but the number of possible combinations of ps = s!(p−s)!p! . The values in the matrix can represent the packet load or energy load on the nodes for a given position of sinks. We can apply our previous algorithms (PLMA and ELMA) to the new matrix for solutions to the multi-sink case.
The number of rows in the load matrix for the multiple-sinks case can be approximated by Stirling’s formula: √2πp(pe)p. Therefore, our multi-sink
algo-rithms have O(npp) pre-processing time complexity to initialize the matrix. In
each round (before each move), we need O(pp) operations to determine the next
Obviously, using these algorithms for large values of p and n is not feasible. However, they can be used for cases where the ps value is less than a threshold. We call this as binomial threshold (tb). What tb will be is a design decision
and should be determined by considering the storage capacity of sensor nodes to store the matrix. For a high number of sink sites, we can choose a subset of migration points. The size of that subset, ths, should be the maximum integer
where ths
s ≤ tb), The subset can be selected by using, for example, the k-means
algorithm. Then we can apply our PLMA or ELMA algorithm to this reduced matrix. We call these multi-sink algorithms that work with fewer combinations as MS-PLMA (Algorithm 3) and MS-ELMA (Algorithm 4), and show their pseudo-codes below.
Algorithm 3 Multiple Sinks Packet-Load–Based Movement Algorithm (MS-PLMA)
1: procedure MS-PLMA(c, tx) . c: node coordinates, tx: transmission range 2: p ← getM igrationP oints(c, tx)
3: if ps > tb then . tb: binomial threshold 4: p0 = kmeans(p, ths) . ths max int, thss ≤ tb 5: end if
6: P LM A(c, tx, p 0 s) 7: end procedure
Algorithm 4 Multiple Sinks Energy-Load–Based Movement Algorithm (MS-ELMA)
1: procedure MS-ELMA(c, tx) . c: node coordinates, tx: transmission range 2: p ← getM igrationP oints(c, tx)
3: if ps > tb then . tb: binomial threshold 4: p0 = kmeans(p, ths) . ths max int, thss ≤ tb 5: end if 6: ELM A(c, tx, p 0 s) 7: end procedure
3.4
Performance Evaluation
We implemented and simulated our algorithms in MATLAB to evaluate and compare them with some other approaches. In this section we discuss the results
of these simulation experiments. We compared our proposed algorithms (ELMA, PLMA, and their multiple sinks variants) against the optimal case (OPT) and other approaches (MM, RAND, and STS). Below we briefly describe all simulated and compared methods.
• OPT: Sink moves to the migration points and stays there according to the results given by the optimal model.
• ELMA: Sink visits sites as specified by our Algorithm 2.
• PLMA: Sink moves according to the results given by our Algorithm 1. • MM: Minimum energy values of sink’s first-hop neighbors are collected from
each site and sink moves to the one with maximum energy among them. • RAND: Sink selects a sink site randomly and moves to it.
• STS: Sink does not move but stays static in the center of the area.
We used the following two metrics in comparing these methods:
• Network lifetime: time until the first sensor node depletes its energy. This is a commonly used network lifetime definition.
• Latency: average hop count that a packet travels until it reaches the mobile sink node. We model latency as the number of hops traveled.
• Total distance: Total distance that mobile sink travels during the network lifetime.
3.4.1
Simulation Parameters
The sensor networks generated in our simulations have n static sensor nodes and one mobile sink. The sensor nodes are deployed randomly to a region of interest
