Brakes - A portable thread serialization mechanism for Java

What is BRAKES ?

Brakes currently consists of two parts

A ByteCode transformer (based on version 1.4 of the ByteCode Engineering Library) which instruments Java classfiles so they are able to capture their current internal state at any given time
A small framework which uses the ability of the 'patched' classes to allow Java threads to pause and resume whenever desirable.

Brakes is licensed under the Academic Free License (AFL)

Brakes is the main source of inspiration for the JavaFlow component in the Apacha Jakarta Project.

Documentation

Conference Paper: "Portable support for transparent thread migration in Java" In Proceedings of ASA/MA2000 : as Gzipped Postscript or PDF
Workshop Paper : "On the use of threads in mobile object systems" In Workshops of ECOOP 2000 : as Gzipped Postscript or PDF

Recent Changes

0.1 - 0.2: A change in the construction of Computations + small bugfixes
0.2 - 0.3: Change of license to the Academic Free License

Since 2001, the Brakes system is discontinued as research has taken more high-level directions. Therefor, the binary distribution stays mostly a 'proof-of-concept' system, without any optimizations for realworld use.

The standard version, which was the prototype of the presentation at ASA/MA (see higher), is what is called brakes-serial, or computation-serial in the binary distribution. The other version, brakes-parallel, or computation in the binary distribution, is an unoptimized addon of the first prototype, and has of course a much higher overhead than documented in the papers. So be sure you know what you are referencing.

There is a new subbranch of the Brakes system, Distributed Brakes. See Below.

Bugs

At the moment, we have a small buglist. But check out these pages regulary, as entries will move from the bugs section to the recent changes.

Downloading

brakes-0.1.tar.gz (obsolete)
brakes-0.2.tar.gz + included README (obsolete)
brakes-0.3.tar.gz + included README

The Brakes-0.3 source is included in the package.

Distributed Brakes

Building on Brakes, we have developed a system, called Distributed Brakes for serializing the execution state of distributed applications, that are programmed by a conventional Object Request Broker such as Java RMI. An important benefit of this mechanism is its portability. It can transparently be integrated into any legacy Java application. Further more, it does require no modifications to the Java Virtual Machine (JVM) or to the underlying Object Request Broker. Distributed Brakes can serve many purposes such as migrating distributed execution state over the network or storing it on disk.

In particular, we have implemented of a prototype for repartitioning distributed Java applications at run-time. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Distributed Brakes enables us then to apply these methods at any point in an on-going distributed computation.