Hands-on Tutorial on Rapid, Sustainable Development for Complex HPC Software


May 13, 2008
PARA 2008 : 9th International Workshop on State-of-the-Art in Scientific and Parallel Computing May 13-16, NTNU, Trondheim, Norway

Short Course Organizer:

Benjamin Allan
Sandia National Laboratory

Table of contents:

  1. Abstract
  2. Objectives
  3. Difficulty
  4. Recommended Background
  5. Justification
  6. Lecturers
  7. Description
  8. Hands-on exercises

1. Abstract:

This is the first European open offering of a tutorial on SIDL, Babel, and the Common Component Architecture for supporting the high-performance computing software development life-cycle.

This tutorial will introduce participants to bocca, a tool reducing the complexity of using SIDL/Babel and the Common Component Architecture (CCA). SIDL and the Babel compiler provide the full multi-language interoperability needed to freely mix C, C++, Fortran, Python, and Java on high-performance architectures. The CCA specification increases software developer productivity by helping to manage the social and software complexity of large-scale applications. Bocca is designed specifically to simplify the use of Babel and CCA in high-performance scientific computing environments. Using lectures and hands-on bocca-based exercises, we will cover the concepts of interoperability, the CCA approach to components, and their uses in scientific applications. Participants will work in a preconfigured instructional software environment. The software and examples will also be available for download.

Past tutorial presentations can be found at http://www.cca-forum.org/tutorials/. For this, the 10th presentation of a CCA-based tutorial since 2002, the tutorial is being significantly expanded to allow more hands-on, practical experience with the tools. The examples presented will include the solution of PDEs and the use of parallel programming (MPI) in a multi-language component environment.

2. Course Objectives and who should attend

This tutorial targets two different levels of participants: 1) people who are interested in the promise of multi-language components, but who are still on the sidelines waiting to be convinced that the available tools are mature enough, and 2) people who are ready to write portable, multilanguage code. For the first group, our goal is to give them the knowledge needed to make intelligent decisions about the adoption of SIDL/Babel or the CCA model. 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 applications. Each module of the tutorial serves both groups and goals to differing degrees. For example, while our introductory material is aimed primarily at those less familiar with components, it also helps to insure that all participants have a common understanding of the concepts and terminology to facilitate the remainder of the tutorial (this is an area in which the terminology is not yet well standardized). On the other hand, detailed hands-on exercises are aimed primarily at the second group, but also give those merely considering components a clear view of what's involved in writing, building, and using components.

3. Difficulty:

50% beginner, 30% intermediate, 20% advanced

4. 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 Python, Java, Fortran, C, and C++ so specific language background should not matter. Experience with developing large-scale or multi-language software systems using other approaches would enhance appreciation of the component-based approach but is not necessary. To participate in the hands-on portion, the ability to use a provided Linux workstation or a provided Windows workstation and remote Linux server is required.

5. Justification

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 and maintenance processes and increase productivity. Component-based software engineering (CBSE) is emerging as a valuable approach to address these issues, but it introduces complexities of its own that we address for the first time through the use of bocca. 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 that limit their utility in high-performance scientific computing. 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. The CCA 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 many Para08 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 addresses the needs of Para08 conference attendees better than commodity component models. CCA-based applications and components are already under development and showing their effectiveness in a broad range of scientific areas, including combustion, climate modeling, meshing tools, PDE solvers, Poisson solvers, fusion, quantum chemistry, and others.

6. Lecturers

Benjamin A Allan
Sandia National Laboratories

Tony Drummond
Lawrence Berkeley National Laboratory

Jaideep Ray
Sandia National Laboratories

Damian Rouson
Sandia National Laboratories

Stefan Muszala
Tech-X Corporation

7. Description

The bocca-based CCA tutorial currently consists of four modules and a hands-on session, which cover the concepts and motivation for CBSE in general as well as the Common Component Architecture in particular in addition to detailed examples of CCA-compliant code and tools.

Introduction to Babel and the CCA. An overview of the basic concepts of multi-lingual, component-based software development, how these ideas are expressed in the Common Component Architecture, and how Babel and CCA have been specifically designed to support high-performance computing. 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.

The Primary Tools. Babel is the CCA's tool for language interoperability, and the Scientific Interface Definition Language (SIDL) is used by Babel to represent interfaces. Ccaffeine is a generic framework implementing the CCA specifications in high-performance environments. Bocca is a code creation and management framework that addresses many code life-cycle issues and automates the hundreds of details faced until now by every user or evaluator of Babel-based CCA technology. This module provides an overview of the concepts behind all these tools. This material sets the stage for participants to begin working with bocca in the hands-on exercises.

Using bocca: Approaches & Experience. This module makes the connection between the simple but easily grasped examples used in the majority of the tutorial and the use of CCA in serious scientific applications. It begins by discussing the process of developing components, including both newly-written code and wrapping of existing code, architectural considerations, and other technical and social issues. The remainder of the module presents an in-depth case study of how Bocca is being used in one domain.

Can it be that easy? A quick demonstration. This module demonstrates the creation of components and a complete running application in minutes.

Hands-on Exercises. A series of individual exercises utilizing CCA tools and components, described in detail below.

8. Hands-on outline

The hands-on portion is self-paced with instructor assistance. Note: Since we continually update and improve our tutorial, the details of a tutorial are subject to minor modifications.

  1. Assembling and Running a PDE Application (from pre-built components)
    • Languages: C, C++, Fortran, Python, Java
  2. Building an application with bocca
    • Languages: C++, Python, Fortran, C, Java
  3. Building a new PDE term component
  4. Defining and using generic run-time parameters
  5. Creating an MPI-dependent component
  6. Static linking applications
    • Languages: C++, Fortran, Python, Java, C
  7. Using TAU to Monitor the Performance of Components
  8. Understanding Arrays and Component State
    • Languages: C, Fortran
  9. Understanding Objects and Passing Modes
    • Languages: C++, Python

Created: 2/19/08
Modified: 2/19/08