Addressing Issues

The Bayanihan framework allows programmers to experiment with different ways of addressing the research issues in Sect.2 by programming at different levels, and implementing or modifying the appropriate objects. Specifically, programmers may address the issues as follows:

1.

Programming Interface. As we have seen, programmers can easily implement a wide variety of applications by simply composing existing components. Furthermore, by implementing their own components and following good design rules, they can create their own reusable libraries and frameworks for future applications.

2.

Adaptive Parallelism. Different forms of adaptive parallelism can be implemented by designing work managers and work engines. Although the framework may appear at first glance to be suited only for a master-worker style applications, it is actually quite flexible.

For example, one can conceivably implement PVM-like functionality [15] by writing a work engine that functions like a PVM daemon, and writing PVM-like programs or tasks as work data objects. The work data objects would depend on the work engine to provide message-passing and task-spawning capabilities. The work engine may implement message-passing directly (if it has no network restrictions), or it can forward the responsibility to the manager (if restricted applets are used). The manager can then route messages to the appropriate work engines and work data on other machines.

Of course, PVM is a bad example since it is not adaptive. However, we use it here as an extreme case - i.e., if you can implement PVM, then implementing other programming models (e.g., Linda, Cilk) is at least as easy, since PVM (and message-passing in general) can implement these.

3.

Fault-Tolerance. Fault-tolerance can be implemented through the managers and the work pools. For example, a master-worker style manager may choose to make sure that a single work data object is done by at least three different engines before it marks it as done in the work pool. Alternatively, this functionality may be built into the work pool.

4.

Computational Security. Computational security can generally be addressed by the manager or its advocate on the server side, and by the engine or the data on the client side. The manager would give the client keys as it gives out work data, and check signatures and checksums as it receives results. The signature and checksum generating code can be contained in the work engine or the work data.

Information can be encrypted between the engine and the advocate. This can prevent sabotage and spying attacks from external sources (i.e., non-volunteers). For certain applications, the process() method itself may also implement a true encrypted computation.

Since work data objects are polymorphic, we can also implement dynamic obfuscation by varying the the process() method between different instances of the work data object. However, currently this will probably not be efficient since it would involve downloading an entire class file for each work data object to be processed. If Java allowed partial downloading of code (e.g., a single method), then this may be feasible.

5.

Scalability and Congestion. Workers (and clients in general) may be allowed to communicate with each other by implementing the chassis as an application or a signed applet. This allows us not to be restricted to star topologies.

Volunteer servers are more difficult to implement. Conceivably, however, it is possible to treat a server's program object as an engine, and connect it to a manager on another server. In this way, we can get hierarchical systems where servers can be clients of higher-level servers. This idea remains to be tried, but seems plausible and promising.

6.

User Interface The data GUI objects allow programmers to provide arbitrary GUI functionality to their data objects to display application-specific data in application-specific ways. At the same time, by using polymorphic GUI objects, the same application can be viewed differently as desired. For example, different watch GUIs may display the result data in different formats.

Watcher clients can allow not only administrators, but users as well, to view results and statistics of the computation. By adding in the appropriate methods, these clients, or possibly separate wisher clients, may also be used to submit requests to the server.