A capriccio is a spritely, improvisational
musical dance involving multiple voices.
The Capriccio project aims to create tools to ease the burden on
programmers who develop high-performance systems software. Our
primary goal is to allow high performance without high complexity.
Our target applications include clustered Internet servers, databases
and OS kernel components. These applications must perform well under
a wide range of operating conditions. In particular, they must handle
large variations in load gracefully and make maximal use of the
available resources. Conventional mechanisms for realizing these goals
require very complicated programming logic. This introduces bugs and
makes the software difficult to write and maintain.
The key insight behind Capriccio is that many of the tricks that
programmers use to achieve high performance can be automated, either
statically or by changing the runtime system. Hence, we are working
to achieve the following goals:
- Flexible, application-specific user-level threading.
High-performance system software is typified by a large number of
concurrent actions. Managing this concurrency is often one of the
most difficult and error-prone aspects of high-performance systems
programming. Many researchers have argued that event-based
programming is the best way to handle high concurrency, as it exposes
both scheduling and per-task resource management direclty to the
programmer, and allows more taylored programs.
We believe that events are fundamentally more difficult to use than
threads, and can cause more errors in the resulting programs. Hence,
we have developed a threads package with all of the performance
advantgages of events. This threads package forms the core of the
Capriccio runtime environment.
- Powerful static analysis framework.
- Capriccio leverages the
powerful static analysis framework provided by CIL and
to deduce important properties of a program at compile time. This
information can be used statically to catch bugs and reduce programmer
errors. It can also be fed into the runtime system to allow more
Capriccio is a project of the University of California at Berkeley's
Computer Science department. The following are the active
contributors to Capriccio:
You can find a (somewhat old) snapshot of the Capriccio threads
package on our downloads page.