Computer Science Technical Report Archive

USC Computer Science Technical Reports, no. 774 (2002)

(USC DC Other)

USC Computer Science Technical Reports, no. 774 (2002)

PDF

Download a page range

Download transcript

Copy asset link

Request this asset

Transcript (if available)

Content 1
Computing Aggregates for Monitoring Wireless
Sensor Networks
Jerry Zhao, Ramesh Govindan, Deborah Estrin
Abstract—Wireless sensor networks involve very large num-
bers of small, low-power, wireless devices. Given their unat-
tended nature, and their potential applications in harsh envi-
ronments, we need a monitoring infrastructure that indicates
system failures and resource depletion. In this paper, we briefly
describe an architecture for sensor network monitoring, then
focus on one aspect of this architecture: continuously com-
puting aggregates (sum, average, count) of network properties
(loss rates, energy-levels etc., packet counts). Our contribu-
tions are two-fold. First, we propose a novel tree construction
algorithm that enables energy-efficient computation of some
classes of aggregates. Second, we show through actual imple-
mentation and experiments that wireless communication arti-
facts in even relatively benign environments can significantly
impact the computation of these aggregate properties. In some
cases, without careful attention to detail, the relative error in
the computed aggregates can be as much as 50%. However, by
carefully discarding links with heavy packet loss and asymme-
try, we can improve accuracy by an order of magnitude.
I. INTRODUCTION
Wireless sensor networks will consist of large numbers
of small, battery-powered, wireless sensors. Deployed in
an ad-hoc fashion, those sensors will coordinate to monitor
physical environments at fine temporal and spatial scales [1],
[2], [3]. Wireless sensor networks will be autonomously de-
ployed in large numbers. Energy-efficiency is a key design
criterion for these sensor networks.
A monitoring infrastructure will be a crucial component of
a deployed sensor network. Such an infrastructure indicates
node failures, resource depletion, and other abnormalities.
Our first contribution is an architecture for sensor network
monitoring infrastructures, one that consists of three classes
of software. The first class of software continuously collects
aggregates of network properties (we call them network di-
gests) in the background. Triggered by sudden changes in
these properties, scans can be invoked to provide global, yet
aggregated, views of system state. Such views can indicate
the location of performance problems or impending failure
within the network. Dumps can then be used to collect de-
tailed node state to debug the problem. These three pieces of
software are invoked at different spatial and temporal scales,
and will allow accurate, yet low-overhead sensor network
monitoring.
Our second contribution is the design of protocols to con-
tinuously compute network digests. Abstractly, a digest is
defined by an digest function f(v
1
; v
2
;; v
n
), where v
i
is
the value contributed by each node i. In this paper, we con-
sider v
i
’s that represent some aspect of network operation:
node energy level, degree of connectivity, volume of traffic
seen etc. A key property of the class of aggregates we are
interested in is decomposability [4], [5]. f is decomposable
by a function g if it can be expressed as:
f(v
1
;; v
n
) = g(f(v
1
;; v
k
); f(v
k+1
;; v
n
))
Decomposable digest functions include min, max, average,
and count. The median, for example, is not decomposable.
Aggregation has been discussed in different contexts such
as large scale databases [6], active networks [7], and wireless
sensor network applications [8], [9], [5]. However, comput-
ing digests for sensor networks poses unique design chal-
lenges. Digests are computed continuously and from the
entire network. Furthermore, computing digests represents
background activity and not the sensing task done by the
applications (in contrast to queries that compute the aver-
age temperature of a region, for example). Finally, prior
aggregation schemes have been designed to deliver aggre-
gates on-demand to a small number of users outside the
network; we argue that digests should be continuously dis-
tributed throughout the entire network. This will allow users
low-latency access to digests from any node within the net-
work. In addition, it may also enable applications to tailor
their performance based on the values of digests (e.g., shift
to a different mode of operation when the average energy
level falls below a certain threshold).
A. Our Approach
These observations lead to two key constraints in the de-
sign of protocols for digest computation. First, digest proto-
cols must be aggressively energy-efficient, far more so than
2
other components of the system. Second, because there isn’t
a natural initiator for a digest (e.g., a user node) the routing
structures for digest computations must be autonomously de-
rived.
To achieve aggressive energy-efficiency, we propose to
piggyback digest computation messages on neighbor-to-
neighbor communication. We observe that many proposed
sensor network protocols for medium access [10] and for
topology control [11], [12] include periodic beaconing. Di-
gests, being small by definition, can easily be piggybacked
on such communication. While not itself a new idea, this ap-
proach seems almost necessary to achieve very low energy
expenditures for digest computation. This approach trades-
off latency for energy savings. We quantify this trade-off in
a later section.
We observe that some decomposable digest functions like
min and max can be computed using a technique we call di-
gest diffusion
1
. For example, suppose we are interested in
computing a digest that represents the value of minimum en-
ergy at any node in the network; call this value E
min
. Each
node periodically broadcasts to its neighbors (e.g. by pig-
gybacking on other messages) its own energy, as well as its
current estimate of E
min
. Each node also sets its estimate
of E
min
to the lower of its own energy-level and the lowest
among the estimates heard from its neighbors. After a few
iterations (intuitively, a number proportional to the network
diameter), all nodes converge to the right E
min
. In other
words, E
min
diffuses out to the network. (This is, of course,
a simplified description. We describe our protocol more fully
in Section IV).
Thus, digest diffusion can be used to evaluate one class
of digests, and satisfy two important requirements we dis-
cussed above. First, every node ends up with an estimate of
the digest. Second, these computations do not need to be ex-
plicitly initiated by some external action (e.g. by injecting a
query into the system).
Not all digest functions can be computed using iterative
diffusing computations. For example, the average and count
functions, being non-idempotent, can be particularly sensi-
tive to duplicates. Our simple diffusing computation can eas-
ily deliver duplicate data to a node. To compute this class of
digests, though, we observe that computing a min or a max
using an iterative diffusing computation results in a tree that
spans the entire network. As we show in Section IV, we can
use this tree to compute this class of digests, by propagat-
ing digest values to the root of the tree. Note that this tree
is not constructed by user initiation, but as a by-product of
1
This is in contrast to directed diffusion [8]. a data-centric routing
paradigm.
computing a min or a max digest
2
Finally, we note that some digests are particularly sensitive
to packet loss. Count is an example of this. That wireless
links can be significantly lossy is anecdotally well known.
However, not much work has gone into quantifying the ex-
tent of loss, until recently. Morris et al. show the prevalence
of lossy and asymmetric links in 802.11 environments [13].
Our own experiments confirm this in Section V for a network
of motes (the sensor node platform). Even in fairly benign
environments, we observe widespread and time-varying oc-
currences of heavy link loss and asymmetry. We also demon-
strate that simple implementations of the count digest can
exhibit severe error in these environments. We then show
that a careful implementation that selectively avoids lossy
and asymmetric tree links can improve the accuracy of count
computation, sometimes by an order of magnitude.
To our knowledge, this paper is the first to articulate an ar-
chitecture for sensor network monitoring. Our paper fleshes
out a very practical implementation of one component of
this architecture, discussing how real-world artifacts can se-
riously impact the performance of the monitoring system.
B. Paper Organization
The rest of the paper is structured as follows. The next two
sections describe an infrastructure to monitor wireless sensor
networks in details, and give a brief definition of aggregate
network properties. Section IV describes our approach that
enables energy-efficient computation of aggregate properties.
Section V describes link quality estimation and rejection al-
gorithms to reduce the negative impacts of packet loss on the
performance of the computation process. The performance
of our design is evaluated by implementation on a testbed
and a simulator in Section VI and VII. We conclude our work
with related work and discussion of strength and limitation of
our approach.
II. MONITORING WIRELESS SENSOR NETWORKS: AN
ARCHITECTURE
While the main focus of this paper is a specific set of di-
agnostic tools for sensor networks (digests), we describe in
this section our vision for how these tools fit into a coher-
ent architecture for monitoring sensor networks. This ar-
chitecture, which is quite different from the classical SNMP
[14] architectural model (centralized collection of per-device
2
The notion here is that the network will be continuously computing
several kinds of digests, depending on the needs of the particular deploy-
ment. We think at least one of them will be a min or max digest, and that
can form the basis for computing other digests.
3
statistics), is motivated by the need for energy-efficient com-
munication in sensor networks.
Our architecture is distinguished by three levels of mon-
itoring, where each level consists of a class of tools. Each
level is distinguished from the next in the spatial or temporal
scale at which the corresponding tools are invoked. This is
illustrated in Figure 1.
Fig. 1. Monitoring wireless sensor networks
The first component consists of tools such as dump. Upon
user’s request, dump collects detailed node state or logs over
the network for diagnosis. For example, we could dump
the raw temperature readings from some sensors to debug
the collaborative event detection algorithm between nearby
nodes. Dump can be implemented as an application upon
directed diffusion[8]. Because the amount of data per node
may be large, dump should be invoked only at small spatial
scales (i.e., from a few nodes), and only when there is a rea-
sonable certainty of a problem at those nodes.
To guide system administrators to the location of prob-
lems, we envision the second class of tools that we call scans.
Scans represented abstracted views of resource consumption
throughout the entire network, or throughout a significant
section of the network. Thus, this class of tools has a sig-
nificantly greater spatial extent than dumps. One example
of a scan is the escan [15]. To compute an escan, a special
user-gateway node initiates collection of node state, for in-
stance residual energy supply level, from every node in the
system. Instead of delivering the raw data to user node, es-
can computation takes advantage of in-network aggregation.
Residual energy level data from individual nodes are com-
bined into more compact forms, if and only if those nodes
are nearby and have similar energy level. By pushing the
data processing into the network, escan constructs an approx-
imate system-wide view of energy supply levels with much
less communication cost compared to centralized collection.
From such a global view, users are able to isolate those nodes
upon which they can invoke tools such as dump.
Clearly, the energy cost of collecting an escan can be sig-
nificant, and our third class of tools, digests, can help alert
users to error conditions (partitions, node deaths) within the
network. As we have described before, a digest is an ag-
gregate of some network property. For example, the size of
network i.e. the number of nodes, can indicate several sys-
tem health conditions: Sudden drop in the network size can
be taken as hint for massive node failure or network parti-
tioning. In the paper, we show how to collect aggregates ef-
ficiently, accurately, and continuously. Digests, like escans,
also span the entire network, or a large spatial extent. How-
ever, unlike escans, they are continuously computed. Digests
are not intended to isolate network problems, merely to tell
users when to invoke network-wide scans.
III. DEFINITIONS, ASSUMPTIONS, AND MODELS
We assume that the sensor network consists of n nodes de-
ployed in an ad-hoc manner. Nodes have unique identifiers.
Nodes may crash due to failures or resource depletion and
new nodes may join the network. Nodes are static or move
infrequently. Each node can communicate with its neighbors
within certain range. Communication between nodes may be
lost due to noise or collision. We do not assume a specific
MAC or routing protocol, but do assume the radio capability
to broadcast messages to neighbors.
Recall that a digest function is denoted by
f(v
1
; v
2
;; v
n
), where v
i
is the value contributed by
sensor node i. Additionally, f is decomposable by a function
g:
f(v
1
; v
2
;; v
n
) = g(f(v
1
;; v
k
); f(v
k+1
;; v
n
))
A decomposable digest function is one in which the final re-
sult can be calculated from partial results. The values v may
either be scalars or vectors. For example, to compute average
residual energy supply level in the network, we can define
v =< s; c > and aggregate function
g
AV G
(v
1
; v
2
) =< v
1
:s + v
2
:s; v
1
:c + v
2
:c >
where s and c are the sum of energy level and c is the node
count, respectively. The average value is derived from the
final result v:s=v:c.
The problem of digest computation is: Each node i pro-
vides a value v
i
as its contribution to the digest function f,
where v
i
may change over time. The goal of the digest com-
putation mechanism is for each node in the network to con-
tain a continuous estimate for the current value of f. In this
4
paper, we limit the digest functions we consider to V
MAX
,
V
AV G
, V
SUM
and V
CNT
, which respectively denote the
maximum, average, and sum of v
1
; v
2
;v
n
, and number
of the nodes in the network.
There is a specific rationale for our choice of digest func-
tions, since these functions are qualitatively different from
each other. Using terminology from [5], a digest function is
monotonic if and only if, when two partial results r
1
and r
2
are combined by a function r = g(r
1
; r
2
), the result r sat-
isfies8i = 1;2 r r
i
for an ordering relationship. It is
exemplary if the final result can be determined from one sin-
gle contribution value. In our set of digest functions, V
MAX
is monotonic and exemplary, while V
CNT
is monotonic but
not exemplary, and V
SUM
and V
AV G
may not be monotonic
(if negative values are allowed) and are certainly not exem-
plary. Finally, as we shall argue later, the loss sensitivity of
V
AV G
may be different from that of V
MAX
.
IV. COMPUTING DIGESTS
In this section, we discuss techniques for computing digest
functions for sensor network monitoring.
A naive, centralized, approach to compute digest functions
is to have each node send its value to a designated head node
H. H computes the final result from all the values received.
This approach does not scale well with network size. First,
there is possible message implosion at nodes near H. Sec-
ond, it can incur heavy processing work load at H to aggre-
gate values from all nodes. Third, H represents single point
of failure.
Our approach leverages in-network aggregation. Each
node computes a partial result of the digest function, and
passes that result to other neighboring nodes (we describe the
exact technique in the next two sections). For this, we lever-
age the fact that our digest functions are all decomposable.
In-network aggregation has better energy-efficiency charac-
teristics; communication overhead is less, and the computa-
tion is evenly distributed.
A standard way of computing these digest functions using
in-network processing is, of course, to use a hierarchy and
propagate the digest up to the root, computing partial values
along the way. Such an approach is exemplified by the ap-
proach of Gupta et al. [4], where node location is leveraged
to construct a “Grid Box” hierarchy. However, their approach
for computing aggregates requires leader election within grid
boxes, and other maintenance overhead. One requirement for
our monitoring application, of course, is that digest compu-
tation has to be aggressively energy-conserving. Another ap-
proach, with similar drawbacks from the perspective of mon-
itoring, is the idea of recursive clustering elections[16], [17].
Instead of using more heavyweight hierarchy and cluster-
ing techniques, we use a two-pronged approach for comput-
ing digests.
We note that some of our digests can be computed by a
scheme we call digest diffusion.
Digest diffusion implicitly builds a tree. We use this
tree to compute digest functions by propagating partial
results up the tree towards the root.
We now describe these in some more detail.
A. Digest Diffusion
We note that monotonic and exemplary digest functions
can be computed efficiently by localized information ex-
changes between one-hop neighbors. We call this tech-
nique digest diffusion. We now describe digest diffusion for
V
MAX
. Initially, each node i sets its perceived maximum
value m
i
= v
i
, source of maximum s
i
= i, hop distance
h
i
= 0 and periodically sends a tuple M = (m
i;
; s
i
; h
i
) to
its neighbors. Upon receiving a message (m
j
; s
j
; h
j
) from
neighboring node j with m
j
> m
i
, node i sets m
i
= m
j
,
s
i
= s
j
, h
i
= h
j
+ 1 and parent p
i
= j. If m
j
= m
i
, it fur-
ther checks if s
j
> s
i
, which guarantees strict monotonicity.
Node i may switch its parent node from j to node k, when
k provides the same maximum value but a shorter hop dis-
tance h
k
< h
j
. Gradually within O(d=(1 p)) steps (d is
the diameter of the network, p is packet loss rate per link.),
all nodes agree on a node s with the maximum value v.
This fusion based approach is simple but efficient. It is
fully distributed and requires no base-station or user node
to initiate the computation. The computation converges in
a time proportional to the network diameter. It is energy-
efficient and scales well with network size since the over-
head at each node is constant over time. The information ex-
changed between neighbors is small and can easily be piggy-
backed
3
on other neighbor-to-neighbor communication (e.g.,
beacons sent by MAC protocols or protocols for topology
adaptation
4
).
3
Of course, if the network is continously computing many digests in
parallel, then piggybacking does not make sense. In that situation, one can
combine the information required from several digests into one message
and achieve similar amortization benefits.
4
The advantage of piggybacking, of course, is that it can avoid the
header and framing costs associated with sending the information on a
separate packet. In addition, in sensor networks, waiting to piggyback the
information on other transmissions can save the cost of turning on and off
radios (e.g., if the MAC layer has turned off the radio for power saving)
compared to sending the information immediately.
5
B. Computing Other Digests
However, digest diffusion cannot be used to compute non-
exemplary digests, such as V
AV G
. One of the fundamental
reasons is that when a node tries to aggregate the V
AV G
par-
tial results from its neighbors, it is difficult to determine if
there are any overlaps between those results. For example,
in Figure 4, node E tries to aggregate the partial results for
V
AV G
from C and D. however without explicit knowledge
whether values from A, B have been accounted by C, D or
both of them, it is impossible for E to aggregate correctly.
We note that digest diffusion implicitly constructs a tree
whose root is the node that contributes to the value of the
exemplary digest (e.g., the node that has the maximum value
in a V
MAX
digest. Digest diffusion also computes a parent
p
i
for each node i (see Section IV-A). We call this tree the
digest tree.
Other digest functions can be computed easily on this tree.
For example, with the aggregation tree from V
MAX
compu-
tation, it is straightforward to calculate compute V
AV G
: node
i periodically calculates a partial result from most recent re-
ports from its children c
1
; c
2
;; c
k
, for node count
n
i
=
k
X
j=1
n
c
j
+ 1
and average value
a
i
=
P
k
j=1
n
c
j
a
c
j
+ v
i
n
i
It then sends out < a
i
; n
i
> to its parent p
i
along the tree.
Hop by hop, the partial results are propagated up to the
root, where the final result of V
AV G
is calculated. It takes
O(d=(1p)) time to converge on the correct result, given the
tree structure is stable. We may further reduce communica-
tion cost by incrementally updating the partial digests. Only
those subtrees that have nodes whose values have changed
beyond a certain threshold need to send their partial results.
Finally, in a similar fashion, the root can propagate a com-
puted digest down the tree such that all nodes can maintain a
current estimate for the digest.
The digest tree construction process is fully distributed
and robust. The tree migrates adaptively when the current
root fails, since digest diffusion will try to find the new value
for V
MAX
. Not all metrics are suitable to construct the ag-
gregation tree. For example, the maximum node link de-
gree is a bad choice because the node with the maximum
degree (maximum number of neighbors) may change fre-
quently over time. A stable tree can avoid short-term errors
in the computed digest values caused by root switching. A
digest tree based on the maximum coarse-grained residual
energy level of a node tends to hold still over relative long
time period. When the current root node is exhausted, the
protocol changes the root of the tree to the next most energy-
rich node in the network.
C. Digest Tree Maintenance
Maintenance of the digest tree against topology changes
such as node failure and addition is also combined within the
process of updating V
MAX
: Each node periodically broad-
casts a message M = (m; s; h) for updating V
MAX
every
T
0
seconds, as described in the previous sub-section. Topol-
ogy adaptation is through soft-state techniques. The parent
node identifier expires if node A does not receive any mes-
sage from its current parent after T
p
seconds.
Node A then switches to another node (including A itself)
which provides the largest value with the smallest hop dis-
tance during the last T
p
seconds. Simiarly, each node keeps
a timer T
c
for the partial result sent by its child. Addition-
ally, a sequence number or time-to-live value from the root is
placed into each message to avoid possible looping when the
root node itself crashes.
It takes T
p
seconds to detect a parent node failure or
disconnection. The time-out value has to be carefully se-
lected. Ideally, we would set T
p
= T
0
for fastest response
to topology changes. However, the stability of the tree is
equally important. Considering existence of packet loss, set-
ting T
p
= T
0
leads to significant oscillation in the tree struc-
ture. We quantify how stable the parent-child relationship is
as follows:
(T) = 1 p
T
T
0
where p is packet loss probability for the link. is the prob-
ability that a soft-state is refreshed within T seconds. The
goal is to minimize T for fast adaption to topology changes,
while having certain bound on so that the tree structure
is stable. Table I describes the relation between T , , and
p. Conservatively, we choose T
p
= 4T
0
in our experiments,
which keeps the tree relatively stable even when all the links
suffers packet loss as much as 30%.
V. IMPACT OF PACKET LOSS
Packet loss can significantly impact the computation of
some classes of digests. In this section, we quantify this
phenomenon by observing packet loss rates in a deployed
wireless network under relatively benign conditions. These
results suggest that our design of digest computation must
6
TABLE I
TIME-OUT VALUE V.S. SOFT-STATE STABILITY
T
T
0
= 90% = 99% = 99:9%
p = 10% 1 2 3
p = 20% 1:4 2:9 5:2
p = 30% 1:9 3:8 5:7
p = 50% 3:3 6:6 9:7
Fig. 2. Distribution of link quality
0
10
20
30
40
50
60
70
80
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
Percentage of Links
Probability of Successful Reception (1−p)
1x26 Line
2x13 Grid
5x5 Grid
explicitly deal with lossy links, the subject of our next sec-
tion.
Several factors affect packet loss over a wireless commu-
nication channel. The signal strength fading effect leads to
low signal noise ratio over long distances. Environmental
interference, which may be sporadic or constant, also con-
tributes to packet loss. Packet collision between multiple
transmitters, particularly the hidden terminal problem, is an-
other factor. As a special case of packet loss, an asymmet-
ric link arises between a pair of nodes when only one can
directly communication with the other. The use of transmis-
sion range control protocols can result in nodes to transmit
with different powers. Even with the same power setting,
different receivers may experience different levels of chan-
nel interference. Depending on those conditions, empirical
studies show that heavy packet loss and link asymmetry can
be quite common in wireless networks [18], [13].
Our measurements on a testbed consisting of motes (de-
tailed description in Section VI) qualitatively confirm the
same findings but in different environment. In our experi-
ments, packet loss for each link is measured every minute for
two hours in different topology settings. A link is defined
as a good link if its average packet loss p 30% or a bad
one if p 80%. Figure 2 shows that common existence of
links with heavy packet loss: Though majority of the links
are good links, more than 10% of the links suffers average
loss rate greater than 50%. To evaluate connectivity asym-
metry, links between a pair of nodes are defined as symmetric
if both are good links, and as asymmetric if one is a good link
and the other is a bad link. A link pair are relatively asym-
metric if their loss rate difference is greater than 35%. Table
II indicates asymmetric links are also quite common. Statis-
tics also shows that the packet loss of most links fluctuates
over the time with an estimated variance of 9% to 17%.
TABLE II
Percentage OF SYMMETRIC AND ASYMMETRIC LINKS
Percentage 1x26 Line 2x13 Grid 5x5 Grid
Symmetric (2G) 72:5% 69:5% 81:1%
Asymmetric (1G1B) 12:5% 10:2% 7:2%
Symmetric Bad (2B) 3:8% 2:9% 3:1%
Relatively Asymmetric 17:5% 16:8% 12:3%
A. Impact on the Aggregation Tree
Not only is loss rate prevalent, it can also adversely affect
the computation of digests, as this section shows.
Fig. 3. A plot of CNT (1x26 network)
0
5
10
15
20
25
30
35
40
0 50 100 150 200 250 300 350 400 450 500
Node Count
Time (second)
Real Count
Observed Count Without Link Rejection
Observed Count With Link Rejections
In Section IV, we described a design for digest computa-
tion that involves constructing a digest tree. Figure 3 shows
the results, on a 26-node linear topology, from the direct im-
plementation of a V
CNT
digest tree. Notice that the estimated
count (shown by the dashed line) changes over time and re-
sults in significant error. An analysis of logs from the testbed
reveals that the existence of heavy packet loss and link asym-
metry adversely affects the tree construction protocol in Sec-
tion IV.
To understand this phenomenon, consider Figure 4 (a) and
(b), where, from time to time, node D selects node A as its
parent over B according to the shortest hop count rule. How-
ever since the link between D and A suffers heavy packet
7
loss, the parent’s soft-state at D soon expires and D switches
back to B as its parent. Thus this branch “flapping” occurs
all the time, and the final aggregate result is unstable. In an-
other case of Figure 4(c), node C always chooses A as its
parent. However, A is hardly able to hear any reports from C
over the asymmetric link A ! C. The branch is stable but
the partial result from C and its subtree are thus lost, which
may lead to significant error if the subtree is large.
Fig. 4. Impact of packet loss on the aggregation tree
Symmetric
Link
Link with
Heavy Packet
Loss
Asymmetric
Link
A
B
C D
A
B
C D
h=0
h=1
h=1
h=2
(c)
A
B
C D
A
B
C D
h=1
h=2
h=0
h=2
h=1
h=2
h=1
h=0
(a) (b)
E
B. Link Quality Profiling and Rejection
So far, we have seen that:
Link loss and asymmetry can be prevalent in wireless
networks.
That time-varying loss and asymmetry can result in os-
cillating digest tree branches, and thereby cause signifi-
cant error in the computed digest.
To avoid this, we propose to selectively “blacklist” links with
poor link quality or asymmetry from being on the tree. That
is, when possible, each node will try to choose a parent with
which it has “good” and symmetric communication. The
challenge in doing this, is of course, to detect these links reli-
ably, and adapt to time-varying conditions. We describe our
approach to doing this, which involves using the digest tree
construction messages to estimate losses to neighbors.
Recall that the digest tree construction message contains
a sequence number. For each of its neighbors B, node A
maintains a FIFO buffer k
1
; k
2
;; k
m
to store the sequence
numbers in the most recently received beacons. Packet loss is
estimated as p
AB
= 1m=(k
m
k
1
). If no message received
from B for 10T
0
seconds, the buffer is released. (i.e., links
with p > 90% are ignored).
Each incoming link is qualified as “good” or “bad” ac-
cording to the following rules: 1) Whenever p
AB
< , link
A! B is marked with “good”. 2) Whenever p
AB
> , link
A ! B is marked with “bad”. The heuristic is necessary
given our observation that there exists fairly high variance in
packet loss over the time. Assessment of link quality based
on a single threshold still leads to frequent parent switching.
Each node now has a list L
IN
of the good incoming links.
To identify asymmetric links, each node periodically broad-
casts L
IN
to its neighbors. Instead of sending out the en-
tire list, each item of L
IN
is piggybacked into the tree con-
struction message, in a round-robin fashion. The overhead
of neighbour list exchange is then amortized over many mes-
sages. By listening if its identifier is mentioned by neighbors,
each node can construct another list L
OUT
of good outgoing
links. To avoid the scenarios in Figure 4, only those neigh-
bors in L
IN
\ L
OUT
are allowed to be parent candidates.
With an upper bound of packet loss, the time-out values can
easily be determined according to Table I to guarantee that
tree is relatively stable.
VI. EXPERIMENTAL EVALUATION
In Figure 3, the solid curve shows that with link profil-
ing and rejection, the computed digest is dramatically more
stable than in an implementation that does not selectively
choose tree links based on observed packet loss. This es-
sentially validates our design, but we now describe our ex-
periments in more detail, more carefully dissect our experi-
mental findings, and quantify the performance difference that
our scheme can bring about.
We implemented our scheme on the “mote” sensor plat-
form [19]. Each node has a 4Mhz Atmel microprocessor
with 4 KB RAM, 128 KB code space and 512KB external
EEPROM. Motes use TinyOS [20] which provides a MAC
layer with a simple CSMA/collision avoidance protocol run-
ning on a 413MHz RFM radio transceiver at 40kbps. In our
experiments, we chose the minimum transmission power set-
ting such that the maximum communication range is approx-
imately 3-4 meters. Nodes are placed along a single line with
inter-node distance of 1 meter. Each node has a degree of 4-
6. Given only a limited number of nodes, our intention is to
stress test our approach with the largest network diameter as
much as possible. A single line formation does not reflect
the full reality of a sensor field, but still captures the accu-
mulated effect of multiple hops with loss and asymmetry on
digest computation.
We implement three digests V
MAX
, V
CNT
and V
SUM
.
V
AV G
can be derived from V
SUM
=V
CNT
. The partial results
for these three can be coded into a 18-byte message (Table
III), which is periodically sent out every T
0
= 6 seconds with
randomization. Note that partial results for V
CNT
and V
SUM
can be separated from V
MAX
computation to further reduce
the individual digest size, but we did not do this for simplic-
ity. As proposed in Section IV, we choose timeout values
8
TABLE III
DIGEST MESSAGE FOR MAX, CNT, SUM, AND AVG
id seqno V
MAX
Src
MAX
Hop
MAX
Seqno
MAX
V
CNT
V
SUM
Parent GoodNeighbour
T
p
= T
c
= 4T
0
. We also choose sequence number buffer
size m = 5, link quality profiling thresholds = 25%,
= 50%. These thresholds are reasonable values to iden-
tify the bad links, given the average packet loss and variance
observed from Figure 2. The contributed value v
i
for each
node is uniformly distributed over the range [0;100]. A node
with the maximum value is intentionally placed on one cor-
ner. Partial results and node state are logged into EEPROM
for post analysis. Each experiment takes around 2 hours. Ex-
periments were repeated until 95% confidence intervals were
achieved.
A. Communication Cost
The digest computation is based on periodic messages,
thus each node consumes constant power transmitting
18=T
0
= 3 byte/sec in our experimement. In addition,
the energy expended for reception at each node is propor-
tional to the node degree. Comparison between our approach
to centralized solution is trivial as described in section IV:
In-network aggregation can achieve an order of magnitude
reduction on communication cost and thus leads to better
energy-efficiency. Note that our choice of a small T
0
= 6
is primarily to reduce the experiment time. Larger value can
be used in practice to further improve energy-efficiency.
B. Robustness to Packet Loss
The primary characteristic to evaluate on our testbed is the
robustness to packet loss and asymmetric links in the real
world. Figure 3 shows that link rejection can reduce the error
in digest computation dramatically. To quantify the perfor-
mance improvement, we define the relative root mean square
errors in digest V as the follows:
1
V
v
u
u
t
T
X
t=1
(V
t
V )=T
where V
t
is the observed value at time t and V is th actual
value.
We then dissect our proposed solution by comparing it
with three other schemes:
1) The digest computation algorithm without link rejec-
tion;
2) Scheme 1 plus rejection of poor incoming links;
3) Scheme 1 plus rejection of poor outgoing (asymmetric)
links;
4) Our proposed scheme: scheme 1 with both incoming
and asymetric link rejections turned on.
Figure 5 shows that the accumulated error over multiple
hops introduced to digest computation increases sigficantly
with larger network size. Without link rejections, the simple
tree construction algorithm leads to error as much as 70% for
V
CNT
in a 1x26 configuration. However, with both rejections
of poor incoming links and asymmetric links, the error can be
reduced to less than 10% for the same network.
In Figure 5, the performance difference between scheme
(2), (3) and (4) implies that both incoming link rejection and
asymmetric link rejection are important to our design. A
thorough analysis of logs shows that with only asymmetric
link rejection (scheme 3), the oscillations depicted in Fig-
ure 4 (a)(b) are still quite common. On the other hand, poor
incoming link rejection (scheme 2) itself is sufficient to con-
struct quite stable trees. However, in some cases, such a tree
includes “stable” asymmetric links where partial results are
constantly lost. Neither of them can achieve acceptable ac-
curacy in digest computation by itself. It is interesting that
scheme 3 outperforms scheme 2 in our experiments. Our ex-
planation is that in scheme 3, that node B is a good outgoing
neighbor of A implies that A can hear from B quite well, at
least for the neighbor list broadcast message. Thus the tree
constructed in scheme (3) is more likely be a “good” aggre-
gation tree compared to those in scheme (2).
Our experiments also show that different digests have dif-
ferent robustness characteristics. Monotonic exemplary di-
gests such as V
MAX
are the most robust digest with hardly no
error all time except some transient errors hen the node with
maximum node crashes. Packet loss and toplogy changes
usually hardly affect the final result given the network is still
connected. V
CNT
and V
SUM
tend to be the most sensitive to
packet loss since their accuracy rely on correctly collect the
partial results from every node in the network. The robust-
ness of V
AV G
computation depends on the characteristics of
the data set. In our experiments, V
AV G
is more robust than
V
CNT
and V
SUM
because the value set is from an uniform
distribution. Even a fraction of samples leads to a good es-
timate for the average. In the next section, we will further
evaluate by simulation the performance of digest computa-
9
Fig. 5. Relative Root Mean Square Error for 1x9, 1x16, 1x26 networks
(Implementation)
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
9 16 26
Relative RMS Error
Network Diameter
simple
poor link rejection
asym link rejction
both
(a) Relative RMS Error for CNT
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
9 16 26
Relative RMS Error
Network Diameter
simple
poor link rejection
asym link rejction
both
(b) Relative RMS Error for SUM
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
9 16 26
Relative RMS Error
Network Diameter
simple
poor link rejection
asym link rejction
both
(c) Relative RMS error for A VG
tion with different distributions of contributed values.
C. Latency
Digest computation relies on piggybacking partial results
on other periodical messages. The latency of reponse to value
changes, node failures or topology changes is another impor-
tant performance metrics. The response time to those scenar-
ios is bounded by the convergence time of computation from
the system initialization. We define the convergence time for
V
CNT
as the time that the moving average of the 10 recent
results appears with less than 10% relative error. For V
MAX
,
we define the convergence time as the time that all nodes
agree on the same V
MAX
: In Figure 6, the convergence time
Fig. 6. Latency for MAX and CNT
0
20
40
60
80
100
120
9 16 26
Convergence Time (second)
Network Diameter
MAX
CNT
for V
CNT
shows the trend approximately proportional to the
network diameter. In addition, the convergence time t
MAX
for V
MAX
is smaller than t
CNT
for V
CNT
. We futher con-
jecture that t
MAX
is approximately half of t
CNT
. Because
from system initialization, V
CNT
computation need t
MAX
time for constructing the aggregation tree and approximately
the same amount of time to propagate all the partial results
back to the root.
VII. SIMULATION RESULTS
To scale up the performance evaluation in previous sec-
tion, we simulated even larger networks in the TinyOS sim-
ulator. We modified the simulator with the following packet
loss model: The packet loss over distance d is defined:
p(d) =
8
>
<
>
:
0:2d=r d r
1:6d=r 1:4 r < d 1:5r
1:0 d > 1:5r
where r is the nominal transmission range. The packet loss
rate slightly drops to 20% at r and then drops sharply to
10
100% at 1:5r. This model is artificial but it reflects our obser-
vation from the testbed experiments. In addition, asymmetric
links are generated by setting r for each node randomly from
range of 2 to 4 meters. The system paramters such as T
0
,T
p
,
, are used with the same values in the testbed experiments
except otherwise noted. Each simulation prolongs approxi-
mately 40 minutes.
A. Scalability
Once again, the communication and computation overhead
at each node is constant over time. The primary metrics to
study scalability is the error that introduced by packet loss
and asymmetric links in large networks. In this set of sim-
ulations, nodes are randomly placed on a m m area, with
approxmiately density of 1 node per square meters. Figure 7
shows the errors in V
AV G
and V
CNT
for the networks with
100-900 nodes. With link rejection, the proposed digest com-
putation protocol scales well with the network size and is ro-
bust to provide accurate results.
Fig. 7. Relative RMS Error forVAV G andVCNT (Simulation)
0
0.2
0.4
0.6
0.8
1
1.2
10X10 15X15 20X20 25X25 30X30
Relative RMS Error
Network Diameter
AVG, w/o link rejection
AVG, with link rejection
CNT, w/o link rejection
CNT, with link rejection
B. Sensitivity to data distribution
Our experiements on the testbed (Figure 5) and simulation
(Figure 7) show that different digests have different levels of
sensitivity to packet loss. In particular, it seems that V
AV G
is signifanctly more robust than V
CNT
and V
SUM
. However,
shown in this section, the robustness of digest computation
also depends on the distribution of the contributed values.
We simulated digest computation with two different distribu-
tion models of the value for each node. The first one is the
uniform model [0;100] that we use in previous experiments.
The second one is a ”skewed” distribution: 10% of the nodes
have a value uniformly from [90;100], the rest nodes have
value of 0 or 1. i.e. a small fraction (10%) of nodes con-
tributes a large fraction (95%) of the sum.
Fig. 8. Relative RMS Error inVAV G for Different Data Sets
0
0.2
0.4
0.6
0.8
1
10 20 30 40 50 60
Relative RMS Error
Network Diameter
uniform distribution, w/o link rejection
uniform distributioin, with link rejection
skewed distributioin, w/o link rejection
skewed distributioin, w link rejection
We simulate V
AV G
computation with different number of
nodes on a linear formation. Figure 8 shows the different
impacts of these two distributions on V
AV G
computation: for
the uniform distribution, the error tends to converge when the
network size increases. From a uniformly distributed data
set, a fraction of samples can provide an average estimate
such that additional sample loss does not introduce more er-
ror. The “skewed” distribution behaves differently. Without
link rejection, the large values from very few nodes tends to
be lost due to high accumulated packet loss. Thus the result
of V
AV G
computation constantly suffers significant error for
different network sizes. However, with link rejection, the di-
gest computation protocol can reduce the error significantly.
VIII. RELATED WORK
The problem of monitoring sensor networks is crucial and
important. Recently, different protocols are proposed to dis-
cover failed nodes[21], [22], compute the coverage and ex-
posure bounds of wireless sensor networks [23], [24], pro-
vide remaining energy supply level [15] or topological map-
ping of the network [25]. These approaches address various
specific aspects of sensor network monitoring and are com-
plementary to the digest aggregation tools proposed in this
paper. In addition, they can fit into our proposed architecture
to provide a coherent monitoring system for wireless sensor
networks.
Computation of aggregates has been discussed in database
research community such as in [6] and others. Madden et al.
recently proposed a generic framework to support aggregate
queries from base-stations in sensor networks[9], [5]. Our
solution eliminates any predefined base-stations or heirachy,
and provides an energy-efficient and robust aggregation with
little extra overhead. In addition, we also addresses the im-
pact of packet loss from empirical studies on a real wireless
11
sensor network testbed, which turns out to be crucial to the
accuracy of aggregate computation. Though this paper is not
intended to address design of generic sensor network appli-
cations, some techniques proposed here can be applied to ef-
ficiently compute global or regional aggregates for applica-
tions.
There are many proposed solutions to deal with packet
loss and asymmetric links in mobile ad-hoc networks. To
name a few, associativity-based routing (ABR) protocol [26]
uses a route stability metric for routing in mobile ad-hoc net-
works. The objective is to select long lived links according
to the associativity of the nodes involved. In signal stabil-
ity based adaptive routing [27], routing is based on both the
signal strength and location stability. The link quality is es-
timated according to the signal strength of received beacons
from its neighbors. In [28], a sub-layer called Sub Routing
Layer between the network and the MAC layer is proposed to
provide a bidirectional abstraction of the unidirectional net-
work to the routing protocols. The proposed link profiling
and rejection techique shares similar spirit but focuses on the
context of lower-power wireless sensor network monitoring,
given its even tighter energy efficiency requirement. Though
mobility is not a primary challenge for sensor networks, our
approach does tolerate certain level of node mobility.
There is another orthogonal class of appraoches to im-
prove scalability with randomized sampling techiques. For
example, in the context of multicast group size estimation
[29] [30] [31], only a small fraction of multicast participants
send out replys to the querying node by suppressing replys
from the others. However, depending on the statistical na-
ture of the data set, these centralized solutions may require
large sample probability to achieve reasonable accuracy. In
addition, they assume that communication cost to dissemi-
nate query/suppression answers are constant, which does not
hold for multi-hop sensor networks where energy-efficiency
is crucial. We are starting to investage the trade-offs to incor-
porate such techniques into digest computation.
IX. CONCLUSIONS AND FUTURE WORK
In this paper, we propose an architecture to monitor wire-
less sensor networks with different level of detail, and focus
on the design of computing network digests. Digests repre-
sent continuously computed summaries of network proper-
ties and can serve to indicate the need for more detailed, but
perhaps energy-intensive, monitoring.
We have implemented digests, and presented our evalua-
tion from a medium-scale testbed of motes. Carefully deal-
ing with lossy and asymmetric links can significantly reduce
the error of digest computation, as we have shown. We pre-
sented a simple scheme that selectively avoids adding lossy
and asymmetric links to the digest tree.
We would like to continue our experiments on a larger
scale testbed and further evaluate our design. Ultimately, we
intend to make a suite of monitoring tools available that will
foster larger scale experimentation in sensor networks.
REFERENCES
[1] Deborah Estrin, Ramesh Govindan, and John Heidemann, “Embed-
ding the Internet,” Communications of the ACM, vol. 43, no. 5, pp.
39–41, May 2000, (special issue guest editors).
[2] Wendi Rabiner Heinzelman, Anantha Chandrakasan, and Hari Bal-
akrishnan, “Energy-efficient communication protocols for wireless
microsensor networks,” in Proceedings of the Hawaii International
Conference on Systems Sciences, Jan. 2000.
[3] P. Varshney and C. Burrus, Distributed detection and data fusion,
New York, Springer, 1997.
[4] I. Gupta, R. van Renesse, and K. Birman, “Scalable fault-tolerant
aggregation in large process groups,” in Proc. Conf. on Dependable
Systems and Networks, 2001.
[5] Samuel Madden, Micheal Franklin, Joseph Hellerstein, and Wei
Hong, “TAG: a tiny aggregation service for ad hoc sensor networks,”
in USENIX Symposium on Operating Systems Design and Implemen-
tation, 2002.
[6] Jim Gray, Surajit Chaudhuri, Adam Bosworth, Andrew Layman,
Don Reichart, Murali Venkatrao, Frank Pellow, and Hamid Pira-
hesh, “Data cube: A relational aggregation operator generalizing
group-by, cross-tab, and sub-totals,” J. Data Mining and Knowledge
Discovery, vol. 1, no. 1, pp. 29–53, 1997.
[7] Danny Raz and Yuval Shavitt, “New models and algorithms for pro-
grammable networks,” in Computer Networks, Feb. 2002, vol. 38(3),
pp. 311–326.
[8] Chalermek Intanagonwiwat, Ramesh Govindan, and Deborah Estrin,
“Directed diffusion: A scalable and robust communication paradigm
for sensor networks,” in Proceedings of the ACM/IEEE Interna-
tional Conference on Mobile Computing and Networking, Boston,
MA, USA, Aug. 2000, pp. 56–67, ACM.
[9] Samuel R. Madden, Robert Szewczyk, Michael J. Franklin, and
David Culler, “Supporting Aggregate Queries Over Ad-Hoc Wire-
less Sensor Networks,” in Workshop on Mobile Computing Systems
and Applications, 2002.
[10] Wei Ye, John Heidemann, and Deborah Estrin, “An energy-efficient
mac protocol for wireless sensor networks,” in Proceedings of the
IEEE Infocom, June 2002.
[11] Ya Xu, John Heidemann, and Deborah Estrin, “Geography-informed
energy conservation for ad hoc routing,” in Proceedings of the
ACM/IEEE International Conference on Mobile Computing and Net-
working, Rome, Italy, July 2001, pp. 70–84, ACM.
[12] Alberto Cerpa and Deborah Estrin, “ASCENT: Adaptive self-
configuring sensor networks topologies,” in Proceedings of the IEEE
Infocom, New York, USA, June 2002, IEEE.
[13] Douglas De Couto, Daniel Aguayo, Benjamin Chambers, and Robert
Morris, “Performance of multihop wireless networks: Shortest path
is not enoughi,” New Jersey, USA, Oct. 2002.
[14] J. Case, M. Fedor, M. L. Schoffstall, and C. Davin, “Simple Network
Management Protocol,” RFC 1908, Internet Request For Comments,
Nov. 1996.
12
[15] Y . Zhao, R. Govindan, and D. Estrin, “Residual energy scans for
monitoring wireless sensor networks,” in Proceedings of the IEEE
Wireless Communications and Networking Conference, Mar. 2002.
[16] Wendi Rabiner Heinzelman, Joanna Kulik, and Hari Balakrishnan,
“Adaptive Protocols for Information Dissemination in Wireless Sen-
sor Networks,” in Proceedings of the ACM/IEEE International Con-
ference on Mobile Computing and Networking, Seattle, WA, USA,
Aug. 1999, pp. 174–185, ACM.
[17] P. Tsuchiya, “The Landmark Hierarchy: A new hierarchy for routing
in very large networks,” in ACM Computer Communication Review,
Aug. 1988, pp. 35–42.
[18] Deepak Ganesan, Bhaskar Krishnamachari, Alec Woo, David Culler,
and Deborah Estrin, “An empirical study of epidemic algorithms in
large scale multihop wireless networks,” in Submitted for reviews,
Mar. 2002.
[19] Mike Horton, David Culler, Kris Pister, Jason Hill, Robert
Szewczyk, and Alec Woo, “MICA, the commercialization of mi-
crosensor motes,” in Sensors Magazine, Apr. 2002, vol. 19, pp. 40–
48.
[20] Jason Hill, Robert Szewczyk, Alec Woo, Seth Hollar, David Culler,
and Kristofer Pister, “System architecture directions for network
sensors,” in Proceedings of the 9th International Conference on
Architectural Support for Programming Languages and Operating
Systems, Cambridge, MA, USA, Nov. 2000, pp. 93–104, ACM.
[21] Stafano Chessa and Paolo Santi, “Fault Diagnosis in Wireless Sensor
Networks,” in ERCIM News, Oct. 2001.
[22] Jessica Staddon, Dirk Balfanz, and Glenn Durfee, “Efficient tracing
of failed nodes in sensor networks,” in The First ACM International
Workshop on Wireless Sensor Networks and Applications, Atlanta,
USA, Sept. 2002, pp. 122–130, ACM.
[23] Seapahn Meguerdichian, Farinaz Koushanfar, Miodrag Potkonjak,
and Mani Srivastava, “Coverage Problems in Wireless Ad-hoc Sen-
sor Networks,” in Proceedings of the IEEE Infocom, 2001.
[24] Seapahn Meguerdichian, Farinaz Koushanfar, Gang Qu, and Mio-
drag Potkonjak, “Exposure In Wireless Ad Hoc Sensor Networks,”
in Proceedings of the ACM/IEEE International Conference on Mo-
bile Computing and Networking. July 2001, pp. 139–150, ACM.
[25] Budhaditya Deb, Sudeept Bhatangar, and Badri Nath, “A topology
discovery algorithm for sensor networks with applications to net-
work management,” in IEEE CAS Workshop on Wireless Communi-
cations and Networking, Pasadena, USA, Sept. 2002, IEEE.
[26] C. Toh, “Associativity-based routing for ad-hoc mobile networks,”
in IEEE Personal Communications Magazine, 1997.
[27] R. Dube, C.D. Rais, K. Wang, and S.K. Tripathi, “Signal stability
based adaptive routing for ad-hoc mobile networks,” in IEEE Per-
sonal Communications Magazine, Feb. 1997.
[28] V . Ramasubramanian, R. Chandra, and D. Mosse, “Providing A
Bidirectional Abstraction for Unidirectional Ad-Hoc Networks,” in
Proceedings of the IEEE Infocom, June 2002.
[29] Jorg Nonnemacher and Ernst W. Biersack, “Optimal multicast feek
backup,” in Proceedings of the IEEE Infocom, San Fransisco, USA,
Mar. 1998, pp. 964–971.
[30] T. Friedman and D. Towsley, “Multicast session memebership size
estimation,” in Proceedings of the IEEE Infocom, New York, USA,
Mar. 1999, pp. 965–972.
[31] Sara Alouf, Eitan Altman, and Philippe Nain, “Optimal on-line esti-
mation of the size of a dynamic mutilcast group,” in Proceedings of
the IEEE Infocom, New York, USA, June 2002.

