This project consists of techniques and tools for developing fast, correct distributed applications. Two aspects are novel. First, application modules developed with these techniques are statically analyzed for potential conflicts when executed in parallel. Modules that may conflict are serialized to avoid errors. Second, applications are transparently monitored at run-time to show where conservative serialization has unduly slowed the application.
The traditional approach to building concurrent systems is to write the serial version of a module and then consider how concurrent executions might cause errors. Each potential problem must be synchronized appropriately before the application may be executed safely on concurrent requests. This project analyzes code to conservatively preclude dangerous interactions and run it safely in a concurrent environment. The resulting safe application can be made faster using the same techniques that developers use today to ensure safety. For example, locks can be employed to make two segments of code safe for concurrent execution. Although static analysis allows developers to learn where modules may conflict, the second piece of this project, transparent monitoring of concurrent applications, helps developers focus their attention on areas of contention that occur in practice.
This project's techniques will allow large, concurrent applications to be developed without the bugs normally introduced by parallel computation. As more of the software we use runs on central sites, multiplexed for thousands of users, these concerns are growing. Our techniques will be disseminated as papers at systems and languages conferences, and as software artifacts that demonstrate their utility.
