Benjamin A. Allan

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.

The CCA core specification in a distributed memory SPMD framework

We 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

Parallel PDE-Based Simulations Using the Common Component Architecture

The complexity of parallel PDE-based simulations continues to increase as multimodel, multiphysics, and multi-institutional projects become widespread. A goal of component- based software engineering in such large-scale simulations is to help manage this complexity by enabling better interoperability among various codes that have been independently developed by different groups. The Common Component Architecture (CCA) Forum is defining a component architecture specification to address the challenges of high-performance scientific computing. In addition, several execution frameworks, supporting infrastructure, and general-purpose components are being developed. Furthermore, this group is collaborating with others in the high-performance computing community to design suites of domain-specific component interface specifications and underlying implementations.

Bocca: a development environment for HPC components

In high-performance scientific software development, the emphasis is often on short time to first solution. Even when the development of new components mostly reuses existing components or libraries and only small amounts of new code must be created, dealing with the component glue code and software build processes to obtain complete applications is still tedious and error-prone. Component-based software meant to reduce complexity at the application level increases complexity with the attendant glue code. To address these needs, we introduce Bocca, the first tool to enable application developers to perform rapid component prototyping while maintaining robust software-engineering practices suitable to HPC environments. Bocca provides project management and a comprehensive build environment for creating and managing applications composed of CommonComponent Architecture components. Of critical importance for HPC applications, Bocca is designed to operate in a language-agnostic way, simultaneously handling components written in any of the languages commonly used in scientific applications: C, C++, Fortran, Fortran77, Python,and Java. Bocca automates the tasks related to the component glue code, freeing the user to focus on the scientific aspects of the application. Bocca embraces the philosophy pioneered by Ruby Rails for web applications: Start with something that works and evolve it to the users purpose.

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.

ODEPACK++: refactoring the LSODE Fortran library for use in the CCA high performance component software architecture

We present a case study of the alternatives and design trade-offs encountered when adapting an established numerical library into a form compatible with modern component-software implementation practices. Our study will help scientific software users, authors, and maintainers develop their own roadmaps for shifting to component-oriented software. The primary library studied, LSODE, and the issues involved in the adaptation are typical of many commonly used numerical libraries. We examine the adaptation of a related library, CVODE, and compare the impact on applications of the two different designs. The LSODE-derived components solve models composed with CCA components developed independently at the Argonne and Oak Ridge National Laboratories. The resulting applications run in the Ccaffeine framework implementation of the common component architecture specification. We provide CCA-style interface specifications appropriate to linear equations, ordinary differential equations (ODE), and differential algebraic equations (DAE) solvers.

Toward Rapid Understanding of Production HPC Applications and Systems

A detailed understanding of HPC applications resource needs and their complex interactions with each other and HPC platform resources is critical to achieving scalability and performance. Such understanding has been difficult to achieve because typical application profiling tools do not capture the behaviors of codes under the potentially wide spectrum of actual production conditions and because typical monitoring tools do not capture system resource usage information with high enough fidelity to gain sufficient insight into application performance and demands. In this paper we present both system and application profiling results based on data obtained through synchronized system wide monitoring on a production HPC cluster at Sandia National Laboratories (SNL). We demonstrate analytic and visualization techniques that we are using to characterize application and system resource usage under production conditions for better understanding of application resource needs. Our goals are to improve application performance (through understanding application-to-resource mapping and system throughput) and to ensure that future system capabilities match their intended workloads.

OnRamp: enabling a new component-based development paradigm

Often the adoption of component-based scientific software requires the developer to abandon comfortable practices and embrace an unfamiliar software methodology. OnRamp provides a mechanism for the developer to generate CCA components, through commented markup in their original software, and keep their familiar software development practices. The developer uses these annotations to identify which methods in their code belong to which Port interfaces, and which Ports belong to which CCA components. Taken by itself, the markup is sufficient to create a skeleton of components representing the exported functionality of the original code, but because the entire code is available to OnRamp the implementation can also be generated. The functionality of the original code is wrapped in annotation-specified components, exporting part or all of its original functionality. OnRamp provides a model for component software engineering that allows developers to improve their code with their familiar software and in their established software practices and also interoperate with external developers easily when the need arises.

ISIS++Reference Guide (Iterative Scalable Implicit Solver in C++) Version 1.1

ISIS++ (Iterative Scalable Implicit Solver in C++) Version 1.1 is a portable, object-oriented framework for solving sparse linear systems of equations. It includes a collection of Krylov solution methods and preconditioners, as well as both uni-processor (serial) and multi-processor (scalable) matrix and vector classes. Though it was developed to solve systems of equations originating from large-scale, 3-D, finite element analyses, it has application in many other fields. This document supersedes the ISIS++ V1.0 Reference Guide, defines the V1. 1 interface specification, and includes the necessary instructions for building and running ISIS++ v 1.1 on Unix platforms. The interface is presented in annotated header format, along with background on design and implementation considerations. A finite difference modeling example problem is included to demonstrate the overall setup and use.

Managing scientific software complexity with Bocca and CCA

In high-performance scientific software development, the emphasis is often on short time to first solution. Even when the development of new components mostly reuses existing components or libraries and only small amounts of new code must be created, dealing with the component glue code and software build processes to obtain complete applications is still tedious and error-prone. Component-based software meant to reduce complexity at the application level increases complexity to the extent that the user must learn and remember the interfaces and conventions of the component model itself. To address these needs, we introduce Bocca, the first tool to enable application developers to perform rapid component prototyping while maintaining robust software-engineering practices suitable to HPC environments. Bocca provides project management and a comprehensive build environment for creating and managing applications composed of Common Component Architecture components. Of critical importance for high-performance computing (HPC) applications, Bocca is designed to operate in a language-agnostic way, simultaneously handling components written in any of the languages commonly used in scientific applications: C, C++, Fortran, Python and Java. Bocca automates the tasks related to the component glue code, freeing the user to focus on the scientific aspects of the application. Bocca embraces the philosophy pioneered by Ruby on Rails for web applications: start with something that works, and evolve it to the users purpose.