A novel crash-tolerant data gathering in wireless sensor networks
16 Apr 2012-pp 940-946
TL;DR: A set of algorithms is proposed which builds a data gathering tree rooted at the sink which eventually becomes a Breadth First Search (BFS) tree where each node maintains the shortest distance in hop-count to the root to reduce the routing delay and power consumption.
Abstract: Event driven data gathering or convergecast through sensor nodes requires efficient and correct delivery of data at the sink. A tree rooted at the sink is an ideal topology for data gathering which utilizes sensor resources properly. Resource constrained sensor nodes are highly prone to sudden crash. A set of algorithms, proposed in this paper, builds a data gathering tree rooted at the sink. The tree eventually becomes a Breadth First Search(BFS) tree where each node maintains the shortest distance in hop-count to the root to reduce the routing delay and power consumption. The data gathering tree is repaired locally within a constant round of message transmissions after any random node fails. Simulation result shows that the repairing delay is very less in average, and the proposed scheme can repair from arbitrary node failure using constant number of message passing.
Citations
More filters
01 Jan 2012
TL;DR: This paper proposes a proactive tree recovery mechanism to make the overlay multicast resilient to failures and unexpected events, and shows that it can recover from node departures much faster than reactive methods, while the quality of trees restored and the cost of recovery are reasonable.
Abstract: Overlay multicast constructs a multicast delivery tree among end hosts. An important problem for making overlay multicast more dependable is how to recover from node departures in order to minimize the disruption of service to those affected nodes. In this paper, we propose a proactive tree recovery mechanism to make the overlay multicast resilient to these failures and unexpected events. The salient feature of the approach is that rescue plans for multiple non-leaf nodes can work together for their respective children when they fail or leave at the same time. Extensive simulations demonstrate that our proactive approach can recover from node departures much faster than reactive methods, while the quality of trees restored and the cost of recovery are reasonable.
17 citations
01 Aug 2013
TL;DR: The proposed scheme builds a data gathering tree rooted at the sink that eventually becomes a Breadth First Search (BFS) tree where each node maintains the shortest hop-count to the root to reduce the routing delay.
Abstract: The efficiency and reliability of convergecast in sensor network depends on the correct and efficient accumulation of data to the sink. A tree, rooted at the sink, that utilizes sensor resources properly is an ideal topology for data gathering. Resource constrained sensor nodes are highly prone to sudden crash. So the application demands a quick and efficient repairing of the tree when a node dies. The proposed scheme builds a data gathering tree rooted at the sink. The tree eventually becomes a Breadth First Search (BFS) tree where each node maintains the shortest hop-count to the root to reduce the routing delay. Each node collects some extra neighborhood information during the tree construction. Thus a little pre-processing at each node helps in taking prompt actions to repair the tree through local adjustment if any arbitrary single or multiple nodes fail in future. On failure of a node, each affected node in its vicinity fixes the parent through a pair of control message transmissions. Simulation results show that the repairing delay is significantly less in average and the convergecast messages are delivered with minimum data loss and no redundancy even in presence of node crash.
6 citations
Cites background from "A novel crash-tolerant data gatheri..."
...In [21], a node u can choose node v as its alternate parent, where the parent of node u belongs to the forwarding path of node v....
[...]
...In [21], a node u can set node v as its parent after parent of node u fails, where node v was precomputed as alternate parent....
[...]
...A preliminary version of this work has been published in [21] which restricts the failure of alternate parent after a parent node has crashed....
[...]
TL;DR: A data gathering tree management scheme has been proposed to deal with arbitrary node failures in delay-sensitive sensor networks and offers low overhead, enhanced network lifetime and good QoS in terms of delay and reliability of the application messages.
Abstract: The lifetime of a sensor network is influenced by the efficient utilization of the resource constrained sensor nodes. The tree-based data gathering offers good quality of service (QoS) for the running applications. However, data gathering at the sink reduces the network lifetime due to a fast failure of highly loaded nodes. Loss of connectivity and sensing coverage affect the performance of the applications that demand critical QoS. In this paper, a data gathering tree management scheme has been proposed to deal with arbitrary node failures in delay-sensitive sensor networks. A load-balanced distributed BFS tree construction procedure has been introduced for an efficient data gathering. Based on the initial tree construction, a tree maintenance scheme and an application message handler have been designed to ensure the reliable delivery of the application messages. The correctness of the proposed scheme has been verified both theoretically and with the help of simulation. The proposed scheme offers low overhead, enhanced network lifetime and good QoS in terms of delay and reliability of the application messages.
2 citations
04 Dec 2014
TL;DR: This work presents distributed energy-efficient algorithms for constructing BFS and SPT sink trees in WSNs and proposes a simple distributed collision avoidance mechanism that enables efficient functioning of their tree construction algorithms.
Abstract: Sink trees such as Breadth-First Search (BFS) or Shortest-Path Tree (SPT) are essential in Wireless Sensor Networks (WSNs) for various purposes such as data gathering, aggregation, clustering, and synchronization. These trees minimize the path-lengths reachable from root node to any other node in the network. With the energy-bound sensor nodes, it is vital to construct such trees in an effective manner, by minimizing the number of message exchanges. By exploiting the broadcast nature of the underlying wireless medium, we present distributed energy-efficient algorithms for constructing BFS and SPT sink trees in WSNs. To mitigate collisions, we propose a simple distributed collision avoidance mechanism that enables efficient functioning of our tree construction algorithms. Extensive simulation study is performed for different networks by varying the size, degree, and depth. Our promiscuous learning based algorithm outperformed by incurring up to 66% less (message) exchanges than the state-of-the-art tree construction algorithm.
2 citations
Cites background from "A novel crash-tolerant data gatheri..."
...Recently, the authors in [6] consider BFS as an energy-efficient way to broadcast messages to all the nodes in the network and construct a crash-tolerant BFS tree structure in the presence of failure nodes....
[...]
References
More filters
TL;DR: The concept of sensor networks which has been made viable by the convergence of micro-electro-mechanical systems technology, wireless communications and digital electronics is described.
17,936 citations
"A novel crash-tolerant data gatheri..." refers background in this paper
...Sensors with various applicabilities are useful for accessing critical resources, environment monitoring, battlefield surveillance, industrial automation and process control, health and traffic monitoring and so on [1]....
[...]
09 Mar 2002
TL;DR: PEGASIS (power-efficient gathering in sensor information systems), a near optimal chain-based protocol that is an improvement over LEACH, is proposed, where each node communicates only with a close neighbor and takes turns transmitting to the base station, thus reducing the amount of energy spent per round.
Abstract: Sensor webs consisting of nodes with limited battery power and wireless communications are deployed to collect useful information from the field. Gathering sensed information in an energy efficient manner is critical to operate the sensor network for a long period of time. In W. Heinzelman et al. (Proc. Hawaii Conf. on System Sci., 2000), a data collection problem is defined where, in a round of communication, each sensor node has a packet to be sent to the distant base station. If each node transmits its sensed data directly to the base station then it will deplete its power quickly. The LEACH protocol presented by W. Heinzelman et al. is an elegant solution where clusters are formed to fuse data before transmitting to the base station. By randomizing the cluster heads chosen to transmit to the base station, LEACH achieves a factor of 8 improvement compared to direct transmissions, as measured in terms of when nodes die. In this paper, we propose PEGASIS (power-efficient gathering in sensor information systems), a near optimal chain-based protocol that is an improvement over LEACH. In PEGASIS, each node communicates only with a close neighbor and takes turns transmitting to the base station, thus reducing the amount of energy spent per round. Simulation results show that PEGASIS performs better than LEACH by about 100 to 300% when 1%, 20%, 50%, and 100% of nodes die for different network sizes and topologies.
3,731 citations
Book•
01 Jan 2001
TL;DR: The complexity class P is formally defined as the set of concrete decision problems that are polynomial-time solvable, and encodings are used to map abstract problems to concrete problems.
Abstract: problems To understand the class of polynomial-time solvable problems, we must first have a formal notion of what a "problem" is. We define an abstract problem Q to be a binary relation on a set I of problem instances and a set S of problem solutions. For example, an instance for SHORTEST-PATH is a triple consisting of a graph and two vertices. A solution is a sequence of vertices in the graph, with perhaps the empty sequence denoting that no path exists. The problem SHORTEST-PATH itself is the relation that associates each instance of a graph and two vertices with a shortest path in the graph that connects the two vertices. Since shortest paths are not necessarily unique, a given problem instance may have more than one solution. This formulation of an abstract problem is more general than is required for our purposes. As we saw above, the theory of NP-completeness restricts attention to decision problems: those having a yes/no solution. In this case, we can view an abstract decision problem as a function that maps the instance set I to the solution set {0, 1}. For example, a decision problem related to SHORTEST-PATH is the problem PATH that we saw earlier. If i = G, u, v, k is an instance of the decision problem PATH, then PATH(i) = 1 (yes) if a shortest path from u to v has at most k edges, and PATH(i) = 0 (no) otherwise. Many abstract problems are not decision problems, but rather optimization problems, in which some value must be minimized or maximized. As we saw above, however, it is usually a simple matter to recast an optimization problem as a decision problem that is no harder. Encodings If a computer program is to solve an abstract problem, problem instances must be represented in a way that the program understands. An encoding of a set S of abstract objects is a mapping e from S to the set of binary strings. For example, we are all familiar with encoding the natural numbers N = {0, 1, 2, 3, 4,...} as the strings {0, 1, 10, 11, 100,...}. Using this encoding, e(17) = 10001. Anyone who has looked at computer representations of keyboard characters is familiar with either the ASCII or EBCDIC codes. In the ASCII code, the encoding of A is 1000001. Even a compound object can be encoded as a binary string by combining the representations of its constituent parts. Polygons, graphs, functions, ordered pairs, programs-all can be encoded as binary strings. Thus, a computer algorithm that "solves" some abstract decision problem actually takes an encoding of a problem instance as input. We call a problem whose instance set is the set of binary strings a concrete problem. We say that an algorithm solves a concrete problem in time O(T (n)) if, when it is provided a problem instance i of length n = |i|, the algorithm can produce the solution in O(T (n)) time. A concrete problem is polynomial-time solvable, therefore, if there exists an algorithm to solve it in time O(n) for some constant k. We can now formally define the complexity class P as the set of concrete decision problems that are polynomial-time solvable. We can use encodings to map abstract problems to concrete problems. Given an abstract decision problem Q mapping an instance set I to {0, 1}, an encoding e : I → {0, 1}* can be used to induce a related concrete decision problem, which we denote by e(Q). If the solution to an abstract-problem instance i I is Q(i) {0, 1}, then the solution to the concreteproblem instance e(i) {0, 1}* is also Q(i). As a technicality, there may be some binary strings that represent no meaningful abstract-problem instance. For convenience, we shall assume that any such string is mapped arbitrarily to 0. Thus, the concrete problem produces the same solutions as the abstract problem on binary-string instances that represent the encodings of abstract-problem instances. We would like to extend the definition of polynomial-time solvability from concrete problems to abstract problems by using encodings as the bridge, but we would like the definition to be independent of any particular encoding. That is, the efficiency of solving a problem should not depend on how the problem is encoded. Unfortunately, it depends quite heavily on the encoding. For example, suppose that an integer k is to be provided as the sole input to an algorithm, and suppose that the running time of the algorithm is Θ(k). If the integer k is provided in unary-a string of k 1's-then the running time of the algorithm is O(n) on length-n inputs, which is polynomial time. If we use the more natural binary representation of the integer k, however, then the input length is n = ⌊lg k⌋ + 1. In this case, the running time of the algorithm is Θ (k) = Θ(2), which is exponential in the size of the input. Thus, depending on the encoding, the algorithm runs in either polynomial or superpolynomial time. The encoding of an abstract problem is therefore quite important to our under-standing of polynomial time. We cannot really talk about solving an abstract problem without first specifying an encoding. Nevertheless, in practice, if we rule out "expensive" encodings such as unary ones, the actual encoding of a problem makes little difference to whether the problem can be solved in polynomial time. For example, representing integers in base 3 instead of binary has no effect on whether a problem is solvable in polynomial time, since an integer represented in base 3 can be converted to an integer represented in base 2 in polynomial time. We say that a function f : {0, 1}* → {0,1}* is polynomial-time computable if there exists a polynomial-time algorithm A that, given any input x {0, 1}*, produces as output f (x). For some set I of problem instances, we say that two encodings e1 and e2 are polynomially related if there exist two polynomial-time computable functions f12 and f21 such that for any i I , we have f12(e1(i)) = e2(i) and f21(e2(i)) = e1(i). That is, the encoding e2(i) can be computed from the encoding e1(i) by a polynomial-time algorithm, and vice versa. If two encodings e1 and e2 of an abstract problem are polynomially related, whether the problem is polynomial-time solvable or not is independent of which encoding we use, as the following lemma shows. Lemma 34.1 Let Q be an abstract decision problem on an instance set I , and let e1 and e2 be polynomially related encodings on I . Then, e1(Q) P if and only if e2(Q) P. Proof We need only prove the forward direction, since the backward direction is symmetric. Suppose, therefore, that e1(Q) can be solved in time O(nk) for some constant k. Further, suppose that for any problem instance i, the encoding e1(i) can be computed from the encoding e2(i) in time O(n) for some constant c, where n = |e2(i)|. To solve problem e2(Q), on input e2(i), we first compute e1(i) and then run the algorithm for e1(Q) on e1(i). How long does this take? The conversion of encodings takes time O(n), and therefore |e1(i)| = O(n), since the output of a serial computer cannot be longer than its running time. Solving the problem on e1(i) takes time O(|e1(i)|) = O(n), which is polynomial since both c and k are constants. Thus, whether an abstract problem has its instances encoded in binary or base 3 does not affect its "complexity," that is, whether it is polynomial-time solvable or not, but if instances are encoded in unary, its complexity may change. In order to be able to converse in an encoding-independent fashion, we shall generally assume that problem instances are encoded in any reasonable, concise fashion, unless we specifically say otherwise. To be precise, we shall assume that the encoding of an integer is polynomially related to its binary representation, and that the encoding of a finite set is polynomially related to its encoding as a list of its elements, enclosed in braces and separated by commas. (ASCII is one such encoding scheme.) With such a "standard" encoding in hand, we can derive reasonable encodings of other mathematical objects, such as tuples, graphs, and formulas. To denote the standard encoding of an object, we shall enclose the object in angle braces. Thus, G denotes the standard encoding of a graph G. As long as we implicitly use an encoding that is polynomially related to this standard encoding, we can talk directly about abstract problems without reference to any particular encoding, knowing that the choice of encoding has no effect on whether the abstract problem is polynomial-time solvable. Henceforth, we shall generally assume that all problem instances are binary strings encoded using the standard encoding, unless we explicitly specify the contrary. We shall also typically neglect the distinction between abstract and concrete problems. The reader should watch out for problems that arise in practice, however, in which a standard encoding is not obvious and the encoding does make a difference. A formal-language framework One of the convenient aspects of focusing on decision problems is that they make it easy to use the machinery of formal-language theory. It is worthwhile at this point to review some definitions from that theory. An alphabet Σ is a finite set of symbols. A language L over Σ is any set of strings made up of symbols from Σ. For example, if Σ = {0, 1}, the set L = {10, 11, 101, 111, 1011, 1101, 10001,...} is the language of binary representations of prime numbers. We denote the empty string by ε, and the empty language by Ø. The language of all strings over Σ is denoted Σ*. For example, if Σ = {0, 1}, then Σ* = {ε, 0, 1, 00, 01, 10, 11, 000,...} is the set of all binary strings. Every language L over Σ is a subset of Σ*. There are a variety of operations on languages. Set-theoretic operations, such as union and intersection, follow directly from the set-theoretic definitions. We define the complement of L by . The concatenation of two languages L1 and L2 is the language L = {x1x2 : x1 L1 and x2 L2}. The closure or Kleene star of a language L is the language L*= {ε} L L L ···, where Lk is the language obtained by
2,817 citations
"A novel crash-tolerant data gatheri..." refers methods in this paper
...So using a BFS tree would be a good option for data gathering as the hop-count distance between the sink and each sensor node in the network is minimum for a BFS tree [9]....
[...]
07 Mar 2004
TL;DR: An on-line distributed protocol that relies only on the local information available at each sensor node within the aggregation tree, and a pseudo-polynomial time approximation algorithm based on dynamic programming are developed.
Abstract: We study the problem of scheduling packet transmissions for data gathering in wireless sensor networks. The focus is to explore the energy-latency tradeoffs in wireless communication using techniques such as modulation scaling. The data aggregation tree - a multiple-source single-sink communication paradigm - is employed for abstracting the packet flow. We consider a real-time scenario where the data gathering must be performed within a specified latency constraint. We present algorithms to minimize the overall energy dissipation of the sensor nodes in the aggregation tree subject to the latency constraint. For the off-line problem, we propose (a) a numerical algorithm for the optimal solution, and (h) a pseudo-polynomial time approximation algorithm based on dynamic programming. We also discuss techniques for handling interference among the sensor nodes. Simulations have been conducted for both long-range communication and short-range communication. The simulation results show that compared with the classic shutdown technique, between 20% to 90% energy savings can be achieved by our techniques, under different settings of several key system parameters. We also develop an on-line distributed protocol that relies only on the local information available at each sensor node within the aggregation tree. Simulation results show that between 15% to 90% energy conservation can be achieved by the on-line protocol. The adaptability of the protocol with respect to variations in the packet size and latency constraint is also demonstrated through several run-time scenarios.
383 citations
20 Mar 2003
TL;DR: A heuristic algorithm is proposed (convergecasting tree construction and channel allocation algorithm (CTCCAA), which constructs a tree with schedules assigned to nodes for collision free convergecasting, and is capable of code allocation in case multiple codes are available to minimize the total duration required for convergecasting.
Abstract: A wireless sensor network (WSN) consists of sensors implanted in an environment for collecting and transmitting data regarding changes in the environment based on the requests from a controlling device (called base station) using wireless communication. WSNs are being used in medical, military, and environment monitoring applications. Broadcast (dissemination of information from a central node) and convergecast (gathering of information towards a central node) are important communication paradigms across all application domains. Most sensor applications involve both convergecasting and broadcasting. The time taken to complete either of them has to be kept minimal. This can be accomplished by constructing an efficient tree for both broadcasting as well as convergecasting and allocating wireless communication channels to ensure collision-free communication. There exist several works on broadcasting in multihop radio networks (a.k.a. ad hoc networks), which can also be used for broadcasting in WSNs. These algorithms construct a broadcast tree and compute a schedule for transmitting and receiving for each node to achieve collision-free broadcasting. In this paper, we show that we need a new algorithm for applications, which involve both convergecasting and broadcasting since the broadcast tree may not be efficient for convergecasting. So we propose a heuristic algorithm (convergecasting tree construction and channel allocation algorithm (CTCCAA)), which constructs a tree with schedules assigned to nodes for collision free convergecasting. The algorithm is capable of code allocation (direct sequence spread spectrum (DSSS)/ frequency hopping spread spectrum (FHSS)), in case multiple codes are available, to minimize the total duration required for convergecasting. We also show that the same tree can be used for broadcasting and is as efficient as a tree exclusively constructed for broadcasting.
183 citations
"A novel crash-tolerant data gatheri..." refers methods in this paper
...[6] have proposed a heuristic algorithm for tree construction and channel allocation for both broadcast and convergecast in multi-hop radio network....
[...]