Cid: A parallel, “shared-memory” C for distributed-memory machines

Abstract

Cid is a parallel, “shared-memory” superset of C for distributed-memory machines. A major objective is to keep the entry cost low. For users-the language should be easily comprehensible to a C programmer. For implementors-it should run on standard hardware (including workstation farms); it should not require major new compilation techniques (which may not even be widely applicable); and it should be compatible with existing code, run-time systems and tools. Cid is implemented with a simple pre-processor and a library, uses available C compilers and packet-transport primitives, and links with existing libraries.

Cid extends C with MIMD threads and global objects and a common “join-variable” mechanism for dealing with asynchronous actions. The number of threads is arbitrary and may vary dynamically. Any C object can be registered as a global object; the resulting “global pointer” may be used to access the object from any PE (processing element) in a locked, coherent, cached manner. Combining locking with cacheing reduces communication traffic. Being entirely in software, there is the opportunity to vary coherence protocols to suit the application. Distributed data structures may built by linking across PEs with global pointers, or by using Cid's distributed array primitives.

The programmer does no explicit message-passing, but Cid exposes some abstractions of the distributed memory machine. PEs have separate address spaces; threads may be forked to different PEs, but a thread does not span PE boundaries. Threads access remote data only via thread arguments and results, and global objects. Finally, several Cid operations are made explicitly asynchronous, in recognition of the underlying communication and synchronization costs.

In this paper, we describe the language, our first, multi-threaded implementation, some preliminary results, and compare with related systems.