Abstract (if available)

Linked assets

Computer Science Technical Report Archive

Conceptually similar

PDF

USC Computer Science Technical Reports, no. 745 (2001)

PDF

USC Computer Science Technical Reports, no. 750 (2001)

PDF

USC Computer Science Technical Reports, no. 692 (1999)

PDF

USC Computer Science Technical Reports, no. 732 (2000)

PDF

USC Computer Science Technical Reports, no. 706 (1999)

PDF

USC Computer Science Technical Reports, no. 873 (2005)

PDF

USC Computer Science Technical Reports, no. 723 (2000)

PDF

USC Computer Science Technical Reports, no. 731 (2000)

PDF

USC Computer Science Technical Reports, no. 697 (1999)

PDF

USC Computer Science Technical Reports, no. 841 (2005)

PDF

USC Computer Science Technical Reports, no. 669 (1998)

PDF

USC Computer Science Technical Reports, no. 872 (2005)

PDF

USC Computer Science Technical Reports, no. 704 (1999)

PDF

USC Computer Science Technical Reports, no. 603 (1995)

PDF

USC Computer Science Technical Reports, no. 677 (1998)

PDF

USC Computer Science Technical Reports, no. 631 (1996)

PDF

USC Computer Science Technical Reports, no. 910 (2009)

