Common Component Architecture Research Articles

Debugging high‐performance component‐based applications

AbstractComponent frameworks for high‐performance computing (HPC) have special requirements that distinguish them from general component frameworks and other traditional/monolithic codes. HPC component‐based applications have a crucial need for correct, high‐performance execution across a variety of open‐source and proprietary component compositions, potentially incorporating several different programming languages. This paper targets the unique challenges associated with debugging HPC component‐based applications in the Common Component Architecture (CCA). We propose to take advantage of the well‐defined code separation created by component interfaces or ‘ports’ by logging port method invocations and capturing the corresponding data arguments. This approach makes it possible to find and isolate faulty components, simulate their invocation for specific debugging analyses, check data argument validity and boundaries, and create inputs for black‐box testing. Published in 2006 by John Wiley & Sons, Ltd.

Component‐oriented application construction for a Web service‐based Grid

AbstractWe present the architecture and prototype implementation of a component‐oriented programming environment for a Web service based computational Grid. As middleware, we utilize the Vienna Grid Environment (VGE), a framework that enables the provision of compute‐intensive parallel applications as configurable, QoS‐aware Grid services. Our component model follows the Common Component Architecture (CCA) and models application Web services as distributed components. We describe a component framework that integrates VGE services with a component model allowing to express and dynamically manage application and performance meta‐data as well as dependencies on the infrastructure or other components. Furthermore, we show how the client programming interface is used to compose Grid applications from abstract application components that are mapped against available Grid services by the component framework at runtime. Copyright © 2006 John Wiley & Sons, Ltd.

How the common component architecture advances computational science

Computational chemists are using Common Component Architecture (CCA) technology to increase the parallel scalability of their application ten-fold. Combustion researchers are publishing science faster because the CCA manages software complexity for them. Both the solver and meshing communities in SciDAC are converging on community interface standards as a direct response to the novel level of interoperability that CCA presents. Yet, there is much more to do before component technology becomes mainstream computational science. This paper highlights the impact that the CCA has made on scientific applications, conveys some lessons learned from five years of the SciDAC program, and previews where applications could go with the additional capabilities that the CCA has planned for SciDAC 2.

Enabling new capabilities and insights from quantum chemistry by using component architectures

Steady performance gains in computing power, as well as improvements in Scientific computing algorithms, are making possible the study of coupled physical phenomena of great extent and complexity. The software required for such studies is also very complex and requires contributions from experts in multiple disciplines. We have investigated the use of the Common Component Architecture (CCA) as a mechanism to tackle some of the resulting software engineering challenges in quantum chemistry, focusing on three specific application areas. In our first application, we have developed interfaces permitting solvers and quantum chemistry packages to be readily exchanged. This enables our quantum chemistry packages to be used with alternative solvers developed by specialists, remedying deficiencies we discovered in the native solvers provided in each of the quantum chemistry packages. The second application involves development of a set of components designed to improve utilization of parallel machines by allowing multiple components to execute concurrently on subsets of the available processors. This was found to give substantial improvements in parallel scalability. Our final application is a set of components permitting different quantum chemistry packages to interchange intermediate data. These components enabled the investigation of promising new methods for obtaining accurate thermochemical data for reactions involving heavy elements.

Experiences with component‐oriented technologies in nuclear power plant simulators

AbstractThis paper proposes the application of modern component‐oriented technologies to the development of nuclear power plant simulators. On the one hand, as a significant improvement on previous simulators, the new kernel is based on the Common Component Architecture (CCA). The use of such a high‐performance computing oriented component technology, together with a novel algorithm to automatically resolve simulation data dependencies, allows the efficient execution of both parallel and sequential simulation models. On the other hand, RT‐CORBA is employed in the development of the rest of the applications that comprise the simulator. This real‐time communication middleware not only makes the management of communications easier, but also provides the applications with real‐time capabilities. Software components used in these two ways, simulation models integrating the kernel and distributed applications from which the simulator is comprised, improve the evolution and maintenance of the entire system, as well as promoting code reusability in other projects. Copyright © 2006 John Wiley & Sons, Ltd.

Data redistribution and remote method invocation for coupled components

With the increasing availability of high-performance massively parallel computer systems, the prevalence of sophisticated scientific simulation has grown rapidly. The complexity of the scientific models being simulated has also evolved, leading to a variety of coupled multi-physics simulation codes. Such cooperating parallel programs require fundamentally new interaction capabilities, to efficiently exchange parallel data structures and collectively invoke methods across programs. So-called “ M × N ” research, as part of the common component architecture (CCA) effort, addresses these special and challenging needs, to provide generalized interfaces and tools that support flexible parallel data redistribution and parallel remote method invocation. Using this technology, distinct simulation codes with disparate distributed data decompositions can work together to achieve greater scientific discoveries.

