Sparse Data Aggregation in Sensor Networks Jie Gao Computer Science Department SUNY Stony Brook Stony Brook, NY 11794 jgao@cs.sunysb.edu Leonidas Guibas Nikola Milosavljevic Computer Science Department Stanford University Stanford, CA 94305 John Hershberger Mentor Graphics 8005 S.W. Boeckman Road Wilsonville, OR 97070 john hershberger@mentor.com guibas@cs.stanford.edu nikolam@cs.stanford.edu Abstract We study the problem of aggregating data from a sparse set of nodes in a wireless sensor network. This is a common situation when a sensor network is deployed to detect relatively rare events. In such situations, each node that should participate in the aggregation knows this fact based on its own sensor readings, but there is no global knowledge in the network of where all these interesting nodes are located. Instead of blindly querying all nodes in the network, we show how the interesting nodes can autonomously discover each other in a distributed fashion and form an ad hoc aggregation structure that can be used to compute cumulants, moments, or other statistical summaries. Key to our approach is the capability for two nodes that wish to communicate at roughly the same time to discover each other at a cost that is proportional to their network distance. We show how to build nearly optimal aggregation structures that can further deal with network volatility and compensate for the loss or duplication of data by exploiting probabilistic techniques. Categories and Subject Descriptors C.2.2 [Computer-Communication Networks]: Network protocols—Routing protocols; F.2.2 [Analysis of Algorithms and Problem Complexity]: Nonnumerical Algorithms and Problems—Geometrical problems and computations General Terms Algorithms, Design, Theory Keywords Aggregation, Sensor Networks 1. INTRODUCTION AND RATIONALE Information aggregation is a common operation in sensor networks. Traditionally, information sampled at the sensor nodes needs Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. IPSN’07, April 25-27, 2007, Cambridge, Massachusetts, USA. Copyright 2007 ACM 978-1-59593-638-7/07/0004 ...$5.00. Figure 1. An example of sparse aggregation trees in a 1, 024-node (32 × 32) grid network. The heavier solid lines represent the tree edges. Nodes marked by crosses are not in the tree, but have been involved in the tree formation phase (by relaying probe and recall messages). to be conveyed to a central base station for further processing, analysis, and visualization by the network users. Information aggregation in this context can refer to the computation of statistical means and moments, as well as other cumulative quantities that summarize the data obtained by the network. Such accumulation is important for data analysis and for obtaining a deeper understanding of the signal landscapes observed by the network. In certain contexts, when atomic sensor readings might reveal inappropriate information about a location or an individual, aggregation is also essential for alleviating privacy concerns. An important topic addressed by the wireless sensor networks community over the last several years has been in-network aggregation. The notion is that cumulants, moments, or summaries can be computed directly in the network by sensor nodes endowed with computational power, thus avoiding the expensive transmission of all sensor data to a (possibly distant) base station. It is well known that, for nearly all node technologies, data transmission over wireless links costs hundreds to thousands of times more energy than performing local computation on the same data. In the setting of untethered, energy-constrained sensor nodes monitoring a physical environment, it thus becomes quite significant, for energy conser- vation and network lifetime considerations, to be able to trade local computation for communication as much as possible. There has been a lot of interesting prior work on the in-network aggregation problem, some of which is briefly surveyed in Section 2 below. Most of the extant work assumes that the goal of the aggregation is to accumulate data from all the network nodes. This is certainly the case in scientific applications, where scientists are aiming to obtain as detailed information as they can about the observed physical phenomenon. In fact, physical scientists are often unhappy about in-network aggregation, as they want to have access to the raw sensor data, whenever possible. To some extent these concerns can be alleviated by providing tools for filtered aggregation, where only a select subset of nodes participate in the aggregation, according to the values of some of their sensors, their geographic location, etc. Even in these settings, however, all the nodes see all the queries— they simply decide whether to participate in the aggregation or not. In this paper we are interested in exploring a new part of the aggregation problem space, by focusing on situations where only a relatively small subset of the nodes have useful data to report, or want to participate in an aggregation. This is appropriate, for example, in settings where nodes perform some local processing first, to map raw sensor data into event detections, and where events of interest are relatively rare. Many applications of sensor networks fit this model, as sensor networks are often deployed to monitor and protect the health or safety of a system/space/environment, and anomalous events are, by their nature, infrequent. For example, if we have a sensor network monitoring a city, natural catastrophes such as flooding, the spread of disease, earthquake damage, etc., may affect a relatively small portion of the city at any one time. The causative factors of these disasters may depend on combinations of external forces (e.g., rain, ground movement) and local conditions (e.g., building construction, health habits), making their locations hard to predict. What is common in such situations is that the sensor nodes observing the event of interest know that it has occurred, but there is no centralized knowledge in the network about where all these event detections are. In such situations existing aggregation methods are quite suboptimal. One can poll and query the network for these events, but such queries will also have to be routed to the many nodes that have nothing to report, wasting large amounts of energy. Clearly, for rare events, frequent polling is inefficient. A purely event-driven approach, where each node with a detection independently transmits a record of the event to a base station, may also not be optimal. In the settings we have in mind multiple detections may occur within a relatively short time period and it can be advantageous to aggregate in-network for all the reasons given earlier, as well as for avoiding the creation of hot-spots and single points of failure around the base station. In other settings, where for example rescue workers are embedded and operating in the same space as the network, there may be no single fixed information sink. Instead the detections should be reported to the nearest network users, with minimal latency. Similar challenges arise in settings where we wish to track intermittently observable targets moving through a sensor network. Traditionally, leader nodes aggregate information and perform hand offs as the target moves. But when the detecting nodes are all disconnected, this no longer works. How should these nodes locally discover each other and pool their data to estimate the target tracks? Our goal in this paper is to aggregate data in-network from a small set of nodes that is possibly disconnected, but all of which have data to aggregate within a relatively short period. Each node knows locally whether it wants to be aggregated or not, but no global information about the location of this set is available in the network. We call this the sparse aggregation problem. We focus on the problem of counting the number of nodes in the sparse detection set, or of summing a set of values, one from each of these nodes, as the canonical aggregation problems. Many other variations are possible. For brevity, we refer from now on to the nodes in the aggregation set as the hot nodes. We present a class of solutions to the sparse aggregation problem with several attractive properties: • Our protocols are entirely distributed and need no prior information about whether hot nodes exist or where they are located; nevertheless, they can exploit such information, if available. • We bring the hot nodes into a connected aggregation structure, such as a tree, whose total cost is within a small factor of what would be possible if we had a full network map and perfect knowledge of where the hot nodes are located. • We exploit probabilistic techniques in data aggregation, to make our protocols robust to network volatility and the incorporation of duplicate data, at the expense of a small probability of modest errors. An interesting aspect of our work is the way that the data processing and information aggregation can be interleaved with the routing, hot node discovery, and tree-formation aspects of our protocols— to the benefit of both. This paper provides a first theoretical analysis and simulation validation of this sparse aggregation framework. 2. PREVIOUS WORK We are not aware of previous work that specifically addresses the sparse aggregation problem. However, there is a vast amount of extant work on general in-network aggregation that we cannot hope to fully survey here. Thus we focus on what is most relevant to our approach. Early work on in-network aggregation, e.g., TinyDB [11], uses a tree-like structure to disseminate queries and collect results back to the sink. Queries are pushed down the network to construct a spanning tree. Aggregate values are routed up the tree with partial data aggregated, compressed and pruned at internal tree nodes to reduce communication cost. Various algorithmic techniques have been proposed to allow efficient aggregation without increasing the message size [3, 4, 17]. A serious problem with tree structures is that they are fragile under transmission failures, which are common in sensor networks. With in-network aggregation, packet loss can be fatal—as it may lead to the loss of the values from an entire subtree. To improve routing robustness, multi-path routing schemes can be adopted. But this may lead to duplicate packets arriving at the base station and subsequently cause double counting. To deal with this problem, methods such as synopsis diffusion [3, 12, 13] were proposed to decouple aggregation from message routing by designing aggregation schemes that are insensitive to message duplication and arrival orders, a property named order and duplicate insensitive (ODI). Many of these techniques intuitively implement an aggregation operation by MAX/MIN or boolean operations on bit arrays, which are by nature insensitive to duplicate data. The aggregation methods we use in this paper exploit similar tools. Non-tree based methods, such as sweeps, have also been proposed [18]. 3. NETWORK SETUP AND AN OVERVIEW Our approach to the sparse aggregation problem is based on and inspired by a number of tools that we briefly mention here, then develop further in later sections. Suppose that sensor nodes are uniformly deployed inside a regular region with sufficient density for connectivity and coverage. The boundary of the field is known. Furthermore, nodes on the boundary have connections to an external high-speed network. Based on their own sensor measurements, certain sensors in the field decide that they are ‘hot’ (i.e., they believe they have detected something of interest). Our goal is to count the number of hot nodes in the network, or more generally to compute efficiently certain aggregate statistics about the set of hot nodes. These statistics may involve the number of nodes, the locations of the nodes (if known), or other secondary physical measurements that convey more information about the phenomenon being observed. We assume that the set of hot nodes is relatively small compared to the whole network. There is no assumption that the hot nodes are ‘clustered’ in any way, though this may turn out to be the case in practice, as physical phenomena exhibit spatial coherence. We would like to collect these statistics at periodic intervals. To accomplish this goal without explicitly interrogating all nodes, we make a few assumptions that we believe to be reasonable. Since we want the data collection to be initiated by the hot nodes themselves, we need to assume a common temporal framework for the nodes, with a shared clock that lets a node know when to initiate data collection. We do not require perfect (and unrealistic) clock synchronization among the nodes—instead we assume that clock drift between a pair of nodes is proportional to the distance between those nodes in the network. This can be accomplished by a low-overhead time synchronization protocol, simply by guaranteeing that each node has a bounded drift with respect to each of its 1-hop neighbors. In the case of target tracking, nodes detect events and participate in the aggregation protocol when a target passes by. As long as the target keeps moving with a minimum speed, detection time differences at two nodes will also be bounded by some constant times the relative distance of the nodes or the target path length. Distance-sensitive neighbor discovery. Key to our approach is a probe protocol that can be initiated independently by a node and involves emitting a few packets out of the node that follow certain paths in the network while leaving a trail behind, until the probes are terminated. The key property of the probe protocol is that if two nodes, say u and v, at network distance d (with no knowledge of each other) initiate probes at the same time, then a packet from one of the nodes will encounter a trail left by a packet from the other node after O(d) steps. We call this crucial property distance sensitivity. At that encounter event • if the probe packets carry data from the two nodes, the data can be aggregated, and • a path between the two nodes has been established whose length is O(d) as well. The same holds if the two nodes initiate probes within a time-lag of O(d) of each other. Furthermore, at this point it is possible to initiate another recall protocol whose function is to terminate the probe packets of one of the two nodes, say u. This can be done so that when all the packets of u have been stopped by the recall protocol, the total work performed by both the probe and recall protocols on both nodes u and v is still O(d). In the simplest scenario, when we use the probe and recall protocols, we will think of u and v as ‘competing’ in a tournament. When an encounter event occurs, the winner of the tournament is decided based on the data carried or left behind by the probe packets. The losing node then has his probes terminated by invoking the recall protocol, while the probes of the winner continue to propagate. Probe packets that are not recalled will eventually reach the boundary of the network, where they stop. Their data is aggregated in an appropriate base station, using the high-speed network available for the boundary nodes. We will use the above communication pattern in several variations in what follows. Effectively, our intersecting probes provide a lightweight rendez-vous mechanism, allowing nodes within distance d to discover each other’s existence at a cost of O(d), and not the Ω(d2 ) that a traditional broadcast in a planar network requires. Tree formation. To form an aggregation tree, we let each node choose a random number from some distribution, named the weight of this node. The weights of the hot nodes determine how the aggregation tree is formed. The weights can also be exploited in the specific aggregation to be performed, as will be explained later. At the right time, according to their local clocks, hot nodes initiate probes carrying their weights. When two probes encounter each other, the packet with lower weight wins and initiates a recall protocol for the packets of the node with the larger weight. Probe messages that are not recalled will eventually reach the network boundary. Thus a spanning forest of the hot nodes all connected to the network boundary is formed which can be used for subsequent data aggregation. What is the total cost of the tree formation? Note that each node u will have its probes recalled by a node v of smaller weight, to whom it loses in some encounter event during the tournament1 . This happens at a total cost proportional to the distance d from u to v. Thus each losing node spends effort that is proportional to its distance to the node that defeats it. We show in Section 5 that this simple property is enough to guarantee that the overall effort spent in the aggregation for nodes other than the one of minimum weight is O(T log n), where T is the cost of a minimum spanning tree connecting the hot nodes. Our distributed construction of the aggregation tree was motivated by the nearest neighbor trees by Khan, Kumar, and Pandurangan [8], which are built by giving desired nodes (the hot nodes in our context) certain priorities and then connecting, in a distributed manner, each node to its nearest node of higher priority. We note that in the aggregation tree (or forest) formed by our protocol, a node is not necessarily connected to its nearest neighbor of higher priority. But our tree still has a small total weight. The overall cost of the algorithm is O(T log n + K), where K is the time needed for the probes of the minimum weight node to reach the sensor field boundary. Aggregation. After the aggregation tree or forest is formed, data aggregation can be conducted by having the data flow up the tree and aggregated in the standard way. An interesting aspect of our protocol is that we can actually integrate data aggregation with the tree formation process so that they both happen simultaneously. Recall that in the tree formation procedure we use random priorities to determine which probe message should proceed. These random priorities can be used to implement data aggregation, by using probabilistic counting techniques. Essentially the formation of the tree achieves the computation of the minimum of some random numbers chosen by the hot nodes, with which one can derive an approximation to the final aggregation value. Note that since 1 We assign the nodes on the boundary weight −∞ so that probes that reach the boundary (and thus deliver their data to the sink) are recalled. we are aggregating by computing mins, the framework is robust to packet duplication, multiple encounter events between packets from the same two nodes, etc. 4. FORMATION OF A SPARSE AGGREGATION TREE This section generalizes and fleshes out the details of the methods in Section 3. Note that an unknown sink (or sinks) seeking the results of the aggregation can easily be integrated into this tree discovery/formation scheme. Thus the the aggregated data can be delivered to any desired location or locations in the network. 4.1 Double Rulings To achieve the distance-sensitivity property for neighbor discovery, in our probing protocol each participating node initiates probe packets and sends them along double ruling trails. A double ruling scheme defines a set of trails through every node in the network with the following properties: (i) the maximum length of the trail through each node is O(D), where D is the network diameter; (ii) the trails through two nodes p and q are guaranteed to intersect in the network; (iii) there is a path connecting p and q through the trail intersection with total length O(d), where d is the network distance between p, q. Double ruling schemes were initially designed for information discovery in a sensor network where a sink desires to obtain specific data from a data source while neither of the source or sink knows the location of each other. Different from a pure ‘pull’ or pure ‘push’ approach (both of which involve expensive flooding operations), a double ruling scheme adopts a symmetric information discovery principle with both the source and sink actively searching for each other, as first suggested in rumor-routing [1]. The notion of trails has appeared in a number of other papers as well, including in trajectory forwarding [14], in the asymptotics of query strategies [16], and the combs and needles work [10]. A number of double ruling schemes that guarantee distance sensitivity have been devised in the literature [15]. For example, with geographical location information, a simple double ruling scheme defines the trail for each node p as a cross, i.e., horizontal and vertical paths that go through p. See Figure 2 for an example. The length of a path connecting p, q through either of the two intersections is √ the ℓ1 distance between p, q, which is at most a factor of 2 more than the Euclidean distance between p and q. p q Figure 2. The double ruling trail through each node consists of a cross. The two crosses from nodes p and q intersect. This rectilinear double ruling scheme can be implemented by geographical greedy forwarding. A node sending a probe packet to the north will select the next hop as the one among all 1-hop neighbors that has the maximum y-coordinate. The other three directions are treated similarly. Under uniform deployment of sensor nodes with sufficient density, the greedy algorithm will create paths that resemble a cross passing through the initial node. We call a node receiving probe packets from both p and q a junction node. A junction node can be a node on both double ruling trails from p and q. Or, if two double ruling trails do not intersect at sensor nodes, then we have two crossing links, ab and cd. Assuming sufficient sensor density, because of the broadcast nature of a wireless network, there will a node in the vicinity of the crossing that receives and stores probes from both p and q, and this node is a junction. Junction nodes may not be unique, however. What is crucial is that there is always a path through some junction node connecting p and q with total length O(d), where d is the distance between p, q. To improve the system robustness to link failures and packet loss, we can augment this basic double ruling scheme by using multipath routing. That is, a node holding important data (say, in the sense discussed at the end of Section 6) can send its probe packets along a wider band, rather than a single path. This can be controlled by specifying the width W of the band. A probe packet from source p heading north is broadcast to the nodes in its 1-hop neighborhood; all the nodes with x-coordinate within [px − W/2, px + W/2] and y-coordinate higher than the transmitting node will re-transmit the probe. W can be chosen according to the importance of the data. More about the coupling of data and routing will be discussed in Section 6. In the sequel we use this rectilinear cross scheme to describe the probe and recall protocols. For our sparse aggregation problem, any double ruling scheme satisfying the three properties above is adequate and such schemes can be devised for quite general field morphologies and sensor distributions [15]. 4.2 Probe and Recall Protocols The sparse aggregation protocol starts at a particular time. We assume the nodes have bounded clock drift. The clock difference between two nodes p, q is bounded by α||pq||, where α is a constant, and ||pq|| is the network distance between p, q. The hot nodes with data to report participate in the tree formation protocol, composed of two sub-protocols, the probe protocol and the recall protocol, which together establish an aggregation tree connecting all the hot nodes. The goal of the probe protocol is to discover other hot nodes in the network and establish communication paths between them. The goal of the recall protocol is to prune excess packets traveling in the network, after hot nodes discover each other, so as to reduce the communication overhead. To maintain a consistent tree structure in a distributed environment, we invoke a ranking system on the hot nodes. In general, each hot node uses a pseudo-random hash function on its node ID to generate a unique priority number. When two nodes discover each other by the probe protocol, the node with higher priority ‘wins’ and continues its probe packet. The node with lower priority ‘loses’ and initiates the recall protocol to terminate its probe packets. We assume that the probe packets travel in the network with ‘unit’ speed. The recall packets travel with speed M > 1 in order to catch up to and terminate the probe packets. M depends on the bound on clock drift and is typically a small constant. At time zero, a hot node sends out probe packets in the four directions north, south, west and east. A probe packet from a node p contains the source of the probe, p, and the direction the probe travels. A node sends the probe packet to all the nodes in its 1-hop neighborhood and those in the direction of the probe re-transmit. The number of nodes that retransmit can be adjusted for improved robustness, as explained earlier. A similar trade-off was recently analyzed in [19]. Each node keeps a status table recording the information it has received from each hot node. This includes: a tuple (S OURCE , M SG T YPE , PARENT, J UNCTION), where S OURCE is the ID of the hot node, M SG T YPE is P ROBE for a probe packet and R ECALLED for a recall packet, PARENT and J UNCTION are the parent and junction node in the aggregation tree, to be defined later. When a node w receives a probe packet from p, it first checks whether it has already received any packet from p; if so, this packet is ignored. Otherwise w records the probe packet. In addition, if w has received messages from other hot nodes, w checks if it is a junction node and if any probes need to be recalled. If w has received a message from a node q with priority higher than p, then the probe message from p will be recalled. Node q is a candidate to be the parent of p in the aggregation tree. If p’s priority is higher than all the other hot nodes whose status entries have M SG T YPE = P ROBE at node w, then those probes will be recalled. They are assigned p as a potential parent. The probe packet for p will be re-transmitted. The recall protocol is initiated when a hot node p ‘loses’ to another hot node q at a junction node w. Node q is a possible parent of p. The recall packet contains the IDs of p (the child), q (the parent), and w (the junction node). A recall packet travels at speed M , faster than the speed of the probe packets. A recall packet has no direction associated with it but uses flood-fill to travel through the trails of the probe packets. When a node x receives (or initiates) a recall message, it first checks the status for node p in its local table. If x has received a message from p before and the current status is P ROBE , then x will change the status of p to R ECALLED. The recall message will be broadcast to all the 1-hop neighbors of x. If x has no message from p, or the status is R ECALLED, x does not send the recall message further. When node p itself receives a recall packet for p, it sets its parent to be the parent-candidate q in the packet and remembers the junction node w where the trails of p and q met. Thus the parent of p in the aggregation tree is determined by the first recall packet that reaches p. The boundary of the sensor region is incorporated into the protocol by initializing every boundary node as a junction whose probing node (the base station b) has the highest priority. When a probe packet for hot node p reaches a boundary node w, p loses to b, and w initiates the recall protocol for p with potential parent b and junction node w. Finding boundaries in networks has been addressed by a number of authors [5, 6, 9, 20]. The status tables in the nodes record the trails of probe and recall packets, and also provide a way to suppress redundant retransmissions. Due to the broadcast nature of wireless communication, a packet may be received by multiple nodes. In the probe and recall protocol, multiple nodes may realize they are junction nodes and thus initiate the recall procedure. However, once a node has received a recall packet and updated its status, it will not respond to any further recall packets other nodes may have generated. 4.3 Forming an Aggregation Tree As described in the preceding subsection, the aggregation tree is a logical structure recorded in the hot nodes themselves: each node p knows its parent q in the tree. The parent may either be another hot node or the boundary of the sensor region. Thus the ‘tree’ is actually a forest of trees, with the number of trees in the forest dependent on the distance from the region of hot nodes to the boundary. Nevertheless, we will continue to use the word ‘tree’ to describe the structure—it is still an aggregation tree, but the children of the base station are joined to it by high-performance links. Our simulations, described in Section 7, use the simple parentchild representation of the aggregation tree. The earlier figure 1 shows an example of the tree we obtained. One can see that only a small fraction of the nodes are involved in the tree formation. Although our simulations use the simple tree representation, there are several variants on the tree structure that pay greater attention to the physical embedding of the tree in the sensor network, with varying impacts on communication cost and reliability. Using the logical representation of the aggregation tree, aggregation happens at the hot nodes themselves. The children of a node p send their results to p, p aggregates them, and then p sends the resulting summary on to its parent. There are several choices for how each node p sends data to its parent q. • Send a packet from p along p’s trail to the junction node w, then along q’s trail to q. This has the advantage that the probe and recall protocol has already demonstrated the existence of this path—no path discovery is required. • Use some network-specific point-to-point routing mechanism, such as geographic routing [7], to send a packet from p to q, bypassing the junction w entirely. This reduces the load on the trail nodes, but forces the packet to discover its own path. • If p’s results are known to be particularly important and their successful delivery is crucial, the preceding two possibilities can be combined, or either can be complemented by transmitting in a band around the basic path, with the width of the band dependent on the importance of the message, as described in Section 4.1. Routing along the trails of the logical aggregation tree may cause some inefficiency in the routing. Packets may be sent in one direction along p’s trails from its children, only to have the summary packet from p traverse the same trail in the opposite direction on the way to its parent. We can avoid this redundancy (possibly saving a constant factor in communication costs) by exploiting the embedding of the aggregation tree. We add a third phase to the probe and recall protocol, in which a node p notifies all the nodes in its trails of its parent q and junction node w. This allows all the nodes in p’s trails to direct the trail edges toward w. Node w becomes a proxy for p in the aggregation tree. Instead of sending data to p for aggregation, all p’s children (represented by their proxy nodes on p’s trail) send data along p’s trail to w, where aggregation occurs before w sends a summary packet toward the junction representing p’s parent. Node p also sends its own individual data to w for aggregation. Two variants of this approach are possible: • Each proxy for a child of p sends its data along p’s trail independently to w. A constant fraction of p’s trail may be traversed for each child. • The child proxies along p’s trails may be used as intermediate aggregation points, combining data from the child with data flowing along p’s trail from nodes farther from w along the trail. This reduces the number of messages that must be sent—each trail segment is traversed just once—but makes the aggregation tree more vulnerable to deadlock because of single-node failures. A final modification enhances robustness by replacing the aggregation tree with a DAG. To do this, we modify the recall protocol so that all recall messages for a node p propagate back to p. This increases the amount of communication in the recall phase of the protocol, but has the advantage that p is informed of all its candidate parents, not just the one whose recall packet reaches it first. Node p can choose multiple parents among the candidates, perhaps up to four, one for each cardinal direction. When p performs its aggregation (here we assume the simple tree structure, with aggregation performed at hot nodes rather than proxies), it sends the resulting data to all its parents, thereby increasing the likelihood that the data will reach the base station. Of course this requires that we use an ODI (order and duplicate insensitive) scheme. 5. QUALITY OF THE SPARSE AGGREGATION TREE In this section we discuss the performance of the protocols in the previous section and characterize the aggregation tree that they build. The asymptotic bounds we present apply to all the tree variants discussed in Section 4.3, with the caveat that multiplying the width of important communication paths to increase reliability has a corresponding multiplicative cost in communication resources. As noted in Section 4.2, the clock skew between any two nodes u and v is bounded by α||uv||, where ||uv|| is the network distance between u and v. The speed of probe packets is 1 and the speed of recall packets is M > 1. We denote the set of hot nodes by S. For any hot node p, let trail (p) be the set of nodes in p’s trails. Because of the uniform distribution of sensor nodes, |trail (p)| is proportional to the distance between p and the farthest node in trail (p). Furthermore, |trail (p)| is proportional to the total number of packets in the probe and recall protocol attributable to p. When a probe meets the trail of another node’s probe, at least one of the two will be recalled, if neither has already been recalled. This observation leads to the following lemma (proof omitted): Create a new set X ′ = X \ XM ; by Lemma 5.2, |X ′ | ≤ β|X|, for some constant β < 1. Assembling the pieces, we have f (X) = f (XM ) + f (X ′ ) ≤ ≤ C · |MST (X)| + f (X ′ ) 2C · |MST (S)| + f (X ′ ). The base case for |X| = 1 is f (X) = O(K). By induction on |X|, we have f (X) ≤ 2C · |MST (S)| · log 1/α |X| + O(K).  Because the aggregation tree built in Section 4.3 uses a subset of the nodes in all the trails, the theorem has the following immediate consequence: Theorem 5.4. The aggregation tree constructed by our protocol has total length O(|MST (S)| · log |S| + K), where K is as defined in Theorem 5.3. The maximum degree of the aggregation tree is also important for its performance. Nodes with high degree must perform much more aggregation work than the average (which is just constant). In the following theorem we bound the maximum degree of our aggregation tree. The proof is omitted from this version of the paper. Lemma 5.1. Let u and v be two hot nodes. Then min(|trail (u)|, |trail (v)|) ≤ C · ||uv|| for some constant C . Let E be the set of nearest-neighbor edges: for each hot node u, E contains the edge from u to its nearest hot node, denoted nn(u). Lemma 5.2. E contains a partial matching2 of size Θ(|S|). It is well-known that the minimum spanning tree of S, denoted MST (S), contains all the edges of E. (If MST (S) does not contain e = (v, nn(v)) for some node v ∈ S, adding e to MST (S) creates a cycle, and the tree weight can be decreased by retaining e and removing the other cycle edge incident to v.) The weight of MST (S), i.e., its total length, is |MST (S)|. The length of an individual edge e = (p, q) is len(e) = ||pq||. Theorem 5.3. Let K be the maximum, over all v ∈ S , of the shortest axis-aligned distance from v to the boundary of the sensor region. Then X |trail (v)| = O(K + |MST (S)| · log |S|). v∈S P P ROOF. For any subset X ⊆ S, define f (X) = v∈X |trail (v)|. We want to estimate f (S). For a given X ⊆ S, let E be the set of nearest-neighbor edges defined with respect to X, and let EM be a maximal-cardinality matching in E. Because every edge of EM belongs to MST (X), X len(e) ≤ |MST (X)|. e∈EM Also note that |MST (X)| ≤ |TSP (X)| ≤ |TSP (S)| ≤ 2|MST (S)|, where TSP (·) is the minimum-length traveling salesman tour of a point set. By Lemma 5.1, every edge e ∈ EM is incident to a node v such that |trail (v)| ≤ C · len(e). Let the set of these nodes be XM . We have X f (XM ) = |trail (v)| ≤ C · |MST (X)|. v∈XM 2 A partial matching is a set of edges such that each node is an endpoint of at most one edge. Theorem 5.5. Let A be the aspect ratio of S , i.e., the ratio between the maximum and minimum distances between elements of S . If the clock skew parameter α is less than 1, then the maximum degree of any node in the aggregation tree of Section 4.3 is O(log A). 6. AGGREGATION Many possible aggregation strategies are possible, within the framework discussed above. If the network has solid connectivity and point-to-point routing already in place, then a logical aggregation tree is all that is needed and aggregation can happen in the traditional way, after tree formation. If the network is volatile, however, then a DAG-based approach with multi-path connectivity is preferable, together with an ODI aggregation scheme. Note also that our tree discovery protocol naturally leads to a multiplyconnected structure, as for each pair of nodes the multiple probe paths establish multiple routes between the nodes. Of special interest is the fact that our protocols allow fine interleaving between tree formation and aggregation. Specifically, the random priority needed by the tree formation process can be used to implement a probabilistic aggregation scheme. In this way aggregation is already completed, as soon as the tree is formed. Specifically, we can make use of certain properties of the classical exponential distribution. A random variable x chosen from an exponential distribution with parameter λ, λ > 0, has a probability density function f (x; λ) given by  λe−λx , if x ≥ 0 f (x; λ) = 0, if x < 0 The cumulative distribution function F (x; λ) is given by  1 − e−λx , if x ≥ 0 F (x; λ) = 0, if x < 0 The distribution has mean 1/λ and variance 1/λ2 . The following two properties of the exponential distribution are crucial for us. Theorem 6.1. If x1 and x2 are independent random variables with parameters λ1 and λ1 respectively, then Prob(x1 < x2 ) = λ1 . λ1 + λ 2 Theorem 6.2. If x1 , x2 , . . . , xn are independent exponential random variables, where xi has parameter λi , then min(x1 , x2 , . . . , xn ) is an exponential random variable with parameter Pn i=1 λi . A consequence of these properties is that if x1 , x2 , . . . , xn are independent exponential random variables chosen from exponential distributions with parameters λ1 , λ2 , . . . , λn respectively, then P their minimum is a random variable with mean 1/ n i=1 λi . This effectively allows us to replace a data summation by a data minimization operation which, as mentioned, is insensitive to data duplication and thus is advantageous in a volatile network setting. This use, to our knowledge, was first pointed out by E. Cohen [2], in the context of solving counting problems on large graphs. In our adaptation of the Cohen framework, each network node i holding data value fi independently selects a random number drawn from an exponential distribution with density function fi e−fi x . If µ is the minimum number chosen by any hot node, then 1/µ is an unbiased estimator of the sum of F = f1 + f2 + · · · + fn . Summing values at the hot nodes is a surprisingly powerful aggregation primitive. If node locations are known, this primitive can be used to compute arbitrary moments of the hot node position distribution, conveying a picture of where the exceptional events are being detected. Alternatively, summation can be used to compute moments of the values sensed by the nodes, covariances between node locations and values, etc. For the primitive of summing values, we can use the random number chosen from the exponential distribution described above as the weights in the tree formation protocol. Recall that during tree formation, a number of packets may reach the field boundary, from where these weights can be transmitted to the base station and the minimum weight can be retained. No packet can stop the packets of the hot node whose weight is globally minimal—and therefore these packets will reach the boundary and the base station. Thus as the tree is formed, the base station can immediately derive an approximation to the aggregated value. For applications in which a quick and dirty approximation suffices, our job is done at the moment when the tree is formed. For better accuracy, we can repeat this experiment a number of times. Cohen shows that, for a given parameter ε, if we repeat this experiment O( ε12 log n) times, where n is the number of nodes involved, average the minimum weights obtained in each experiment, and then take the inverse of that, this quantity lies, with high probability, within relative error ε of F . With O( ε12 ) experiments, the expected relative error is at most ε. We report on some simulations validating these bounds in Section 7. In summary, by integrating data aggregation with node discovery and tree formation, the simple distributed probe protocol performs two important tasks at once: it connects the hot nodes into an aggregation tree that is nearly optimal in terms of communication cost, while at the same time performing the min-based aggregation that can translate into an estimate of the final aggregation. The robustness of aggregation deserves further exploration. Note that this type of probabilistic counting has built-in robustness to data loss, as well as duplicate insensitivity. Some of the simulations reported below quantify how many exponential variates are necessary to obtain a given degree of accuracy. For example, if the smallest variate in the counting problem is lost, but the second smallest makes it, our final count will be off by only 1 in expectation— while in regular aggregation a single lost subtree count can cause unbounded error. If other variates are lost, they have no impact on the count. The counting problem also allows this self-determined yet globally consistent notion of data importance, which when coupled with multi-path routing can guarantee further robustness. Although this does not directly extend to the completely general case of summation of hot node values, in most scenarios prior knowledge of the range of node values, past measurements, etc., can be used to develop a notion of the significance of data locally, without requiring additional extensive communication. 7. SIMULATIONS AND EXPERIMENTS In this section we evaluate by means of simulation the performance of our sparse aggregation scheme in a number of settings. 7.1 Communication Costs The main metric we consider is the communication cost of a single aggregation task. If aggregation is initiated by a base station, then we include the costs of both the query phase and the data collection phase. In our protocol there is no query phase. Our aggregation cost is defined to be the cost of forming an aggregation tree, as the basic logical structure described in subsection 4.2, and the cost of sending partial aggregates along child-parent paths if data aggregation/delivery has not been accomplished (if data aggregation is combined with tree formation as in Section 6 this cost is 0). We assume that the cost of sending a message is proportional to the Euclidean distance between the sender and the receiver, a justified assumption in the case of dense deployment. Although not completely realistic, we believe that this assumption does not influence the overall outcomes of our comparisons, but only the absolute costs, which we are less interested in. We compare our algorithm to two general aggregation paradigms, commonly known as ‘push’- and ‘pull’-style aggregation, rather than any specific method proposed in the literature. Almost all existing methods that we are aware of (see Section 2) belong to one of these categories. In Figures 3 and 4, the vertical axis is the ratio of the cost of our scheme vs. the cost of the corresponding ‘push’ or ‘pull’ scheme—thus the smaller the better. ‘Pull’-based method: The base station queries all nodes, and only the hot nodes reply. The query cost is essentially the cost of flooding the entire network. We consider two variations for the data collection cost. In the first data collection, the hot nodes reply by sending the data upstream along the spanning tree constructed in the flooding phase. Data can be aggregated at internal nodes of the tree. We also consider the case when each hot node replies independently along its shortest path to the base station, disregarding any message trails it may encounter along the way. This method invokes higher communication cost, but requires no coordination and scheduling of partial aggregates, which makes it much easier to implement. Since the hot nodes are scattered at unpredictable locations, scheduling for in-network aggregation of irregularly spaced participants is non-trivial. Our two performance metrics are the sum of the fixed query cost and that of the two reply costs, as described above. Note that we discount the costs of both reply methods significantly by disregarding the non-trivial amount of work required to discover the shortest paths and the cost of coordination and scheduling for in-network aggregation, respectively. Another serious overhead that we did not account for in the ‘pull’-method is that the user/sink needs to know when to ‘pull’. As interesting events happen irregularly and unexpectedly, a ‘pull’ approach in practice may waste a lot of communication by querying when the data is not yet be available. Our comparison is unrealistically favorable to this approach, as we simply ignore the cost of the unfruitful polling queries that a practical ‘pull’-method would definitely include. 1 3 separation <= 0.1 0.1 < separation <= 0.2 0.2 < separation <= 0.5 0.5 < separation <= 1.0 separation > 1.0 1.4 1.2 0.6 0.4 0 0 0.05 0.1 0.15 0.2 hot nodes (fraction) 0.25 0.8 0.6 0.4 separation <= 0.1 0.1 < separation <= 0.2 0.2 < separation <= 0.5 0.5 < separation <= 1.0 separation > 1.0 0.2 1 cost (fraction) cost (fraction) cost (fraction) 0.8 2.5 separation <= 0.1 0.1 < separation <= 0.2 0.2 < separation <= 0.5 0.5 < separation <= 1.0 separation > 1.0 0.2 0 0.3 0 0.02 0.04 0.06 0.08 0.1 hot nodes (fraction) 0.12 2 1.5 1 0.5 0 0.14 0 0.05 0.1 0.15 0.2 hot nodes (fraction) 0.25 0.3 Figure 3. (i), (ii) Communication cost of ‘pull’-aggregation in the 100 × 100 grid network. The query dissemination cost is the cost of the flooding on all nodes. Hot nodes reply using shortest paths to the base station (the boundary in this case). (i) Without in-network aggregation; (ii) With in-network aggregation; (iii) Communication cost of ‘push’-aggregation. Hot nodes reply using shortest paths to the boundary. ‘Push’-based method: The hot nodes themselves report to the sink via shortest paths without being explicitly queried. There is no query cost. Again we heavily underestimate the cost in this method by disregarding the cost of maintaining the shortest paths to the sinks (which requires some form of flooding). We consider the regular grid topology and the simulation of the real-world deployment built by the Extreme Scaling (ExScal) project at the Ohio State University, as deployed in Florida in December 2004. We examine how the performance of our aggregation scheme is influenced by the number and density of hot nodes, as well as the delay with which various nodes launch their probes. The delay may come from imperfect synchronization or may be inherent in the application, as in the case of intermittent tracking. 7.1.1 Simulated Grid Network We tested the algorithm on a network with regular grid topology, consisting of 10, 000 nodes (100 × 100 grid). The whole boundary acts as a base station, i.e., the boundary nodes can communicate quickly and reliably using an external network. ‘Pull’ and ‘push’ aggregation: Figure 3 shows how our protocol compares to the ‘pull’- and ‘push’-based methods described above, depending on the number of hot nodes and their spatial proximity. Different curves correspond to varying spatial distributions of hot nodes, specifically the extent to which they are ‘clustered’ in space. In the experiment, hot nodes are generated by first picking a random square of side length equal to the prescribed ‘cluster size,’ then selecting a prescribed number of nodes within the cluster uniformly at random. This models the emergence of some physical events that influence the sensors in its proximity. During the experiments we discovered that the distances of hot nodes to the boundary are important parameters for the cost metric, so we grouped the data points by the separation parameter: the ratio of the diameter of the set of hot nodes in the ℓ∞ norm and the shortest distance between the hot nodes and the boundary. The larger the separation, the further away the hot nodes from the boundary. In the ‘pull’ scenario without in-network aggregation, when compared to the simpler shortest-path-based method (Figure 3 (i)), our algorithm performs better for almost all parameter settings, which is expected, as it avoids flooding the network to announce the query to all nodes. The benefit of our method when hot nodes are colocated is quite significant. In the pull model with in-network aggregation (Figure 3 (ii)), our advantage is not as significant. Again we remark that scheduling in-network aggregation between sparse nodes is not trivial. The major challenge is that, an internal node has no knowledge of whether or not there are hot nodes in its subtree. Thus data propagating upstream has no idea whether it should wait at internal nodes to be aggregated with data from other hot nodes. In our implementation we actually ‘cheat’ in favor of the pull method by assuming that this is known. Even in this very pessimistic comparison, our sparse aggregation scheme is still better when the hot nodes are sparse and well-clustered. For the same reason, in the remaining experiments we only compare with the pull model with hot nodes sending their data separately with no in-network aggregation. In the ‘push’ scenario (Figure 3 (iii)), our tree is better by 20 to 30 percent unless the hot nodes are too few and their separation is small. With only a few very scattered nodes, the sum of their individual shortest paths is indeed nearly optimal. So the ‘peaks’ come from the overhead of our protocol. In other words, most probes get propagated all the way to the boundary (because there is not much opportunity for early aggregation), and our algorithm gets penalized for trying four directions and traversing the same trails twice. Tree quality: We measured the quality of the aggregation tree built by our algorithm. Equivalently, this is the cost of collecting the data from all hot nodes, once an aggregation tree has been built. For instance, this could be the per-iteration cost of repeated aggregation from a fixed set of sources in a short time interval during which the tree is sufficiently stable. In light of our theoretical result (Theorem 5.4), we normalize the cost by that of the MST of the hot nodes and the base station. The results are shown in Figure 4 (i). One can see that, at least for networks of this size, the MST approximation factor does appear to grow nearly logarithmically with the number of hot nodes. However, the constant factor is very good (much better than the explicit constants of the theorem would suggest): our aggregation tree was never more than twice the length of the MST. Tracking: We now consider the application of sparse data aggregation to the problem of tracking a target that is only intermittently detected. In this experiment we assume for simplicity that the target moves along a straight-line path with constant speed. We vary the target speed (relative to the message speed), and the density of detections along the track. For each fixed setting of the two parameters, we generate 50 line segments with randomly chosen endpoints as the trajectories of the target. For a given track, we distribute the target detections uniformly along the track and trigger each observing node’s probes when the target passes by this node. We examine how the speed of the tracked object influences the cost of the sparse aggregation tree. The probes of consecutive hot nodes along the object’s path are now launched with clock skew inversely proportional to the speed of the object (i.e., the faster the target moves, the smaller the clock skew of the probe packets). As before, we compare our cost to the cost of the ‘pull’ aggregation initiated by the boundary nodes, where the observers reply 1.8 0.4 3.5 0.35 3 1.7 pull push 2.5 1.5 1.4 1.3 1.2 density 0.2, speed 1/3 speed 1/2 speed 1 speed inf. density 0.4, speed 1/3 speed 1/2 speed 1 speed inf. density 0.8, speed 1/3 speed 1/2 speed 1 speed inf. 0.2 separation <= 0.1 0.1 < separation <= 0.2 0.2 < separation <= 0.5 0.5 < separation <= 1.0 separation > 1.0 1.1 1 0.9 1e-04 0.25 0.001 0.01 hot nodes (fraction) 0.15 0.1 1 cost (fraction) 0.3 cost (ratio) cost (fraction) 1.6 0.1 2 4 6 8 10 12 14 16 18 2 1.5 1 0.5 0 20 22 observations 0 0.05 0.1 hot nodes (fraction) 0.15 0.2 Figure 4. (i) The cost of our aggregation tree (excluding the tree formation cost) for a 100 × 100 grid network, vs. the cost of the MST of the hot nodes and the base station. The behavior agrees with Theorem 5.4. (ii) Tracking an intermittently observable target. ‘Density’ is in number of observers per one grid cell of track length. ‘Speed’ is the ratio of the speeds of the target and probe message propagation. (iii) Performance on the ExScal deployment. 180m 7.1.3 Summary 90m Our simulation results lead to the following conclusions regarding the comparative communication costs of the sparse aggregation framework and the ‘push’ and ‘pull’ aggregation paradigms: 9m ··· 9m ··· ··· NORTH WEST 36m • The sparse aggregation scheme is consistently more communication efficient compared to the ‘pull’-based approach without in-network aggregation, for both the grid and ExScal topologies. This remains true even when compared to ‘pull’based aggregation (favored by our assumptions), as long as the percentage of hot nodes is less than 8% or so. The sparse aggregation scheme is also superior to the ‘push’-based approach, if more than 3% of nodes are hot. Thus sparse aggregation fills in an interesting gap between scenarios where ‘pull’ and ‘push’ methods are respectively preferred. EAST ··· ··· 4.5m SOUTH 4.5m Figure 6. A typical section of the Thick Horizontal part of the ExScal deployment. There are 100 motes (shown as disks) and 4 stargates (only two shown as triangles). independently using shortest paths. The results are shown in Figure 4 (ii). The simulation results show the following observation. We are at least 50% better in terms of total communication cost. When the clock skew of the probe packets is smaller, the probe packets are recalled earlier. This results in lower total communication cost. 7.1.2 Simulated ExScal Deployment Our second set of simulations used the ExScal deployment model, in particular the deployment setup that the ExScal documents refer to as Thick Horizontal. It is a two-tier deployment, with Tier 1 consisting of XSM motes, and Tier 2 of more powerful stargate nodes. Some stargates are designated as gateways between the tiers. The deployment consists of 7 sections (see Figure 6), each containing about 100 motes, 2 gateway stargates and 2 stargates that communicate strictly in Tier 2. The sections are laid out in sequence along a straight line (see Figure 5). The network is organized hierarchically to facilitate routing and other applications. Each stargate is responsible for its section. For the sparse aggregation problem, these gateway stargates provide natural aggregation points for hot nodes within one section. For this deployment we let the leftmost stargate (in Figure 5) be the base station. In tree formation, we choose the four neighbors for double ruling as shown in Figure 6. The results are in Figure 4 (iii). In this simulation we only used the metric where the hot nodes reply to the base station using shortest paths (in this case, this is the shortest path to the nearest stargate plus a path up the hierarchy). The important features of the resulting plots consistently agree with those of the grid network (Figures 3 (i) and 3 (iii)). When the hot nodes are extremely sparse (less than 3%), the ‘push’ scheme is the most efficient, otherwise our scheme works better. The ‘pull’ scheme is consistently the worst. • The efficiency of our sparse aggregation scheme becomes more evident when hot nodes are clustered and far from the network boundary. • Modest clock drift does not affect the aggregation cost significantly. 7.2 Quality of Probabilistic Aggregates Recall from Section 6 that the theoretical bound for the number of experiments with exponential variates required for a relative error of ε in expectation and with high (inverse polynomial in the number of hot nodes) probability is O(ε−2 ) and O(ε−2 log n), respectively, where n is the number of hot nodes. We ran an experiment to test how the algorithm performs in practice. We focused on the simplest problem of counting, and chose several ground truth (exact count) values ranging from 10 to 10, 000. Notice that the theoretical convergence speed does not depend on the actual count, but only on desired accuracy (relative error) and confidence (probability of success). For each exact count we recorded the number of experiments needed to achieve relative error of 10%, 5% and 1%. Figure 7 shows the failure probability (one minus the confidence) vs. the number of experiments. Estimates of this probability are obtained from 1, 000 independent experiments3 . The results form three dense ‘clusters’ of curves. A cluster corresponds to a target accuracy, and a curve within a cluster to a ground truth value. Thus we confirm that the exact count has little influence on the convergence. The remaining three curves are the theoretical counterparts. They are simply plots of the function (for complete derivation see [2]) 3 These experiments are not to be confused with the experiments for estimating the counts. The latter are run an a priori unbounded number of times, i.e., until the desired accuracy is reached. Figure 5. The complete layout of the Thick Horizontal part of the ExScal deployment. There are 729 motes and 29 stargates (notice that the leftmost section contains an extra stargate). Stargates shown as black triangles communicate only in Tier 2. probability of failure 1 theory, 1% accuracy theory, 5% accuracy theory 10% accuracy experiment, 1% accuracy experiment, 5% accuracy experiment, 10% accuarcy [6] 0.1 [7] [8] 0.01 100 1000 number of experiments Figure 7. Convergence speed of probabilistic count estimates based on exponential variates. k P k P − 1−ε k−1 ki ki k → 1 − e− 1+ε k−1 i=0 i!(1+ε)i + e i=0 i!(1−ε)i , where ε ∈ {0.01, 0.05, 0.10}. The actual estimates are consistently better than theoretical predictions. An estimate from around 50 experiments is good enough for many applications—it is within 10% of the exact count with probability 0.9. The theoretical requirement for the same accuracy and confidence is about 10 times as high. 8. [10] [11] CONCLUSION We have shown how to aggregate data from a sparse set of relevant nodes in a wireless sensor network. We believe that the probe and recall protocols proposed here can be useful in other contexts, e.g. for stopping a flood once its task has been accomplished, etc. Acknowledgement: The authors wish to thank Anish Arora and Santosh Kumar of Ohio State for sharing with us the topology of their ExScal deployment, as well as the anonymous referees for their valuable comments. Jie Gao was supported by NSF CNS0643687 and funding from Stony Brook’s Center of Excellence in Wireless and Information Technology. Nikola Milosavljevic and Leonidas Guibas were supported by NSF grants CNS-0435111, CNS-0626151, ARO grant W911NF-06-1-0275, the Max Planck Center for Visual Computing and Communications, and the DoD Multidisciplinary University Research Initiative (MURI) program administered by ONR under Grant N00014-00-1-0637. 9. [9] [12] [13] [14] [15] [16] REFERENCES [1] D. Braginsky and D. Estrin. Rumor routing algorithm for sensor networks. In Proc. 1st ACM International Workshop on Wireless Sensor Networks and Applications, pages 22–31, 2002. [2] E. Cohen. Size-estimation framework with applications to transitive closure and reachability. J. Comput. Syst. Sci., 55(3):441–453, 1997. [3] J. Considine, F. Li, G. Kollios, and J. Byers. Approximate aggregation techniques for sensor databases. In ICDE ’04: Proceedings of the 20th International Conference on Data Engineering, pages 449–460, 2004. [4] G. Cormode, M. Garofalakis, S. Muthukrishnan, and R. Rastogi. Holistic aggregates in a networked world: Distributed tracking of approximate quantiles. In SIGMOD ’05: Proceedings of the 2005 ACM SIGMOD International Conference on Management of Data, pages 25–36, 2005. [5] S. P. Fekete, M. Kaufmann, A. Kröller, and K. Lehmann. A new approach for boundary recognition in geometric sensor networks. In [17] [18] [19] [20] 17th Canaidan Conference on Computational Geometry, pages 82–85, 2005. S. Funke. Topological hole detection in wireless sensor networks and its applications. In DIALM-POMC ’05: Proceedings of the 2005 Joint Workshop on Foundations of Mobile Computing, pages 44–53, 2005. B. Karp and H. Kung. GPSR: Greedy perimeter stateless routing for wireless networks. In Proc. of the ACM/IEEE International Conference on Mobile Computing and Networking (MobiCom), pages 243–254, 2000. M. Khan, V. Kumar, and G. Pandurangan. Distributed local algorithms for constructing approximate minimum spanning trees with applications to wireless sensor networks. Dept. Comput. Sci., Purdue University, West Lafayette, Indiana, 2006. A. Kröller, S. P. Fekete, D. Pfisterer, and S. Fischer. Deterministic boundary recognition and topology extraction for large sensor networks. In Proceedings of the 17th Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1000–1009, 2006. X. Liu, Q. Huang, and Y. Zhang. Combs, needles, haystacks: balancing push and pull for discovery in large-scale sensor networks. In SenSys ’04: Proceedings of the 2nd International Conference on Embedded networked sensor systems, pages 122–133, New York, NY, USA, 2004. ACM Press. S. Madden, M. J. Franklin, J. M. Hellerstein, and W. Hong. TAG: A Tiny AGgregation service for ad-hoc sensor networks. SIGOPS Oper. Syst. Rev., 36(SI):131–146, 2002. A. Manjhi, S. Nath, and P. B. Gibbons. Tributaries and deltas: Efficient and robust aggregation in sensor network streams. In SIGMOD ’05: Proceedings of the 2005 ACM SIGMOD International Conference on Management of Data, pages 287–298, 2005. S. Nath, P. B. Gibbons, S. Seshan, and Z. R. Anderson. Synopsis diffusion for robust aggregation in sensor networks. In SenSys ’04: Proceedings of the 2nd International Conference on Embedded Networked Sensor Systems, pages 250–262, 2004. D. Niculescu and B. Nath. Trajectory-based forwarding and its applications. In Proc. 9th Annual International Conference on Mobile Computing and Networking (MobiCom 2003), pages 260–272. ACM Press, 2003. R. Sarkar, X. Zhu, and J. Gao. Double rulings for information brokerage in sensor networks. In Proc. of the ACM/IEEE International Conference on Mobile Computing and Networking (MobiCom), pages 286–297, September 2006. S. Shakkottai. Asymptotics of query strategies over a sensor network. In Proc. of the 23rd Annual Joint Conference of the IEEE Computer and Communications Societies (InfoCom), pages 557–565, March 2004. N. Shrivastava, C. Buragohain, D. Agrawal, and S. Suri. Medians and beyond: New aggregation techniques for sensor networks. In SenSys ’04: Proceedings of the 2nd International Conference on Embedded Networked Sensor Systems, pages 239–249, 2004. P. Skraba, Q. Fang, A. Nguyen, and L. Guibas. Sweeps over wireless sensor networks. In IPSN ’06: Proceedings of the 5th international conference on Information processing in sensor networks, pages 143–151, 2006. F. Stann, J. Heidemann, R. Shroff, and M. Z. Murtaza. RBP: robust broadcast propagation in wireless networks. In SenSys ’06: Proceedings of the 4th international conference on Embedded networked sensor systems, pages 85–98, 2006. Y. Wang, J. Gao, and J. S. B. Mitchell. Boundary recognition in sensor networks by topological methods. In Proc. of the ACM/IEEE International Conference on Mobile Computing and Networking (MobiCom), pages 122–133, September 2006.