Cooperative Data Sharing System (CDS)

Introduction

The Cooperative Data Sharing system (CDS) is a portable parallel communication library with a very simple logical model (i.e. syntax and semantics) and very efficient physical model (i.e. set of implementation approaches). The logical model consists of moving memory regions (i.e. byte sequences) between local program ("heap") space and some globally-accessible queues called cells. The physical model allows these operations to be implemented with a minimum of copying or overhead using virtually-shared dynamic memory regions. (No special MMU support is required.) As a result, shared-memory, message-passing, and hybrid communication paradigms are possible while still offering portability, efficiency, and user control over the placement and movement of data. The entire library of 51 functions also supports

many-to-many and multicast operations
dynamic non-blocking process creation,
one-sided and demand-driven communication (i.e. "get" and "put"),
asynchronous prefetch and data forwarding,
communication-driven execution (i.e. handlers), and
support for data translation for heterogeneous environments.

In spite of its simplicity, programs (using any or all of the primitives) are efficient in shared-memory, message-passing, and cluster environments, because:

As in shared memory models

Copying is not necessary for communication
Reading processes may share access to data (with copy-on-write to prevent race conditions)
Consuming processes can retrieve data from producing processes

As in message-passing models

Producing processes can forward data to consuming processes to compensate for latency in high-latency environments
Handlers can be installed to be invoked on the presence or absence of communicated data
Communicated data can be queued while awaiting processing

CDS can be considered as a means of programming parallel computers by describing how the data should be shared among the processors (i.e. communication policy), rather than explicitly describing how the data should be communicated among the processors (i.e. mechanism). This can yield more portable and correct programs, since the mechanics of communication can be handled automatically and can be performed using the most efficient mechanisms available for a particular architecture.

[Index] On to Basic Communication