A Component Architecture for High-Performance Scientific Computing

The Common Component Architecture (CCA) provides a means for software developers to manage the complexity of large-scale scientific simulations and to move toward a plug-and-play environment for high-performance coputing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed coputing as well as local high-performance connections between components in a language-independent manner. The design places minimal requirements on components and thus facilitates the integration of existing code into the CCA environment. The CCA model imposes minimal ovehead to minimize the impact on application performance. The focus on high performance distinguishes the CCA from most other component models. The CCA is being applied within an increasing range of disciplines, including cobustion research, global climate simulation, and computtional chemistry.

Cumulvs: Interacting with High-Performance Scientific Simulations, for Visualization, Steering and Fault Tolerance

High-performance computer simulations are an increasingly popular alternative or complement to physical experiments or prototypes. However, as these simulations grow more massive and complex, it becomes challenging to monitor and control their execution. CUMULVS is a middleware infrastructure for visualizing and steering scientific simulations while they are running. Front-end “viewers” attach dynamically to simulation programs, to extract and collect intermediate data values, even if decomposed over many parallel tasks. These data can be graphically viewed or animated in a variety of commercial or custom visualization environments using a provided viewer library. In response to this visual feedback, scientists can “close the loop” and apply interactive control using computational steering of any user-defined algorithmic or model parameters. The data identification interfaces and gathering protocols can also be applied for parallel data exchange in support of coupled simulations, and for application-directed collection of key program data in checkpoints, for automated restart in response to software or hardware failures. CUMULVS was originally based on PVM, but interoperates well with simulations that use MPI or other parallel environments. Several alternate messaging systems are being integrated with CUMULVS to ease its applicability, e.g. to MPI. CUMULVS has recently been integrated with the Common Component Architecture (CCA) for visualization and parallel data redistribution (referred to as “MxN”), and also with Global Arrays. This paper serves as a comprehensive overview of the CUMULVS capabilities, their usage, and their development over several years.

Coupling climate models with the Earth System Modeling Framework and the Common Component Architecture

AbstractTypical Earth system models involve coupled model components in high‐performance computing (HPC) environments. In the last few years, several frameworks have been developed for HPC applications. Two of them are component‐based frameworks: the Earth System Modeling Framework (ESMF) defining a component interface for Earth system models and the Common Component Architecture (CCA) defining a generic component model. The purpose of this work is to investigate the relationship between ESMF and CCA to deploy the best features of ESMF and CCA into a ESMF–CCA prototype and examine the prototype through a representative coupled climate model. Copyright © 2005 John Wiley & Sons, Ltd.

The CCA component model for high‐performance scientific computing

AbstractThe Common Component Architecture (CCA) is a component model for high‐performance computing, developed by a grass‐roots effort of computational scientists. Although the CCA is usable with CORBA‐like distributed‐object components, its main purpose is to set forth a component model for high‐performance, parallel computing. Traditional component models are not well suited for performance and massive parallelism. We outline the design pattern for the CCA component model, discuss our strategy for language interoperability, describe the development tools we provide, and walk through an illustrative example using these tools. Performance and scalability, which are distinguishing features of CCA components, affect choices throughout design and implementation. Copyright © 2005 John Wiley & Sons, Ltd.

On Building Parallel & Grid Applications: Component Technology and Distributed Services

Software Component Frameworks are well known in the commercial business application world and now this technology is being explored with great interest as a way to build large-scale scientific applications on parallel computers. In the case of Grid systems, the current architectural model is based on the emerging web services framework. In this paper we describe progress that has been made on the Common Component Architecture model (CCA) and discuss its success and limitations when applied to problems in Grid computing. Our primary conclusion is that a component model fits very well with a services-oriented Grid, but the model of composition must allow for a very dynamic (both in space and in time) control of composition. We note that this adds a new dimension to conventional service workflow and it extends the "Inversion of Control" aspects of most component systems.

Performance technology for parallel and distributed component software

AbstractThis work targets the emerging use of software component technology for high‐performance scientific parallel and distributed computing. While component software engineering will benefit the construction of complex science applications, its use presents several challenges to performance measurement, analysis, and optimization. The performance of a component application depends on the interaction (possibly nonlinear) of the composed component set. Furthermore, a component is a ‘binary unit of composition’ and the only information users have is the interface the component provides to the outside world. A performance engineering methodology and development approach is presented to address evaluation and optimization issues in high‐performance component environments. We describe a prototype implementation of a performance measurement infrastructure for the Common Component Architecture (CCA) system. A case study demonstrating the use of this technology for integrated measurement, monitoring, and optimization in CCA component‐based applications is given. Copyright © 2005 John Wiley & Sons, Ltd.

