CS 252 Project Proposal

                   March 21, 2003

Aggregation Query Under Uncertainty in Sensor Networks
------------------------------------------------------


Yozo   Hida     (yozo@cs.berkeley.edu)
Paul   Huang    (pbhuang@bmrc.berkeley.edu)
Rajesh Nishtala (rajeshn@cs.berkeley.edu)

Project Webpage:  
  http://www.cs.berkeley.edu/~yozo/cs252/project.html


Often the user of a sensor network do not want the raw
data, but rather some form of summary of the sensor values, 
such as MIN, MAX, AVG, and MEDIAN.  Since sending messages
in sensor network is expensive, it makes sense to do some
computation in the network to reduce the number of messages
transmitted.  This was investigated in [1, 2], where the authors
considers the basic algorithm and ways to improve its 
reliability, at the expense of either message count or data
accuracy.

We plan to extend the aggregate query algorithms described in 
[1, 2] to handle two scenarios:

  (A) Malicious or malfunctioning nodes.  In some operations, 
      one malicious node can significantly affect the data.
      For example, one sensor stuck at max temperature reading
      will cause the MAX operation to essentially fail.  It will
      also disproportionately affect the average.

      One possible solution to this problem is for a set of local
      sensors to somehow detect a faulty node by looking at 
      aberrant reading compared to the nearby nodes.  Then the
      surrounding nodes can tag the node as faulty, and ignore
      it.  

  (B) User may want to just know the average to within some 
      tolerance with some confidence.  For example, the user
      may request an average to within 25% with 90% confidence
      (probably expressed though some standard deviation measure).
      The sensor may be able to use this information to make 
      some optimizations to reduce the number of messages.

      For example, for MAX nodes, some sort of sampling may
      do the job: with more sampling, we can be more confident
      that the reported MAX value is close to the true maximum.
      Similarly, the AVG operator can be modified to reduced the
      number of messages sent.  As in scenario (A), this assumes
      some spacial continuity of the sensor values.


The modified TinyOS simulator, Nido, has support for faulty nodes, 
bit level errors, and packet level errors.  We will use Nido to 
simulate various errors and test new algorithms that perform better 
under errors than the traditional aggregation algorithms.  With
the simulation, we will also attempt to answer interesting questions
such as

  - how much extra messages does it require to detect faulty nodes?
  - how many faulty nodes can a sensor network tolerate ?
  - how much sensor value continuity do we need to assume to 
    effectively compute MAX / AVG to within acceptable tolerance?
  - how much messages can we save by increasing the tolerance of
    the final answer ?
  - how are these scenario affected by reliability issues (such as
    lost transmissions).
  - does algorithms described in [1, 2] to increase reliability 
    still applicable ?


References
----------
[1] Samuel R. Madden, Robert Szewczyk, Michael J. Franklin and 
    David Culler.  Supporting Aggregate Queries Over Ad-Hoc Wireless 
    Sensor Networks.  Workshop on Mobile Computing and Systems 
    Applications, 2002 (to appear).  Available at 
    http://www.cs.berkeley.edu/~franklin/Papers/wmcsa02.pdf 

[2] Sam Madden, Michael J. Franklin, Joseph M. Hellerstein, Wei Hong
    TAG: A Tiny Aggregation Service for ad hoc Sensor Networks. 
    OSDI, December, 2002. Available at
    http://www.cs.berkeley.edu/~madden/madden_tag.pdf