Bayanihan: Building Volunteer Computing Systems Using Java

Luis F. G. Sarmenta
MIT Laboratory for Computer Science, Cambridge, MA 02139, USA
lfgs@cag.lcs.mit.edu, http://www.cag.lcs.mit.edu/bayanihan/
Presented at the
EuroTools Workshop on Tools for High Performance Metacomputing,
EuroPar'98, Southampton, UK, Sept. 3, 1998.
(Slides, journal paper)

The word bayanihan (pronounced ``buy-uh-nee-hun'') means a community spirit of unity and cooperation which makes seemingly impossible tasks possible through the concerted efforts of many people working together on a common goal. Project Bayanihan seeks to bring the bayanihan spirit to the realm of global computing by developing the idea of volunteer computing, a form of metacomputing that enables people to build very large parallel computing networks very quickly by using ubiquitous and easy-to-use technologies such as web browsers and Java. While the idea of volunteer computing offers many exciting new prospects in global supercomputing and collaboration, its implementation involves addressing many challenging issues. To this end, we have developed a flexible object-oriented framework that allows researchers to develop generic ways of addressing these issues while at the same time making it easy for programmers to use volunteer computing for a variety of specific applications.

The Bayanihan framework provides programmers with a set of basic components and an infrastructure for composing, interconnecting, and extending them. It employs distributed object technology to make programming easier by allowing programmers to concentrate on object-oriented design instead of low-level communication details. The framework components are divided into generic objects, which provide basic functionality for a family of applications, and application-specific objects, which implement specific functionality for target applications within that family. By reusing ready-made generic components and subclassing application-specific ones, programmers can easily create a wide variety of applications using a particular programming model. At the same time, by subclassing generic components, researchers can change generic functionality transparently, and even create entirely new programming models.

Using this framework, we have implemented a number of applications, as well as initiated explorations into various research issues. Our current results include:

• Accessibility. To volunteer, users need only a web browser that can run version 1.0 Java applets. No other software is required, and volunteers can join simply by clicking a link on a web page. For more complex applications, volunteers can also use less restricted command-line Java applications.
• Programming Interface and Applications. We have developed a set of generic components that support a master-worker style programming model, and have used it to implement a number of applications including factoring, distributed web-crawling, fractal rendering (i.e., Mandelbrot set), and RC5 decryption. We have also built a sub-framework for implementing parallel genetic algorithm applications under this programming model, and have applied it to problems such as multivariable function optimization.
• User Interface Design. The framework's modular design gives programmers great flexibility in designing user interfaces. For example, programmers can create application-specific GUI objects to view the same object in different ways, as well as generic GUI objects to view different objects in the same way. We have also developed support for watcher applets that allow users to view results and control computation interactively using web browsers.
• Adaptive Parallelism. We use a technique called eager scheduling, wherein fast workers which run out of new work to do are allowed to bypass slow or crashed workers and take over their work load when necessary. This allows the computation to take full advantage of available computational power, and provides resiliency in the face of volunteers leaving or crashing at anytime.
• Fault and Sabotage Tolerance. To protect against both unintentional faults and malicious sabotage, we have implemented transparent support for traditional replication and voting techniques, as well as a much more efficient technique we call spot-checking, wherein the server randomly serves workers jobs with known results, and blacklists those that give wrong results.
• Performance and Scalability. Our tests show that with just-in-time (JIT) compilation, sequential Java performance is comparable to that of native C code for highly repetitive computational code. Parallel tests with up to 16 workers produced good speedups (i.e., about 90% of the ideal) for coarse-grain computations. For large-scale systems and systems with slow network links, we support the use of distributed volunteer servers to reduce congestion by moving load away from the central server.

These results give a very encouraging outlook on the feasibility and practicality of volunteer computing. Ongoing and future research includes writing more applications, implementing other programming models such as Linda, Cilk, and PVM, and further studying issues such as fault-tolerance and scalability.

Project Bayanihan is similar to a growing number of Java-based metacomputing projects. Most of these, including early ones such as ATLAS, ParaWeb, and JPVM, and newer ones such as IceT, Ninflet, and Java//, use Java applications that require some technical expertise and setup effort from users. Projects like Bayanihan that greatly improve accessibility by supporting browser-based applets seem to be fewer but are also increasing in number. These include simple systems such as DAMPP, and more complex ones such as Charlotte and Javelin. Bayanihan is unique in that it is intentionally designed to provide an easy object-oriented way to change generic functionality, and thus makes it easier to experiment with approaches to various research issues.

Note: A full version of this paper will appear in a Future Generation Computer Systems Special Issue on Metacomputing to be published this year. Related works cited here are either published or cited in the ACM 1997 Workshop on Java for Science and Engineering Computation and the ACM 1998 Workshop on Java for High-Performance Computing.