[Contents] [Top] [Next] [Previous]
1. Introduction
UC++ is a parallel version of C++, being developed by the Department of Computer Science, University College London (UCL) and the London Parallel Applications Centre (LPAC). This document describes UC++ V1.4, an implementation of UC++ intended primarily for computer architectures comprising multiple processors with separate memories.
1.1 UC++ Background
An object-oriented approach to parallelism has been used as the basis of UC++, as it is believed to provide a natural model of parallelism: objects encapsulate processes and member function calls encapsulate inter-process communication. To this end, UC++ introduces an active object semantic model to C++, combining parallelism with C++ objects, while making the minimum of syntactic extensions to C++.
An active object differs from a passive object (as found in standard C++) in that it additionally encapsulates a process, as well as state and operations. The process allows an active object to execute its member functions in parallel with the activity of the rest of the program. A parallel UC++ program, therefore, consists of a framework of active objects, each capable of executing their member functions in parallel with those of other active objects (see Figure 1
).
In a typical UC++ program only a small number of objects will be active, providing the parallel structure of the program. The majority of objects will be standard passive objects, existing as members of active objects or in data structures managed by active objects. From this it can be seen that UC++ supports coarse to medium scale parallelism.
Communication between active objects is via the use of member function calls. UC++ supports both synchronous and asynchronous member function call between active objects. A synchronous call behaves in the same way as a standard C++ member function call, in that the caller is suspended until the called member function terminates. With an asynchronous call, the caller does not wait for the result of a function call to be returned and may continue processing. Asynchronous member function calls provide the mechanism for initiating parallelism in a UC++ program.
1.2 Aims and Goals
The broad aims of UC++ can be summarised as follows:
- Define a standard for a parallel version of C++.
- Maintain as much compatibility with C++ as possible.
- Minimise the changes to the syntax of C++, to avoid unnecessary differences from C++.
- Provide a language that will be suitable for programming a wide range of parallel architectures.
- Provide a language definition suitable for portable implementations of the UC++ compiler or translator to be constructed.
During the design of UC++ the aim of maintaining as much compatibility with C++ as possible has been a central issue. In particular, it was believed to be important to avoid creating a variant of C++ that had major syntactic differences and would require large amounts of existing C++ code to be re-written. The object-oriented approach to parallelism is particularly significant in this regard, as a well written object based C++ program is likely to maintain much of its structure when parallelised.
The version of UC++ described in the following sections provides a parallel version of C++ achieved by making a minimal number of extensions to C++, consistent with the aims and goals.
UC++ - 02 MAY 95
[Contents] [Top] [Next] [Previous]
Generated with CERN WebMaker