Project Proposal for CS252, Fall 2004
Alvise Bonivento
Distributed Computing on Embedded Networks
The goal of this project is to investigate a design methodology that aims at the development of a general purpose distributed computing system for embedded networks using concepts of classical computer architecture.
Recently I developed a model of computation that, starting from the description of a sensor networks application, generates a set of constraints for sensing and communications that the network has to observe to satisfy application requirements. These constraints are the input to a protocol synthesis engine that I’m developing. The protocol synthesis engine works as follows:
1) I have a set of constraints on latency, sensing, loss rate
2) I have a set of tunable protocols whose operative parameters are determined solving an optimization problem to minimize power consumption
3) I generate the optimal (among my library) solution and the relative code to be downloaded into the nodes.
Consequently,
my automated design flow is so far able to take a program described in terms of
virtual controllers, sensor,s and actuators, communicating with queries and
commands, and generate a solution that respects all the requirements with some
degree of optimality.
Nevertheless the final solution is not very efficient. This is because sensors
report their data to the data collector that does all the computation. This
solution, although applicable to many simple problems, does not take into
account the inherent distributed computing capability of an embedded network.
These poor resource utilization may lead to three types of overhead:
1) Extra hardware, but if nodes are cheap this may not be a huge deal
2) Network could work faster, but again my centralized solution already ensures
deadlines
3)Power waste because I end up sending many more messages ... and this is a big
deal
Furthermore, there is quite a big body of literature on data aggregation and
distributed computing that has to be taken into account for a useful automation
system.
So may idea is to find a way to refine my design automation system using the
concepts that we saw in class and organizing my embedded networks in multiple
general purpose functional units ... reminding the midterm problem
Ideally:
1) I write the application with my instruction set that consists of queries and
commands and virtual processes
2) I generate a valid solution with centralized computation
3) I look at the different requests that are in the queries and I compare them
with a library of distributed algorithms (i.e. calculating average value over
many sensors) and I modify my solution in a decentralized way, whenever it is
useful. At this point I have a controller and many sensing areas that are my
functional units.
4) Now I can introduce some "Tomasuloish" capabilities. For example
if two successive queries have data dependencies, there is no need to route the
information from one sensing area back to the controller and then to another
sensing area that was waiting for those data ... I might as well route directly
between the two sensing area. This, in computer systems is usually accomplished
using a broadcast medium like a bus .... here we have a wireless channel which
is broadcast by nature .... but unreliable.
5) Using this perspective, if I have more than one controller running
applications on a network it would look like a multithreading.
I'm planning to use a simple example (a network for machine diagnostic) to
evaluate this approach.
Alvise