Multi-threaded programming is both difficult and error-prone: It is easy to introduce memory and synchronization errors that produce data race and deadlock conditions. When these errors occur, they are typically hard to locate. The most common memory and synchronization errors are data race and deadlock. Data race occurs when two threads access the same memory location with no ordering constraints enforced between the accesses, where at least one of these accesses is a "write." A deadlock is a situation in which two or more competing actions are waiting for the other to finish, so that neither ever does. Both situations are destructive and are common when building multi-threaded programs.

Multi-Thread Run-time Analysis Tool for Java™ is an accurate and efficient run-time analysis tool for finding data races and deadlock conditions in multi-threaded code. This tool instruments applications to collect run-time information for detection of data race or deadlock conditions. Code is instrumented dynamically at run time by using byte code rewriting techniques. Execution of the instrumented code generates events that are analyzed "on the fly" using sophisticated data race and deadlock detection algorithms. The output from the detection algorithms is both precise and accurate. In experiments with both small and large example applications, it has been found that the tool puts out few spurious race and deadlock conditions.

The tool is easy to use and provides both a command line interface and a GUI front-end in Eclipse. The package includes binaries for instrument one's applications; documentation; and example logs and results.

How does it work?

In order to access the run-time information of multi-threaded program without Java code modifications, byte code rewriting techniques are used. The tool, with the help of the ASM byte code rewriting toolkit, instruments certain points of interest in the user's program during class loading by the Java virtual machine. When the program is executed, a stream of events is generated from the various instrumentation points; this information is propagated to the analysis engine (running in another process) through sockets.

In the analysis engine, sophisticated algorithms are used for data race detection and deadlock detection for multi-threaded programs. The data race detection algorithm is a hybrid version of the two well-known race detection algorithms called lockset and happens-before. This hybrid approach makes the tool more efficient and precise (see "Hybrid Dynamic Data Race Detection"). The "weaker-than" relation (see "Efficient and Precise Datarace Detection for Multi-threaded Object-Oriented Programs") and the "Eraser" state machine (see "Eraser: A Dynamic Data Race Detector for Multi-threaded Programs") are used to filter program events in order to improve the performance of this tool.

The deadlock detection algorithm is based on lock graphs. When the user's program is running, the information of lock and synchronization is recorded and a lock graph is created. When the program exits, the deadlock detector checks for cycles in the lock graph. After all non-deadlocked cycles (false positives) are removed, the rest are reported to the user as potential deadlocks.