Conclusion and Future Work

Efficient and scalable integration of independently developed parallel software components into a single application requires a component architecture that supports ``in-process'' components. In this thesis, we described Charisma, a component architecture for parallel in-process components. Charisma has Converse, an interoperable parallel runtime system based on message-driven execution, at its core. Converse provides data-driven control transfer among components, thus supporting multi-paradigm interoperability and efficient parallel composition of modules. We have demonstrated utility of Converse by building threaded, message-driven, and message-passing languages on top of Converse, thus enabling components written using these paradigms to coexist within a single application as in-process components.

Message-driven execution, along with encapsulation and object virtualization provided by a message-driven object language, Charm++, allows us to build efficient software components that are interoperable. The common interface model of Charisma component architecture allows these components to interact with each other. We observed that traditional interface models based on the object model exhibit several weaknesses, especially for in-process components, where efficiency is of paramount importance. We developed an interface model for Charisma that promotes truly independent development of components. Charisma component interfaces are contracts between the components and the runtime system, rather than between components. Rather than invoking services provided by other components, a Charisma component supplies the runtime system with the data it requires for computations and the data it publishes as a result. These are called input and output ports of a Charisma components. Connections between input ports of one component and the output ports of another are specified (either using Charisma API or the Charisma scripting language) outside of both the components. This, coupled with data-driven control transfer in Converse makes it possible to build reusable components that can be flexibly and efficiently used for application composition.

Although message-driven programming facilitates efficiency and modularity for independent component development, we noted a limitation of message-driven programming systems that obfuscates expression of control-flow within a software component, increasing programming complexity. We have developed a notation called Structured Dagger based on guarded computations (when-blocks), that allows clear expression of control-flow within message-driven components, without incurring additional overheads such as those observed with threaded components.

We have provided support for components based on legacy parallel message-passing codes in Charisma. For this purpose, we have developed Adaptive MPI, an implementation of MPI using Converse's user-level threads. In this thesis, we have described the mechanisms used by AMPI, and evaluated its performance. We have discussed how legacy MPI codes can be converted to AMPI, and can be made into reusable components by providing Charisma interfaces in the message-passing paradigm.