A uniform object model for parallel programming

Abstract

This position statement presents a uniform object model of parallel programming that enables use of multiple programming styles, binding parallelism late, and porting programs among a wide variety of architectures. It then argues for concurrent operations on objects, as opposed to mutually exclusive operations on objects, based on orthogonality between encapsulation and concurrency. The final section argues for its relatively novel insistence on uniform control, based on the flexibility it provides the programmer. The Matroshka ModelA single parallel application may have several subproblems, each suited to a different programming style. Current imperative programming languages tend to support only one of three programming styles based on loosely coupled messages, remote procedure calls, or shared memory. Given a task with subproblems appropriate to different styles, a programmer must choose inappropriate styles for some subproblems, which implies awkward, error-prone code, or attempt to mix programming systems, which represents a substantial interface problem. A few programming languages support multiple styles, but do so with separate mechanisms. This separation increases the complexity of the language and forces the programmer to manage the boundary between mechanisms.Current approaches to parallel computation tend to provide separate facilities for parallel programming on top of a base sequential model. These facilities are typically a distinct notion of process, monitor constructs, messages, etc. This dichotomy between sequential and parallel aspects of programming forces programmers to bind the granularity of parallelism at program construction time. For instance, only specially defined program objects may execute concurrently with others. ttowever, the best binding is often not known until after performance experiments performed on a working program. Altering the program for a different binding of parallelism entails a substantial amount of work and limits the effectiveness of programmers'in exploiting multiprocessor hardware. This paper presents Matroshka (.btnTp~tuKa) I a model of parallel programming that enables programmers to use several styles of programming within the same simple framework and enables programmers to bind the granularity of parallelism late in program development. A consequence of the late binding is that programs may be effectively ported among a wide range of multiprocessor architectures. The model is a synthesis of a few concepts and is minimal in that the loss of a single concept severely degrades its expressive power. See [2] for a more complete description. The model may serve as a base for a wide variety of possible programming languages.