Multicore architectures are an increasingly important technique used to achieve increased performance in modern CPUs. While increasing the number of cores in a chip leads to easy performance benefits when running multiple applications in parallel, writing multithreaded programs has proven to be difficult even for experienced programmers. This difficulty stems, in part, from the loss of fundamental abstractions available in single threaded programs. These lost abstractions include sequential consistency, atomicity, and determinism. Research has gone into recovering these abstractions in multithreaded environments, but all are difficult to recover in the presence of data races. Therefore, eliminating data races has become a key issue in writing multithreaded code.

The desire to eliminate data races has led to the development of tools to detect and/or stop data races in multithreaded programs. Unfortunately, these race detectors must monitor all access to shared memory to detect data races. Shared memory is a huge portion of memory, and in many modern programming languages, such as Java and C++, it comprises all of heap memory. Likewise, checks must be added to all program locations that access shared memory. The huge range of memory and the large number of program points to be monitored leads to large overheads in race detectors.

This thesis aims to increase the speed of dynamic race detectors by restricting the set of memory and program locations they monitor. In general, we aim to classify various objects or locations as safe, meaning that race detection checks can be omitted on these locations/objects without reducing precision. We classify memory/program locations as safe by looking at: overlapping race checks, thread locality, or locality to a thread safe object.