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