Our goal is to apply the software engineering advantages of object-oriented programming to the raw power of massively parallel architectures. To do this we have constructed a hierarchy of C++ classes to support the data-parallel paradigm. Feasibility studies and initial coding can be supported by any serial machine that has a C++ compiler. Parallel execution requires an extended Cfront, which understands the data-parallel classes and generates C&#x002A; code. (C&#x002A; is a data-parallel superset of ANSI C developed by Thinking Machines Corporation). This approach provides potential portability across parallel architectures and leverages the existing compiler technology for translating data-parallel programs onto both SIMD and MIMD hardware.

Daniel J. Lickly

Philip J. Hatcher

C++ and Massively Parallel Computers

We describe an object-oriented implementation of numerical integration methods for solving ordinary differential equations. Software components that are common to many different integration methods have been identified and implemented in such a way that they can be reused. This facilitates the design of a uniform user interface and makes the task of implementing a new integration method fairly modest. The sharing of code in this type of implementation also allows for less subjective comparisons of the result from different integration methods.

Kjell Gustafsson

Object-Oriented Implementation of Software for Solving Ordinary Differential Equations

Frameworks are reusable object-oriented designs for domain-specific programs. In our estimation, frameworks are the key to productivity and reuse. However, frameworks require increased support from the programming environment. A framework-based environment must include design aides and project browsers that can mediate between the user and the framework. A framework-based approach also places new requirements on conventional tools such as compilers. This article explores the impact of object-oriented frameworks upon a programming environment, in the context of object-oriented finite element and finite difference codes. The role of tools such as design aides and project browsers is discussed, and the impact of a framework-based approach upon compilers is examined. Examples are drawn from our prototype C++ based environment.

Robert A. Ballance

Anthony J. Giancola

George F. Luger

Timothy J. Ross

A Framework-Based Environment for Object-Oriented Scientific Codes

We describe C++ classes that simplify development of adaptive mesh refinement (AMR) algorithms. The classes divide into two groups, generic classes that are broadly useful in adaptive algorithms, and application-specific classes that are the basis for our AMR algorithm. We employ two languages, with C++ responsible for the high-level data structures, and Fortran responsible for low-level numerics. The C++ implementation is as fast as the original Fortran implementation. Use of inheritance has allowed us to extend the original AMR algorithm to other problems with greatly reduced development time.

William Y. Crutchfield

Michael L. Welcome

Object-Oriented Implementation of Adaptive Mesh Refinement Algorithms

FastScat is a state-of-the-art program for computing electromagnetic scattering and radiation. Its purpose is to support the study of recent algorithmic advancements, such as the fast multipole method, that promise speed-ups of several orders of magnitude over conventional algorithms. The complexity of these algorithms and their associated data structures led us to adopt an object-oriented methodology for FastScat. We discuss the program's design and several lessons learned from its C++ implementation including the appropriate level for object-orientedness in numeric software, maintainability benefits, interfacing to Fortran libraries such as LAPACK, and performance issues.

Lisa Hamilton

Mark Stalzer

R. Steven Turley

John Visher

Stephen Wandzura

FastScatTM: An Object-Oriented Program for Fast Scattering Computation

We discuss a set of parallel array classes, MetaMP, for distributed-memory architectures. The classes are implemented in C++ and interface to the PVM or Intel NX message-passing systems. An array class implements a partitioned array as a set of objects distributed across the nodes &#x2013; a &#x22;collective&#x22; object. Object methods hide the low-level message-passing and implement meaningful array operations. These include transparent guard strips (or sharing regions) that support finite-difference stencils, reductions and multibroadcasts for support of pivoting and row operations, and interpolation/contraction operations for support of multigrid algorithms. The concept of guard strips is generalized to an object implementation of lightweight sharing mechanisms for finite element method (FEM) and particle-in-cell (PIC) algorithms. The sharing is accomplished through the mechanism of weak memory coherence and can be efficiently implemented. The price of the efficient implementation is memory usage and the need to explicitly specify the coherence operations. An intriguing feature of this programming model is that it maps well to both distributed-memory and shared-memory architectures.

Steve W. Otto

Parallel Array Classes and Lightweight Sharing Mechanisms

This article describes a set of C++ classes developed for the AIPS++ project. These classes handle arrays having an arbitrary number of dimensions. We give an overview of the methods available in these classes and show some simple examples of their use. Finally we describe the use of these classes to develop a radio astronomy application and discuss some of the performance issues that must be considered when these classes are used.

A. G. Willis

M. P. Healey

B. E. Glendenning

AIPS++ N-Dimensional Array Classes

Al Vermeulen

Margaret Chapman

OON-SKI: An Introduction

Class-specific optimizations are compiler optimizations specified by the class implementor to the compiler. They allow the compiler to take advantage of the semantics of the particular class so as to produce better code. Optimizations of interest include the strength reduction of class:: array address calculations, elimination of large temporaries, and the placement of asynchronous send/recv calls so as to achieve computation/communication overlap. We will outline our progress towards the implementation of a C++ compiler capable of incorporating class-specific optimizations.

Michael D. Sharp

A Class-Specific Optimizing Compiler

This article introduces basic principles of first order sensitivity analysis and presents an algorithm that can be used to compute the sensitivity of a dynamical system to a selected parameter. This analysis is performed by extending with sensitivity equations the set of differential equations describing the dynamical system. These additional equations require the evaluation of partial derivatives, and so a technique known as the table algorithm, which can be used to exactly and automatically compute these derivatives, is described. A C++ class which can be used to implement the table algorithm is presented along with a driver routine for evaluating the output of a model and its sensitivity to a single parameter. The use of this driver routine is illustrated with a specific application from environmental hazards modeling.

Donna Calhoun

Roy Overstreet

Sensitivity Analysis of a Dynamical System Using C++

About this journal

Scientific Programming provides a forum for research results in, and practical experience with, software engineering environments, tools, languages, and models of computation aimed specifically at supporting scientific and engineering computing.

Journal profile

Meet the editorial board

Chief Editor&nbsp;Professor Tramontana&nbsp;is based at the University of Catania and his research primarily concerns the areas of software engineering and distributed systems.

Editor spotlight

Submit your proposal

Do you think there is an emerging area of research that really needs to be highlighted? Or an existing research area that has been overlooked or would benefit from deeper investigation? Raise the profile of a research area by leading a Special Issue.

Special Issues

Author guidelines

Editorial board

Databases and indexing

title

Scientific Programming provides a forum for research results in, and practical experience with, software engineering environments, tools, languages, and models of computation aimed specifically at supporting scientific and engineering computing.

description

https://images.hindawi.com/journals/sp/sp.banner.jpg

twitter:card

twitter:description

twitter:site

twitter:title

twitter:url

twitter:image

Scientific Programming | Hindawi

Scientific Programming

This Issue is now open for submissions.
Papers are published upon acceptance, regardless of the Special Issue publication date.