Tamara L. Dahlgren

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.

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.

Improving scientific software component quality through assertions

We are proposing research on self-adaptive interface assertion enforcement for the purposes of improving scientific software component quality. Demonstrating software correctness through assertions is a well-known technique for quality improvement. However, the performance penalty is often considered too high for deployment. In order to determine if partial enforcement based on adaptive sampling is a viable solution in performance critical environments, we are pursuing research on mechanisms combining static and dynamic analyses to efficiently maximize assertion checking within performance constraints. This paper gives an overview of our initial experiments, current work, and plans.

High-performance language interoperability for scientific computing through Babel

High-performance scientific applications are usually built from software modules written in multiple programming languages. This raises the issue of language interoperability which involves making calls between languages, converting basic types, and bridging disparate programming models. Babel provides a feature-rich, extensible, high-performance solution to the language interoperability problem currently supporting C, C++, FORTRAN 77, Fortran 90/95, Fortran 2003/2008, Python, and Java. Babel supports object-oriented programming features and interface semantics with runtime enforcement. In addition to in-process language interoperability, Babel includes remote method invocation to support hybrid parallel and distributed computing paradigms.

Performance-driven interface contract enforcement for scientific components

Several performance-driven approaches to selectively enforce interface contracts for scientific components are investigated. The goal is to facilitate debugging deployed applications built from plug-and-play components while keeping the cost of enforcement within acceptable overhead limits. This paper describes a study of global enforcement using a priori execution cost estimates obtained from traces. Thirteen trials are formed from five, single-component programs. Enforcement experiments conducted using twenty-three enforcement policies are used to determine the nature of exercised contracts and the impact of a variety of sampling strategies. Performance-driven enforcement appears to be best suited to programs that exercise moderately expensive contracts.

The TSTT Mesh Interface

PDE-based numerical simulation applications commonly use basic software infrastructure to manage mesh, geometry, and discretization data. The commonality of this infrastructure implies the software is theoretically amenable to re-use. However, the traditional reliance on library-based implementations of these functionalities hampers experimentation with different software instances that provide similar functionality. This is especially true for meshing and geometry libraries where applications often directly access the underlying data structures, which can be quite different from implementation to implementation. Thus, using different libraries interchangeably or interoperably for this functionality has proven difficult at best and has hampered the wide spread use of advanced meshing and geometry tools developed by the research community. To address these issues, the Terascale Simulation Tools and Technologies center is working to develop standard interfaces to enable the creation of interoperable and interchangeable simulation tools. In this paper, we focus on a languageand data-structure-independent interface supporting query and modification of mesh data conforming to a general abstract data model. We describe the model and interface, and provide programming “best practices” recommendations based on early experience implementing and using the interface.

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.

Gaining confidence in scientific applications through executable interface contracts

Interface contract enforcement is intended to help scientists gain confidence in software built from third-party components. Unfamiliar components present increased risk of incorrect or unanticipated usage patterns and unexpected component behavior. Executable interface contracts can address these issues but may incur unacceptable overhead. Research into techniques for performance-driven contract enforcement pursues practical solutions to adapting the level of contract enforcement to performance constraints.

COMPOSE-HPC: A TRANSFORMATIONAL APPROACH TO EXASCALE

The goal of the COMPOSE-HPC project is to “democratize” tools for automatic transformation of program source code so that it becomes tractable for the developers of scientific applications to create and use their own transformations reliably and safely. This paper describes our approach to this challenge, the creation of the KNOT tool chain, which includes tools for the creation of annotation languages to control the transformations (PAUL), to perform the transformations (ROTE), and optimization and code generation (BRAID), which can be used individually and in combination. We also provide examples of current and future uses of the KNOT tools, which include transforming code to use different programming models and environments, providing tests that can be used to detect errors in software or its execution, as well as composition of software written in different programming languages, or with different threading patterns.

Interface contract enforcement for improvement of computational quality of service (CQoS) for scientific components

This paper describes recent investigations into improving the quality and performance of component-based scientific software. Our approach merges work on Computational Quality of Service (CQoS) with enforceable semantic annotations, in the form of interface contracts, to facilitate the adaptivity of component-based applications and improve the usability of CQoS components. Component interfaces, as advanced by the Common Component Architecture, enable easy access to complex software packages for high-performance scientific computing. However, many challenges remain in ensuring that components are configured and used correctly in long-running simulations. Interface contracts have proven to be helpful for ensuring correct usage. Additional work on CQoS exploits component automation, including capabilities for plugging and unplugging components during execution, to help application scientists choose among alternative algorithmic implementations and parameters, thereby creating new opportunities to enhance the performance of CCA applications. This paper describes the integration of CQoS capabilities and interface contracts and presents two application use cases involving nonlinear solver components.