Component Software for High-Performance Computing: Using the Common Component Architecture
February 28, 2004
SIAM Associated Conference: Parallel Processing 2004
David Bernholdt
Oak Ridge National Laboratory
As scientific applications and the computers on which they run grow in
size and complexity, it is becoming increasingly important to find ways
to manage and reduce the complexity of the software development process
and increase its productivity. Component-based software engineering (CBSE)
is emerging as a valuable approach to address these issues. While there
are a number of "commodity" component architectures in use, especially
in the business and internet areas, these approaches have a number of problems
which limit their utility in high-performance scientific computing. At the
same time, computational scientists often develop large-scale computational
frameworks to facilitate the development of applications. Many such efforts
include component-like features, but are specific to a given scientific
domain, and are hard to use outside the area for which they were designed.
The Common Component Architecture is a component model specifically designed
for the needs of high performance scientific computing, including both parallel
and distributed computing. It also provides the infrastructure on which
domain-specific frameworks can be built while still allowing easy software
reuse at various levels within the application, and across scientific domains/frameworks.
We believe the topic of software complexity and productivity is a significant
concern to a great many Parallel Processing conference attendees, that component-based
software engineering represents one of the most viable approaches to help
address these issues in the near term, and that the Common Component Architecture
in particular is a practical approach to CBSE that better addresses the
needs of conference attendees than commodity component models. CCA-based
applications and components are already under development in a broad range
of scientific areas, including combustion, climate modeling, meshing tools,
PDE solvers, Poisson solvers, fusion, quantum chemistry, and others.
The CCA Forum's Tutorial Working Group has been developing the CCA tutorial since January 2002, and has offered eight presentations to date, including at SC2002. Below are brief bios of everyone involved in the development and presentation of the tutorial material. Although the number of participants is relatively large, we do a number of things to help insure a well-organized and consistent presentation. Presentations are informally peer reviewed by the group prior to their use, and during each presentation we take notes on both the material and the presentation to guide future refinements. To further assist in making a consistent presentation, we minimize the number of people actually making the presentations - lately we have used a total of four presenters for all tutorial modules (it is too far in advance for us to be able to designate which individuals will be presenting). We also use simple measures, such as using the same template and style for all slides and presenting the entire tutorial from one laptop, to further aid in making a cohesive presentation.
While we can limit it to 1-2 presenters if necessary, we believe 4-5 presenters provides participants with a better experience. The Common Component Architecture is a wide-ranging project, and using more presenters allows us to put forward the people with the most experience in each module (often the developers of tools). Our tutorial is very much a group effort, and we are happy to work with SIAM and the conference organizers to find ways that present the tutorial in publicity material, etc. that reflect its group authorship while satisfying space and style constraints. If there is an honorarium, we are also willing to designate a suitable subset of presenters to receive it.
Robert C. Armstrong
Sandia National Laboratories
Rob was one of the founders of Sandia's Embedded Reasoning Institute and has an abiding interest in embedded systems and software intelligence. Rob's main interest, however, is high performance computing; he serves as the chair of the Common Component Architecture Forum, a standards organization for component models in HPC.
David E. Bernholdt
Oak Ridge National Laboratory
David's research interests are in computer and computational science, and especially in enabling technologies for parallel and high-performance simulation. He is the CCA's Coordinator for User Outreach and Applications and leads the CCA Forum's Tutorial Working Group.
Lori Freitag Diachin
Sandia National Laboratories
Lori's research interests include the development of common interfaces for mesh management packages, mesh quality improvement, and postprocessing of ASCI-scale data sets. She has presented material in previous CCA tutorials, including the tutorial given at SC2002, and has taught as an adjunct lecturer at various Chicago universities since 1994.
Wael R. Elwasif
Oak Ridge National Laboratory
Wael R. Elwasif is a researcher at Oak Ridge National Laboratory's Computer Science and Mathematics division. He is working towards his PhD in Computer Science at the Universsity of Tennessee, Knoxville. His research interests include component technology for scientific computing, distributed computing and data management, fault tolerance, visualization, and computational steering.
Daniel S. Katz
Jet Propulsion Laboratory, California Institute of Technology
Dan supervises JPL's Parallel Applications Technologies Group. His research
includes: numerical methods, algorithms, and programming applied to supercomputing,
parallel computing, cluster computing, and embedded computing; and fault-tolerant
computing. He previously co-authored many CCA and "How to Build a Beowulf"
tutorials.
James A. Kohl
Oak Ridge National Laboratory
James Arthur Kohl is on Research Staff at Oak Ridge National Laboratory, with a Ph.D. in Electrical and Computer Engineering from the University of Iowa. Projects include SciDAC Common Component Architecture (CCA), CUMULVS, PVM/XPVM, MatView and Harness. Research interests include visualization, computational steering, application fault tolerance, and parallel/distributed computing.
Gary Kumfert
Lawrence Livermore National Laboratory
Gary (Ph.D. Old Dominion University, 2000) is a Computer Scientist at Lawrence Livermore National Laboratory. He is a principal architect of Babel and coordinates framework and infrastructure R&D in the CCTTSS. Gary has taught classes and short courses in CCA, Babel, Java, introductory numerical linear algebra, and advanced programming topics.
Lois Curfman McInnes
Argonne National Laboratory
Lois investigates algorithms and software for the solution of large-scale PDEs in the Mathematics and Computer Science Division of Argonne and is the CCA's Coordinator for Scientific Components. She has helped to develop and present various tutorials on the CCA and numerical software using the PETSc and TAO libraries.
Boyana Norris
Argonne National Laboratory
Boyana is a researcher in the Mathematics and Computer Science Division of ANL, where she develops numerical components and infrastructure, and investigates numerical quality of service issues for CCA components. She has been involved in the CCA Forum since 1999 and participates in the development and presentation of CCA tutorials.
Craig E. Rasmussen
Los Alamos National Laboratory
Craig is a staff member of the Advanced Computing Laboratory at LANL. He has an extensive publication record in space plasma physics, medical physics, and computational and computer sciences. His current research interests include designing and building applications using parallel component technologies and in building tools for Fortran language interoperability.
Jaideep Ray
Sandia National Laboratories
Jaideep Ray is a member of the technical staff at Sandia National Laboratories, Livermore. He has a PhD in Mechanical Engineering (Rutgers, The State University of New Jersey). His research interests include compressible hydrodynamics, parallel computing and combustion. He is currently involved in developing a flame simulation infrastructure using CCA components.
Sameer Shende
University of Oregon
Sameer is a postdoctoral research associate at the University of Oregon. He received his Ph.D. at the University of Oregon in 2001. He helped develop the TAU (Tuning and Analysis Utilities) and PDT (Program Database Toolkit). His research interests include performance instrumentation and measurement techniques for parallel programs.
Shujia Zhou
Northrop Grumman/TASC
Shujia works NASA's Goddard Space Flight Center where he provides technical support for the development of the Earth System Modeling Framework. His interests include investigating materials properties with massively parallel molecular dynamics simulations; coupling climate models through frameworks; and applying object-oriented design, framework, and component technologies to scientific software development.
The CCA tutorial currently consists of eight modules covering the concepts and motivation for component based software engineering (CBSE) in general as well as the Common Component Architecture in particular in addition to detailed examples of CCA-compliant code and tools. (Modules marked with a "*" are primarily live demonstrations.)
Introduction to Components. A high-level overview of the basic concepts of components and component-based software development. Importantly, we will be careful to convey what components are not as well as what they are to help counter the fact that CBSE is sometimes over-hyped.
CCA Concepts. This module presents the motivations and fundamental concepts of the Common Component Architecture. It will provide participants with the vocabulary to discuss the CCA environment and explain how the CCA has been specifically designed to support high-performance computing.
A Simple CCA Example*. After introducing components and CCA concepts, we will have a "live" module focusing on a simple CCA example to reiterate the essentials ideas. This Simple CCA Example module will introduce a simple, multi-component CCA application for the integration of functions that will be used throughout the tutorial.
Language Interoperability. Babel is the CCA's tool for language interoperability and the Scientific Interface Definition Language (SIDL) used by Babel to represent interfaces.
Writing CCA Components* focuses on the way users write code to create CCA-compliant components (including wrapping of existing software), and the interactions of components in applications. This module is built primarily around "live" CCA-compliant example code and applications.
Building and Running Components* focuses on the issues of building CCA-compliant code into components and composing them to build applications. This module is also primarily "live" code and demonstrations.
A Look at More Complex CCA Applications. This module makes the connection between the simple but easily grasped examples used in the majority of the tutorial to the use of CCA in serious scientific applications. It presents issues around the development of "standardized" interfaces, the growing set of CCA-compliant components available for distribution, and applications being built using the CCA environment.
CCA Status and Plans. To close the tutorial, we will have a short presentation describing the current status of the CCA in terms of both standardization and code development efforts, and our plans for future work in the SciDAC CCTTSS center, which is leading the development of the CCA.
To reduce distractions during the limited time allotted to the tutorial, we will not support live hands-on work by the participants, but we will make available for download a package including all the software necessary for participants to reproduce the basic live examples shown throughout the tutorial.
Past tutorial presentations can be found at http://www.cca-forum.org/tutorials.
This tutorial targets two different levels of participants:
Introductory 25% Intermediate 50% Advanced 25%
Please see item 7.
To get the most out of this tutorial, attendees should be comfortable with scientific computing. Examples will be shown in various programming languages, including Fortran, so specific language background should not matter. Experience with developing large-scale software systems using non-component approaches would enhance appreciation of the component-based approach but is not strictly necessary.
Note: Since we continually update and improve our tutorial, the details of a tutorial this far in the future are subject to some modifications.
1. Introduction to Components (45 min)
2. CCA Concepts (45 min)
3. A Simple CCA Component Application (45 min)
4. Language Interoperable CCA Components via Babel (90 min)
5. Writing Components (60 min)
6. Introduction to the Ccaffeine Framework (60 min)
7. A Look at More Complex Component-Based Applications (90 min)
8. CCA Status and Plans (30 min)
9. Question and Answer Session (15 min)
(Anything not covered during individual presentations)
Created: 6/9/03
Modified: 6/9/03