Component-based software for high-performance scientific computing

Recent advances in both computational hardware and multidisciplinary science have given rise to an unprecedented level of complexity in scientific simulation software. This paper describes an ongoing grass roots effort aimed at addressing complexity in high-performance computing through the use of Component-Based Software Engineering (CBSE). Highlights of the benefits and accomplishments of the Common Component Architecture (CCA) Forum and SciDAC ISIC are given, followed by an illustrative example of how the CCA has been applied to drive scientific discovery in quantum chemistry. Thrusts for future research are also described briefly.

A component-based toolkit for simulating reacting flows with high order spatial discretisations on structured adaptively refined meshes

We present an innovative methodology for developing scientific and mathematical codes for computational studies of reacting flow. High-order (>2) spatial discretisations are combined, for the first time, with multi-level block structured adaptively refined meshes (SAMR) to resolve regions of high gradients efficiently. Within the SAMR context, we use 4th order spatial discretisations to achieve the desired numerical accuracy while maintaining a shallow grid hierarchy. We investigate in detail the pairing between the order of the spatial discretisation and the order of the interpolant, and their effect on the overall order of accuracy. These new approaches are implemented in a high performance, component-based architecture (Common Component Architecture) and achieve software re-usability, flexibility and modularity. The high-order approach and the software design are demonstrated and validated on three test cases modelled as reaction-diffusion systems of increasing complexity. We also demonstrate that the 4th order SAMR approach can be computationally more economical compared to second-order approaches.

Component-based integration of chemistry and optimization software.

Typical scientific software designs make rigid assumptions regarding programming language and data structures, frustrating software interoperability and scientific collaboration. Component-based software engineering is an emerging approach to managing the increasing complexity of scientific software. Component technology facilitates code interoperability and reuse. Through the adoption of methodology and tools developed by the Common Component Architecture Forum, we have developed a component architecture for molecular structure optimization. Using the NWChem and Massively Parallel Quantum Chemistry packages, we have produced chemistry components that provide capacity for energy and energy derivative evaluation. We have constructed geometry optimization applications by integrating the Toolkit for Advanced Optimization, Portable Extensible Toolkit for Scientific Computation, and Global Arrays packages, which provide optimization and linear algebra capabilities. We present a brief overview of the component development process and a description of abstract interfaces for chemical optimizations. The components conforming to these abstract interfaces allow the construction of applications using different chemistry and mathematics packages interchangeably. Initial numerical results for the component software demonstrate good performance, and highlight potential research enabled by this platform.

The CCA core specification in a distributed memory SPMD framework

AbstractWe present an overview of the Common Component Architecture (CCA) core specification and CCAFFEINE, a Sandia National Laboratories framework implementation compliant with the draft specification. CCAFFEINE stands for CCA Fast Framework Example In Need of Everything; that is, CCAFFEINE is fast, lightweight, and it aims to provide every framework service by using external, portable components instead of integrating all services into a single, heavy framework core. By fast, we mean that the CCAFFEINE glue does not get between components in a way that slows down their interactions. We present the CCAFFEINE solutions to several fundamental problems in the application of component software approaches to the construction of single program multiple data (SPMD) applications. We demonstrate the integration of components from three organizations, two within Sandia and one at Oak Ridge National Laboratory. We outline some requirements for key enabling facilities needed for a successful component approach to SPMD application building. Copyright © 2002 John Wiley & Sons, Ltd.

Programming the Grid: Distributed Software Components, P2P and Grid Web Services for Scientific Applications

Computational Grids [17,25] have become an important asset in large-scale scientific and engineering research. By providing a set of services that allow a widely distributed collection of resources to be tied together into a relatively seamless computing framework, teams of researchers can collaborate to solve problems that they could not have attempted before. Unfortunately the task of building Grid applications remains extremely difficult because there are few tools available to support developers. To build reliable and re-usable Grid applications, programmers must be equipped with a programming framework that hides the details of most Grid services and allows the developer a consistent, non-complex model in which applications can be composed from well tested, reliable sub-units. This paper describes experiences with using a software component framework for building Grid applications. The framework, which is based on the DOE Common Component Architecture (CCA) [1,2,3,8], allows individual components to export function/service interfaces that can be remotely invoked by other components. The framework also provides a simple messaging/event system for asynchronous notification between application components. The paper also describes how the emerging Web-services [52] model fits with a component-oriented application design philosophy. To illustrate the connection between Web services and Grid application programming we describe a simple design pattern for application factory services which can be used to simplify the task of building reliable Grid programs. Finally we address several issues of Grid programming that better understood from the perspective of Peer-to-Peer (P2P) systems. In particular we describe how models for collaboration and resource sharing fit well with many Grid application scenarios.