l. Short Course title:

Component Software for High-Performance Computing: Using the Common Component Architecture

2. Date:

February 28, 2004
SIAM Associated Conference: Parallel Processing 2004

3. Short Course Organizer:

David Bernholdt
Oak Ridge National Laboratory

4. Rationale (Why offer this course):

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.

5. Lecturers

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.

6. Description

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.

7. Course Objectives (What are the intended benefits to the attendee)

This tutorial targets two different levels of participants:

  1. people who are interested in the promise of high-performance components, but who are still on the sidelines waiting to be convinced, and
  2. people who are ready to write high-performance components. For the first group, our goal is to give them the knowledge needed to make intelligent decisions about the adoption of the CCA or any other component approach in their applications. For the second group, our goal is to provide them with an understanding of the CCA and basic examples to get them started building their own components and component-based applications. Each module of the tutorial serves both groups and goals to differing degrees.

8. Level of Material:

Introductory 25% Intermediate 50% Advanced 25%

9. Who Should Attend

Please see item 7.

10. Recommended Background

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.

11. Course Outline

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)

  1. A Pictorial Introduction to Components in Scientific Computing
    1. Different lines of evolution in scientific and business computing
    2. How component technology can address the complexity of both
  2. Introduction to Components
    1. Why do we need components?
    2. What are components?
    3. How do we make components?

2. CCA Concepts (45 min)

  1. Features of the Common Component Architecture
  2. Ports, interoperability, and reuse
  3. Frameworks
  4. Components and component lifecycle
  5. Maintaining high performance: direct connection and parallelism
  6. MxN parallel data redistribution
  7. Language interoperability

3. A Simple CCA Component Application (45 min)

  1. Integrator example background
  2. Building applications from components
  3. Details of Monte Carlo Integrator component
    1. SIDL interface definition
    2. Code for setServices method
    3. Code for integrator method
  4. Details of composing and running the integrator example application
  5. Live demonstration

4. Language Interoperable CCA Components via Babel (90 min)

  1. Introduction: Babel history, and what do we mean by "language interoperability"
  2. Babel basics
    1. What Babel does, and how
    2. How to use Babel
    3. Concepts needed for future tutorial modules
  3. Babel and CCA
    1. The Decaf framework
    2. Building language independent CCA components
    3. Demo

5. Writing Components (60 min)

  1. Example application
  2. Interface definitions: ports
  3. Component implementation
    1. Framework interactions
    2. Component interactions: user and provider ports
  4. Compiling
  5. Live demonstration

6. Introduction to the Ccaffeine Framework (60 min)

  1. What is a CCA framework and what is Ccaffeine?
  2. How can I slip my own component into Ccaffeine?
  3. How do I run Ccaffeine?
  4. Live demonstration
  5. Convenience scripts

7. A Look at More Complex Component-Based Applications (90 min)

  1. Mesh-based applications and component reuse
  2. Combustion applications
  3. Quantum chemistry and optimization
  4. Performance considerations of componentized applications
  5. Common interface specifications: a case study of the TSTT Mesh

8. CCA Status and Plans (30 min)

  1. Scientific component and interface development
  2. MxN parallel data redistribution
  3. CCA frameworks
  4. User outreach and applications integration

9. Question and Answer Session (15 min)

(Anything not covered during individual presentations)

Created: 6/9/03
Modified: 6/9/03