Multiprocessors should support simple memory consistency models

Abstract

author argues that multiprocessors should support sequential consistency because—with speculative execution—relaxed models do not provide sufficient additional performance to justify exposing their complexity to the authors of low-level software. n the future, many computers will contain multiple processors, in part because the marginal cost of adding a few additional processors is so low that only minimal performance gain is needed to make the additional processors cost-effective. 1 Intel, for example, now makes cards containing four Pentium Pro processors that can easily be incorporated into a system. Multiple-processor cards like Intel’s will help multiprocessing spread from servers to the desktop. But how will these multiprocessors be programmed? The evolution of the programming model already under way is likely to continue. • Multiprocessors will continue to be used for multitask programming, which lets developers optimize conventional, single-threaded programs for multiprocessing. • Critical parts of processor-intensive applications will continue to be parallelized for multiprocessing—to use multiple threads that share data through shared memory. • Someday, we may be able to build compilers that can effectively parallelize programs or we may be able to provide tools or abstractions that allow developers to program in parallel. But what hardware do we need to support shared memory threads? The hardware should provide a well-defined interface for shared memory and it should provide a high-performance implementation of the interface. UNIPROCESSOR MEMORY Defining a shared memory multiprocessor’s interface to memory is easier if we first consider how memory is defined in a uniprocessor. A uniprocessor executes instructions and memory operations in a dynamic execution order called program order. Each read must return the value of the last write to the same address. If the uniprocessor is capable of multitasking, two options exist. If a program executes as a single thread without sharing memory, then the programmer’s memory interface is the same as for a uniprocessor without multitasking. The situation is more complex, on the other hand, if a program has multiple threads sharing memory (or th