Component-based programming, originally targeted at the construction of sequential programs , is based on functional composition making use of various flavours of procedure calls. Whereas the idea of gluing together existing components significantly improves the software development process, the existing compostion mechanism is obviously not suited to the construction of parallel (and distributed) applications .
Consequently, the notion of software composition has to be transferred to the field of parallel applications. As outlined in , components on different abstraction levels can be identified here. Such components range from low-level idioms, like futures and remote procedure calls, via design patterns, like manager/worker, proxy, and active objects, to architectural styles like pipes and filters, blackboards, shared objects and datastructures, and event-based models. Obviously, components of different abstraction levels require different composition mechanisms, whereas one kind of components can help gluing together abstractions of other layers. For example, dynamic software composition can be achieved by structuring parallel applications into active objects that are composed via shared data structures and Linda-like, generative communication .
One example of a collection of reusable abstractions for concurrently operating entities is the ACE toolkit . It integrates lower-level entities like futures and singletons with design patterns like active objects, and even with architectural styles like event dispatching mechanisms and message queues. Because ACE is targeted at distributed object computing, it lacks suitable abstractions for parallel programming. Nevertheless, ACE is a valuable example how to build component toolkits.
The idea of identifying coordination patterns for parallel applications has already been proposed in previous work . Here, the expression of parallel program structure is supposed to rely on the integration of reusable components. Nevertheless, the formulation of a thoroughly defined set of components is still subject to ongoing work.
Finally, the work on class libraries containing parallel algorithms should be mentioned . Whereas such pre-implemented parallel algorithms allow application construction on a very high level, they typically lack mechanisms for composing multiple instances of these algorithms into applications. Furthermore, these parallel algorithm libraries are implemented directly on top of communication primitives (like message passing) and are hence as sensible to the pecularities of metacomputers as manually implemented parallel applications. In the following, we suggest the construction of component toolkits in order to provide programming platforms for metacomputing that orthogonally integrate resource-aware components with resource-independent, application-level components.