Coordinated movement of multiple mobile sinks in a wireless sensor network for improved lifetime

Abstract

Sink mobility is one of the most effective solutions for improving lifetime and has been widely investigated for the last decade. Algorithms for single-sink mobility are not directly applied to the multiple-sink case due to the latter’s specific challenges. Most of the approaches proposed in the literature use mathematical programming techniques to solve the multiple-sink mobility problem. However, doing so leads to higher complexities when traffic flow information for any possible sink-site combinations is included in the model. In this paper, we propose two algorithms that do not consider all possible sink-site combinations to determine migration points. We first present a centralized movement algorithm that uses an energy-cost matrix for a user-defined threshold number of combinations to coordinate multiple-sink movement. We also give a distributed algorithm that does not use any prior network information and has a low message exchange overhead. Our simulations show that the centralized algorithm gives better network lifetime performance compared to previously proposed MinDiff-RE, random movement, and static-sink algorithms. Our distributed algorithm has a lower network lifetime than centralized algorithms; sinks travel significantly less than in all the other schemes.

1 Introduction

Moving sink nodes (base stations or mobile agents) is among the most effective solutions to improve network lifetime in wireless sensor networks (WSNs) where sinks can move [1]. This approach aims to solve the so called hot-spot problem in a WSN, in which first-hop neighbors of sinks suffer from quick energy depletion due to a high rate of message forwarding [2]. In order to distribute traffic forwarding load as evenly as possible among all sensor nodes, sinks can be moved through the region so that all sensor nodes have nearly equal chance of being the first-hop neighbors of sinks nodes. In this way, data is collected in a mobile manner.

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 $\binom {p}{s}$. These make the multiple-sink 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 the 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 operation, and the solutions (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 occur in the area over the network lifetime.

In this paper, we present two low-complexity algorithms for multiple-sink mobility problem, multiple-sink movement algorithm (MSMA) and prevent and move away (PMA) algorithm. Our algorithms have low complexity and low overhead and therefore can be used directly with sensor nodes and mobile sink nodes.

Our MSMA algorithm runs in each sink node and relies on the energy consumption information of each sensor node for a subset of all possible sink-site combinations. Most algorithms in literature use traffic-load information for each possible sink-site combination as part of their solutions. Since the number of sink-site combination alternatives increases exponentially, it becomes impractical to calculate traffic-load for every sink-site combination for a large number of sites and sinks. In our MSMA algorithm, we address this problem, and we do not require enumeration of all possible sink-site combinations. Our algorithm uses a threshold and limits the number of combinations to consider for movement of sink nodes.

Our PMA algorithm is a totally distributed algorithm and does not require any prior information about the network and possible traffic-load of nodes for specific sink-site combinations. Each sink checks the residual energy values of its descendant nodes and forbids placement in sites nearest to these low-energy nodes. This information, as well as the minimum energy nodes available within the sites’ first-hop neighbors, are shared among sinks. Then, half the sites are selected according to these values. The other half of the sites are chosen to be far away from the previously selected sites so that sink nodes are not clustered to a particular sub-region in the area and the load is balanced as much as possible without collecting and using global network information.

The rest of the paper is organized as follows. In the next section, we discuss the related work about the multiple-sink problem. We describe the system model we used in Section 3. We present our proposed algorithms in Section 4, and we give the performance evaluation of them in Section 5. Finally, we give our conclusions in Section 6.

2 Related work

Different energy-efficient approaches in various network layers are proposed in the literature for improving network lifetime, such as power control mechanisms (physical layer) [3, 4], energy-efficient MAC layer protocols (data-link layer) [5, 6], data-gathering/routing protocols (network layer) [7–16]. Sink mobility is another approach for improving network lifetime. Sink mobility can be either uncontrolled or controlled, depending on the mobility scheme used [17]. In uncontrolled mobility, data MULEs (Mobile Ubiquitous Lan Extensions) move randomly in the area without considering any network parameter (such as nodes’ remaining energy). In controlled mobility, however, network conditions (nodes’ remaining energy, node density in the region, etc.) are taken into consideration. The controlled single-sink mobility problem is widely investigated in the literature [18–24]. Although it has not been investigated as much as its single-sink counterpart, there are some studies about the multiple-sink mobility problem.

Gandham et al. [25] presents one of the earliest works about the multiple-sink mobility problem. 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. Although authors give ILP formulations to find the optimal lifetime, the number of base stations is fixed to three. The solution is not scalable to a higher number of base stations, since the number of constraints increase exponentially.

Azad and Chockalingam [26] 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- K _max , Max-Min-RE, and MinDiff-RE, to determine the sojourn points of the sinks in each round. In Top- K _max , 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 make these solutions impractical.

Basagni et al. [27] proposes a linear programming (LP) model as well as centralized and heuristic algorithms for the 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 maximizes network lifetime. Although the LP has an 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 heuristic for coordinating the motion of multiple sinks throughout the network. The simulation results show that the proposed schemes improve lifetime significantly compared to the cases of a static-sink case and random mobility. Authors both give an efficient method for solving LP and a centralized heuristic for solving the multiple-sink problem. These methods enable them to make experiments of up to 8 sinks (for 16 sink sites). However, the proposed distributed heuristic requires a large amount of data exchange between the sink nodes. This can cause delay while determining the next migration point which makes it disadvantageous for delay intolerant applications

Liang and Luo [28] 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. Although, the authors give a strong heuristic for solving the problem, its complexity, O(m n k l o g n+n ² k+k ³) (m number of edges, n number of nodes, k number of sinks), makes it infeasible to be used dynamically in real sensor nodes.

In [29], the authors propose a multi-sink relocation algorithm with several components. 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 solution space. The experimental results are presented around emphasizing mobility utilization compared to stationary sinks. Authors give an efficient mechanism to place the sinks; however, they do not consider mobility and sojourn times of the sinks for each possible sink location. This makes it usable for the cases where the sinks are placed once and do not change their positions.

3 System model

We consider a sensor network with n stationary sensor nodes deployed to an area of interest. The set of sensor nodes is denoted with |N|=n. There are s mobile sink nodes in the environment, which may change their locations periodically according to network conditions. Sinks choose these locations from a predetermined sojourn point set P, where |P|=p. Each sensor i∈N has a packet generation rate of Q packets per second.

Tree-based routing is used such that each sensor node sends its own packet and relays its children’s packets to the same parent for a given sink-site combination. Sinks learn the related parameters in a training phase so that the same routing tree is constructed in each visit to the same site combination. This method enables us to construct an energy-load matrix structure T of sink-site combinations (rows) and nodes (columns), such that each entry t _ij in the matrix lists how much energy a node j would consume to transmit its packets to its parent in the routing tree for a given sink-site combination i.

Sink sites (sojourn points) are either predetermined or chosen using a sink-site determination method. Some example methods are given in [30]. Those sink sites are associated with each sink using a method that we explain in the next section. Sinks visit those sites (combinations) together and start the topology tree formation process to construct their matrices if the sensor nodes’ positions are not known a priori.

In this phase, each sink broadcasts a packet to construct a tree rooted at that sink. This packet contains the sender ID (the node ID that broadcasts the packet), topology ID (indicates the current sink combination - unique for each combination), hop count (0 for sink, and incremented by one for each received node), and sink ID (the node that initiated the topology). An example of this packet structure is given in Fig. 1. This tree-topology is constructed by sink with ID 0 (s ₀), when sinks sojourn at certain positions specified by combination 81. In this example, node 2, n ₂, constructs a packet with its ID 2, combination ID 81, its logical level 3, and its sink ID 0.

Fig. 1

Sample topology and broadcast packet

The sinks’ first-hop neighbor receiving those packets set the sink ID as their parent ID. These packets are re-broadcast after incrementing the hop count (count to the sink). When a sensor node receives such a packet, it first checks its current hop count to the sink; if it is not set or is bigger than that of the received message, it updates its hop count and sets the sender ID as its new parent ID. This process continues until all nodes in the area have received these topology set-up packets. When the tree has been set up, each sensor node saves the topology ID and parent ID pair to remember which node to send to when sinks select the same combination at any time over the network lifetime.

When a node receives a packet from a different sink, it saves its ID and hop-count to the sink even if this hop-count is bigger than its current value. It becomes a junction node and it informs all the sinks it receives packets from. These junction nodes can be used for two different purposes: sink communication and topology maintenance.

If junction nodes are known by the sinks, then those sinks can reach each other using the paths through junction nodes. Although sinks have higher transmission power than sensor nodes do, sometimes they can be far enough from each other that direct communication cannot be achieved. In these cases, using those junction nodes help sinks exchange information for the next site selection decision or for remaining energy values.

In delay-intolerant applications, it is always critical for sensor nodes to send their data to an available sink (anycast) instead of buffering it. Multiple sinks do not move just exactly at the same time since at least one of the sinks must stay to gather the sensor nodes’ data. When a sink decides to move, it informs its neighbor nodes and sends a re-connect request packet to this junction node indicating that the junction node should connect to another network. The sink’s first-hop neighbors change their parents toward the junction node. For the subtree that junction node belongs to, its ancestor, which is one of the sink’s first-hop neighbors, reverses the packets’ direction. For other subtrees, rooted at the sink’s other first-hop neighbors, these nodes forward their packets to the junction node’s ancestor, until a new topology construction packet with a smaller hop-count value is received by the nodes, which means that a sink arrives at its new location. There are some works about mobile dynamic tree construction and maintenance, such as [31–33]; however, this topic is beyond the scope of this paper.

4 Proposed algorithms

As mentioned in the related work section, most studies about multiple-sink mobility in the literature use linear/integer programming formulations to achieve optimal values of network lifetime.

These methods, however, cannot be used by sink nodes on-the-fly during network operation, since they require a huge amount of computation which sink nodes cannot achieve with the current technology. In this chapter, we want to present algorithms that do not require too much complexity, but still achieve considerable lifetime improvement compared to random movement and static-sink cases.

4.1 Multiple sinks movement algorithm (MSMA)

Our first algorithm to coordinate the movement of multiple mobile sinks for improving network lifetime is called MSMA. The algorithm extends our earlier algorithm MS-ELMA [34]. We improve the method of limiting the possible position combinations before the network begins operation. We also change the algorithm to add limited combinations on-the-fly to further improve its performance.

Algorithms proposed to solve the multiple-sink mobility problem usually consider the amount of traffic (directly or indirectly) between nodes when sinks are placed at certain locations/sites [26, 27]. Assuming that each different sink placement is a sink-site combination, a set of sinks has many possibilities to get placed into these locations. When sinks are placed according to a combination k and routing trees are formed from sinks to nodes, the traffic from a node i to its parent node j can be denoted with x _ijk . Knowing x _ijk values for all possible site combinations as well as the current remaining energy values of nodes help us to select the best alternative site combination to move because we can see how the nodes’ energy values will be affected if sinks would move to a specific site combination. However, calculating x _ijk values for all possible site combinations before the network starts its operation can take a very long time, which is not feasible for reasonable p and s values, such as 50 sink sites and 7 sinks.

Since choosing s points among p alternatives increases exponentially, the main idea should be to decrease those alternatives as much as possible to reduce complexity without sacrificing lifetime improvement.For instance, choosing seven locations among 50 alternatives generates approximately 10⁸ alternatives. In our algorithm, we require all sinks to make a decision about their next migration points using their information, which are further evaluated, and a final decision is made collectively.

Each sink uses an energy-expenditure matrix in which each element t _ij corresponds to the energy required at a node j to transmit packets to its parent when the sink nodes are in position-combination i, i.e., the combination tuple - (p ₁,p ₂,…p _s ). The number of columns of this matrix apparently equals the number of nodes n in the network. The number of rows, i.e., the number of position combinations, is, however, a parameter in our algorithms, which can be determined using sink characteristics. This is called binomial threshold and is not directly involved in our algorithms, instead affects the t h _s parameter (threshold for each sink), which determines how many migration points each sink will select to calculate different combinations. In other words, t h _s is the maximum integer satisfying $\binom {{th}_{s}}{s} \leq t_{b}$, where s is the number of sinks and t _b is the binomial threshold. If we select t _b as 2000, then t h _s becomes 13, when the number of sinks is eight, since $\binom {13}{8} = 1287$.

After determining these parameters, we select the possible migration points for each sink. There will be a total of s groups of points. For a sink, we assign possible migration points from different regions of the area. First, we determine the number of points (k) to assign for a sink. It is given by k = p/s. Then, we start using the k-means algorithm to select migration points for sinks. For the first sink, we run the k-means algorithm considering the whole migration point set. Given the whole point set (p points initially), the k-means algorithm selects k centroids (positions), and the k migration points with minimum distance to these k centroids are assigned to the first sink. We remove these selected positions from our point set, and we continue to select points for the next sink by re-running the k-means algorithm to select another k centroid from the remaining point set. This process continues until all points are partitioned among the sinks. If the allocated number of points is smaller than the predetermined threshold value, then new points are assigned randomly to close this gap.

After each sink has its group of sites, i.e., possible position-combinations to move, it will construct an energy-load matrix. For each candidate sink-site combination i, that means for each row, the algorithm computes how much energy the nodes would consume to transmit their packets to the next node (parent) in the routing tree for that combination i. If coordinates of the nodes are known a priori, these matrices can be constructed by a central authority, i.e., via one of the sinks. The other option is to visit those location combinations and form topology trees for each combination to determine the child-parent relationship and energy expenditure values to construct matrices in a training phase, as in [27], before the network starts operation. Each sink keeps its own matrix that has $\binom {{th}_{s}}{s}$ rows and that includes combinations of the points previously assigned to it. Sinks use these matrices to take role in point selection process. Combination with best value is selected for next migration point collectively. Therefore, sinks are not limited with the points in their matrices and instead can go to any point in the area according to the solution given by the algorithm.

Sinks use the nodes’ remaining energy values and the energy-load matrix to determine the next migration points. The sensor nodes’ remaining energy values, e, can be represented as an nx1 matrix (a vector or a row). Sinks share their descendants’ values with each other to make the row complete for all entities. Each matrix row indicating a sink-site combination is subtracted from this remaining energy row to project the nodes’ remaining energy values if sinks would move to those locations in the next round. The sinks focus on the minimum values of each subtracted row and select the maximum of them. These values, i.e., the maximum remaining energy values and sink-site combinations, are sent to the sink with the minimum-ID through either single-hop or multi-hop communication. If multi-hop communication is needed, then junction nodes are utilized. A sink compares the received values with its own and sends the one with the maximum value to the other sinks. Last, the decisive sink compares all received values and picks the maximum. Then, the selected migration point information is sent back to the sinks in the reverse direction.

In the MSMA, sinks can also select migration points randomly but with a small probability (s/100). Since the algorithm starts with fewer combinations, it is a good idea to increase these combinations without exceeding the t _b value. But more importantly, since the topology is constructed at the selection, the algorithm should take advantage of the sensor nodes’ current remaining energy information. Instead of using the topology constructed using full energy levels (prior to the network beginning operation), sinks can construct more energy-efficient topology trees using the nodes’ current residual energies. Since sinks use this option rarely, selecting those sites randomly is a good choice because it decreases decision time and message overhead. The procedure is summarized in Fig. 2.

Fig. 2

Flowchart of MSMA

Although the next migration points have been determined, which sink is going to exactly which point has not been set. This decision can also made by the same sink, since it knows the current location of each sink. Sinks should inform other sinks about their locations to prevent two or more sinks going to the same location. This is the well-known assignment problem, and the Hungarian method can find the optimal solution for assigning the sinks to new locations with O(n ³) complexity [35].

After sinks migrate to the new points, they will operate there until either a certain amount of change in the energy of its first-hop neighbors is detected or a fixed number of rounds - t _min - has been achieved. Then, when the sojourn time expires, sinks share their children’s remaining energy values with each other and again run the max-min search over the matrix to determine new migration points. This iteration continues until a node depletes its energy. The algorithm is detailed in Algorithm ??. It takes O(n t _b ) to construct the energy load matrix. In each round, we need O(t _b ) computation to determine the sinks’ next migration points.

4.2 Prevent and move away (PMA) algorithm

In this section, we describe our distributed prevent and move away (PMA) algorithm, which is fully distributed and does not require excessive information exchange. As explained above, the current schemes proposed in the literature consider the amount of traffic passing through each node to its parent while sinks are at specific sites. Although this approach improves network lifetime significantly, considering all possible sink-site combinations is computationally expensive. Therefore, it is important to also come up with algorithms which do not require evaluation of so many combinations and distributing the related information while selecting next migration points.

Although there are a few distributed algorithms that attempt to solve the multiple-sink mobility problem, most require a large amount of data exchange, e.g., nodal residual energy, nodal data rate, energy needed to communicate packets for the whole network, as in [27]. Transferring such a large amount of data in each round causes excessive energy consumption in resource-constrained sensor nodes. Therefore, it is very important to find a low complexity and an efficient heuristic that requires minimum information exchange to decide sink movements and that can be run on sink nodes, which is what we achieve with our PMA algorithm.

Our PMA algorithm first filters out the sites closer to the nodes that have relatively lower residual energy compared to other nodes in the network. We do this because we only want to consider the sites close to high energy nodes as possible migration points so that when sinks migrate to those points, the high energy nodes will take the majority of the traffic-forwarding load since they will be at the highest level in the routing trees. PMA also t next migration points. The selected points should not be very close to each other, since moving all sinks to the same sub-region is not useful and makes the routing paths to the majority of sensor nodes to be excessively long. Therefore, we provide a balance between energy and distance while considering the next migration points. We select half of the sites to be close to high-energy nodes and the other half to be far away from these selected sites. In this way, the selected sites are tried to be evenly distributed to the whole sensor network region and are not clustered to a sub-region.

In PMA, the next migration points for sinks are determined as follows at each round of sink site determination. At the end of the current round, before determining next migration points for the next round, the sinks are at some locations, and their combined routing trees span the whole network. Each sink has its own routing tree spanning a portion of the nodes in the network. These nodes are considered to be the descendants of that sink. The routing trees of sinks do not overlap.

Each sink knows its descendants and their remaining energy levels (residual energy information is piggybacked into the data packets). Each sink selects the m _p percent of the minimum-energy nodes among its descendants, where m _p is a design parameter. The sink then determines the nearest sites to those minimum energy sensor nodes to filter out for the next round. These filtered out sites are forbidden. All sinks then exchange this forbidden site information among each other. This requires a total of s(s−1) message exchanges among sink nodes. Each sink then aggregates the forbidden site information coming from other sinks (takes the union) and in this way obtains a forbidden site list for the whole network. The remaining sites are allowed sites and can be used as possible migration points for the next round. Since the forbidden sites can be significant portion of the original point set, we use a parameter called forbidden point threshold (t _fp ) to control its size. The total number of forbidden sites can not be bigger than this threshold. The introduction of this threshold eliminates the possibility of having the number of allowable sink sites to be less than the number of sinks s. Additionally, filtering out too many sites without global network information (like the energy matrix in the MSMA or MinDiff-RE) can eliminate advantageous sites to move to.

When a sink decides its forbidden sites, that means it decided on its allowable sites. For each allowable site in the region of its routing tree, the sink considers the sensor nodes around the site and finds out the node with maximum remaining energy. This minimum energy level is associated with that site. Then, the sink selects the first s/2 sites that have the largest associated minimum remaining energy levels. In other words, the first s/2 sites are selected when sites are sorted in decreasing order with respect to their associated minimum energy levels. We call these as max-min sites. They are good positions for sinks to move next. Then each sink sends s/2 max-min sites together with the corresponding energy values to a designated sink (minimum ID sink, for example). This requires a total of s−1 message transfers to the designated sink. In this way the designated sink collects s(s−1)/2 max-min positions. It then selects s/2 of them, i.e., the first s/2 sites with largest associated minimum-energy values.

After this selection, the remaining s/2 sites are determined one by one according to the total distance to previously selected sites. First, distance to each of the s/2 previously selected sites is calculated to determine total distance value for each remaining allowable site. The site with maximum value is selected as the (s/2)+1st point and added to the previously selected site list. The iteration is done for each site until all remaining s/2 sites, that are far away from each other, are determined. This process is sequential since determining the remaining s/2 sites once (from the sorted list according to the maximum distance) can cause selecting sites near to each other.

After s sites are selected, s sinks are assigned to these sites using the well-known Hungarian assignment algorithm, like in the MSMA. This minimizes the total distance traveled while sinks move to the assigned sites afterwards. The other alternative is to notify the nearest sink to move as each sink site is determined, if network is delay-intolerant or movement cost is not very significant.

In this way, the algorithm finds a balance between the energy and distance components of the problem. It takes the energy values of the nodes into consideration in the first part by removing the sites close to low energy nodes. It also increases the distance between sinks to balance the forwarding load of the sensor nodes. The process is detailed in Algorithm ??. In each round, we need O(s) computations to determine the next migration points.

In the PMA algorithm, each sink shares the site IDs of the forbidden sites (t _fp sites for each sink, in the worst case), as well as the s/2 minimum energy values (with site IDs) in each movement decision. This corresponds to O(t _fp l o g p) and O(s (l o g p+l o g E)) (where E is the initial energy value) storage complexity, respectively. For 50 sink sites, 4 sinks and 10 joules (t _fp becomes 10), it requires 60 bits for each sink to share t _fp (10, for this case) forbidden site IDs and 40 bits for s/2 (2, for this case) minimum energy values and site-id pairs. s(s−1) message exchanges are done sharing forbidden site IDs and s−1 exchanges are required for energy and ID pairs to flow across all sinks. If network lifetime is 500 rounds, total message exchange of all sinks during this lifetime becomes around 51 KB.

In the approach described in [27], the information exchange part is much more expensive, where each sink shares all its descendants’ residual nodal energy levels with the others. The maximum energy amount that a node can have is divided into 40 levels (L), which requires 6 bits to represent. Sinks also need to append sensor IDs to a message so each counterpart can construct a full residual-energy-level table. This operation requires additional l o g N bits. Since all nodes’ energy levels should be shared, totally N(l o g N+l o g L) bits are needed to convey the required information for a decision. For 500 nodes (and 40 levels), it requires 7500 bits for one sink to send the related information. For 500 rounds and 4 sinks, the total message exchange cost increases to 5.36 MB for the algorithm of [27]. This is 108 times more than what our PMA algorithm needs.

5 Performance evaluation

In this section, we discuss the results of our MATLAB-based performance evaluation of the proposed schemes. We compare our MSMA and PMA algorithms with four different schemes:

• MinDiff-RE: Azad and Chockalingam’s algorithm minimizes the residual energy difference [26].

• MS-ELMA: Our naive algorithm which limits possible site-sink combinations and selects the one that maximizes the minimum remaining energy [34].

• RAND: Sinks select sites randomly without considering any network parameter.

• STS: Sinks select sites at the beginning and stay there.

We compared the performance of these six schemes with respect to the following metrics:

• Network lifetime: The time until the first node depletes all its energy, which is the commonly used definition in the literature.

• Latency: Average hop-count that a packet travels until it reaches one of the sinks.

• Total distance: Total distance that mobile sinks travel during the network lifetime.

5.1 Simulation parameters

The sensor networks in our simulations have N static sensor nodes randomly deployed to a region and s mobile sinks (base stations). The deployment region is a square-shaped region with area size 300×300m ². After mobile sinks move to their initial locations, they start broadcasting topology construction messages to construct tree-based multi-hop routing topologies (routing trees) from top to bottom. After topology construction, each sink node will have its routing tree constructed rooted at itself. Routing trees do not overlap. We use a constant packet generation rate Q (1 packet/s) for each sensor node. We define the network lifetime as the period of time until the first node dies. This is a commonly used definition in the literature. We defined data latency as the average hop-count a packet originating at a sensor node travels to reach to the corresponding sink.

The energy model and the radio characteristics used in the simulations are from [36]. Transmission energy cost is related to the number of bits transmitted and to the square of distance between transmitter and receiver, whereas receive energy cost is related just to the number of bits received. In our simulations, we assume a data packet is 50 bytes long and a control packet (used for topology construction, for example) is 20 bytes. We assume radio device consumes E _elec = 50 nJ/bit to run the transceiver circuitry and ε _amp = 100 pJ/bit/ m ² for the transmit amplifier to achieve an acceptable $\frac {E_{b}}{E_{n}}$ [36]. Each sensor node has 50J initial amount of energy. These simulation parameters and their typical values are summarized in Table 1.

Table 1 Simulation parameters

5.2 Simulation results

Network lifetime results for the number of sinks (sink count) between two and eight are given in Fig. 3. Our MSMA algorithm gives a better network lifetime compared to other schemes for all values of sink count. Even MinDiff-RE uses four times more combinations than MSMA when the number of sinks is eight, the MSMA gives a three percent better lifetime performance compared to it. The PMA algorithm performs 22 % worse compared to centralized algorithms on the average, but it still outperforms RAND approach by 21 % on the average.

Fig. 3

Network lifetime values for various numbers of sinks

Data latency (average hop-count) is another important metric for wireless sensor networks. Algorithms should have lower data latencies, especially for delay-intolerant applications (like fire detection). The latency comparison of the schemes is given in Fig. 4. The static sink approach has the best (lowest) latency values—10 % lower than the centralized algorithms and 13 and 16 % lower than the PMA algorithm and the RAND approach, respectively. Centralized algorithms have almost the same latency as each other. The PMA algorithm also has the same latency as centralized algorithms, but it has lower latency (3 % on the average) compared to the RAND.

Fig. 4

Latency values for various numbers of sinks

Although it is not taken into consideration most of the time, travel distance between two sites is another cost to consider for sink mobility problems because mobile sinks spend energy (for example, fuel) to move from one site to another. The distance traveled effects also the reconfiguration latency. Figure 5 shows the total distance covered by mobile base stations for different sink-count values. Centralized algorithms cause sinks to travel more compared to our PMA algorithm and the RAND approach. For example, when the sink-count is eight, centralized algorithms cause the sinks to cover 5.2 times more distance than the other two schemes. Our PMA algorithm achieves the least travel-distance. Sinks cover 1.5 times more distance when they use the RAND approach compared to the PMA algorithm. Therefore, our PMA algorithm has a longer network lifetime and better data latency while traveling less, compared to the RAND approach.

Fig. 5

Distances traveled for various numbers of sinks

Figure 6 gives network lifetime performance of the schemes for different values of transmission-range. The sink-count values, if fixed to five, and the node-count value is fixed to 500. The performance of all schemes gets better when transmission-range increases. The performance of RAND increases by almost 50 % when the transmission range is increased from 30 to 50m. This is more than the increase of any other scheme (others vary between 20 and 30 %). Since RAND does not use any intelligent mechanism while moving sinks, increasing transmission range causes an increase its performance more than the performance increase of any other scheme.

Fig. 6

Network lifetime values for various transmission ranges

The effect of the number of sink sites (site-count) on the network-lifetime performance of the algorithms is shown in Fig. 7. The sink-count, node-count, and transmission-range values are fixed to 4, 500, and 40 m, respectively. The lifetime achieved by MSMA, MinDiffRE, and MS-ELMA schemes improves 50 % on average when site-count increases from 10 to 25. Increasing possible sink sites creates more options (combinations) for these algorithms to select from, which helps improving the lifetime of the network. This increase amount drops to 10 % for the PMA algorithm, since it does not use any prior information (topology information for each site) while selecting the sites on-the-fly. Therefore, increasing the number of sites does not affect PMA performance as much as its centralized counterparts.

Fig. 7

Network lifetime values for various numbers of sink sites

Network lifetime values for different minimum stay time (t _min ) values are given in Fig. 8. The sink-count and site-count values are fixed to 4 and 18, respectively. The t _min value is changed between 50 and 250 s. The performance of all algorithms is not affected by more than 7.5 %. Our MSMA algorithms is affected least (2 %), while RAND approach is affected most (7.5 %). However, increasing t _min helps sinks to travel less in the area, as seen in Fig. 9. Total travel distances decrease by an average factor of 5 while t _min increases from 50 to 250. That means that it is possible to reduce the mobility cost by a factor of five when the network lifetime performance is decreased by just five percent. However, increasing t _min value beyond a threshold will cause algorithms’ achieved lifetime values to decrease, since staying longer at a point can cause unbalanced energy values of the nodes. Therefore, ideal t _min value can change according to the application or needs. It should be increased if mobility cost is taken into consideration; however, beyond a threshold, this will cause lifetime performance to decrease.

Fig. 8

Network lifetime values for various t _min values

Fig. 9

Distances traveled for various t _min values

The effect of the number of nodes changed in the area is shown in Fig. 10. Network lifetime performance is inversely affected by increasing sensor nodes in the area. In this case, hot-spot nodes must relay more packets compared to when there are fewer nodes. However, the decreasing ratio in network lifetime changes according to the algorithm used. The static sink case is affected most (93 %) and the PMA algorithm least (19 %). The PMA’s algorithm network lifetime becomes better than MinDiff-RE’s and MS-ELMA’s when the number of nodes increases to 1,000. Since the current energy levels of the nodes are taken into consideration when the network operates, more-balanced topology trees can be constructed. This situation contributes to lifetime more than the pre-calculated topology trees used in MinDiff-RE and MS-ELMA do. Therefore, it would be better to use the PMA algorithm when there are more than a few hundred nodes in the area. Sinks also travel two times less often using that method compared to centralized algorithms.

Fig. 10

Network lifetime values for various numbers of nodes

6 Conclusion

In this paper, we propose two multiple-sink mobility algorithms, MSMA and PMA, to coordinate movements of multiple sinks in a wireless sensor network. The MSMA uses the energy expenditure information of all nodes for different sink-site combinations. Unlike other similar approaches, the MSMA does not use all possible combinations, but instead limits the number of combinations according to a threshold value to reduce complexity. The PMA algorithm is a distributed algorithm that uses no global network information to determine the sinks’ next migration points. Each sink forbids some sites from using its children’s residual energy information. One group of sinks selects sites from the remaining set using the maximum of the minimum energy of the first-hop nodes. The other group selects points farther from the previously selected ones. We compare the performance of the proposed schemes with the MinDiff-RE, RAND, and static-sink approaches in terms of network lifetime, latency, and total distance covered by the sinks.

Under varying metrics, the experiment results show that the MSMA performs better in terms of network than any other scheme. The MSMA gives better network lifetime than the MinDiff-RE even though it uses up to four times fewer sink-site combinations. Latency (average hop count to any sink) is lowest for the static-sink case and almost the same for the other schemes. The PMA algorithm achieves less lifetime (around 20 % on the average) compared to centralized algorithms (but better than random movement under all conditions); however, its performance increases (becomes better than the MinDiff-RE and MS-ELMA) when there are more than a few hundred nodes. Sinks also travel less compared to other schemes when using the PMA algorithm.