PDF

USC Computer Science Technical Reports, no. 773 (2002)

PDF

USC Computer Science Technical Reports, no. 771 (2002)

PDF

USC Computer Science Technical Reports, no. 724 (2000)

Description

Jerry Zhao, Ramesh Govindan, Deborah Estrin. "Computing aggregates for monitoring wireless sensor networks." Computer Science Technical Reports (Los Angeles, California, USA: University of Southern California. Department of Computer Science) no. 774 (2002).

Asset Metadata

Creator Estrin, Deborah (author), Govindan, Ramesh (author), Zhao, Jerry (author)

Core Title USC Computer Science Technical Reports, no. 774 (2002)

Alternative Title Computing aggregates for monitoring wireless sensor networks (title)

Publisher Department of Computer Science,USC Viterbi School of Engineering, University of Southern California, 3650 McClintock Avenue, Los Angeles, California, 90089, USA (publisher)

Tag OAI-PMH Harvest

Format 12 pages (extent), technical reports (aat)

Language English

Unique identifier UC16269724

Identifier 02-774 Computing Aggregates for Monitoring Wireless Sensor Networks (filename)

Legacy Identifier usc-cstr-02-774

Format 12 pages (extent),technical reports (aat)

Rights Department of Computer Science (University of Southern California) and the author(s).

Internet Media Type application/pdf

Source 20180426-rozan-cstechreports-shoaf (batch), Computer Science Technical Report Archive (collection), University of Southern California. Department of Computer Science. Technical Reports (series)

Access Conditions The author(s) retain rights to their work according to U.S. copyright law. Electronic access is being provided by the USC Libraries, but does not grant the reader permission to use the work if the desired use is covered by copyright. It is the author, as rights holder, who must provide use permission if such use is covered by copyright.

Repository Name USC Viterbi School of Engineering Department of Computer Science

Repository Location Department of Computer Science. USC Viterbi School of Engineering. Los Angeles\, CA\, 90089

Repository Email csdept@usc.edu

Inherited Values

Title Computer Science Technical Report Archive

Coverage Temporal 1991/2017

Repository Email csdept@usc.edu

Repository Name USC Viterbi School of Engineering Department of Computer Science

Repository Location Department of Computer Science. USC Viterbi School of Engineering. Los Angeles\, CA\, 90089

Publisher Department of Computer Science,USC Viterbi School of Engineering, University of Southern California, 3650 McClintock Avenue, Los Angeles, California, 90089, USA (publisher)