Generic programming in POOMA and PETE

POOMA is a C++ framework for developing portable scientific applications for serial and parallel computers using high-level physical abstractions. PETE is the expression template library used by POOMA. This paper discusses generic programming techniques that are used to achieve flexibility and high performance in POOMA and PETE. POOMA uses an engine class that factors the data representation out of its array classes. PETE`s expression templates are used to build up and operate efficiently on expressions. PETE itself uses generic techniques to adapt to a variety of client-class interfaces, and to provide a powerful and flexible compile-time expression-tree traversal mechanism

Tecolote: An object-oriented framework for physics development

The authors describe a C++ physics development environment, called the Tecolote Framework, which allows model developers to work more efficiently and accurately. This Framework contains a variety of meshes, operators, and parallel fields, as well as an input/output (I/O) subsystem and graphics capabilities. Model developers can inherit Tecolote`s generic model interface and use the Framework`s high-level field and operator components to write parallel physics equations. New Tecolote models are easily registered with the Framework, and they can be built and called directly from the input file, which greatly expedites model installation. In the process of developing an extensible and robust framework, they have found appealing solutions to some of the serious problems they encounter when parallelizing and extending the older codes. They also discuss memory and performance issues for a large hydrodynamics application built in this Framework

SMARTS: Exploiting Temporal through Vertical Execution

Abstract In the solution of large-scale numerical problems, parallel computing is becoming simultaneously more important and more dificult. The complex organization of today's multiprocessors with several memory hierarchies has forced the scientific programmer to make a choice between simple but unscalable code and scalable but extremely complex code that does not port to other architectures. This paper describes how the SMARTS runtime system and the POOMA C++ class library for high-performance scientific computing work together to exploit data parallelism in scientific applications while hiding the details of managing parallelism and data locality from the user. We present innovative algorithms, based on the macro-dataflow model, for detecting data parallelism and efficiently executing dataparallel statements on shared-memory multiprocessors. We also describe how these algorithms can be implemented on clusters of SMPs

Finite difference methods fengshui: alignment through a mathematics of arrays

Numerous scientific-computational domains make use of array data. The core computing of the numerical methods and the algorithms involved is related to multi-dimensional array manipulation. Memory layout and the access patterns of that data are crucial to the optimal performance of the array-based computations. As we move towards exascale computing, writing portable code for efficient data parallel computations is increasingly requiring an abstract productive working environment. To that end, we present the design of a framework for optimizing scientific array-based computations, building a case study for a Partial Differential Equations solver. By embedding the Mathematics of Arrays formalism in the Magnolia programming language, we assemble a software stack capable of abstracting the continuous high-level application layer from the discrete formulation of the collective array-based numerical methods and algorithms and the final detailed low-level code. The case study lays the groundwork for achieving optimized memory layout and efficient computations while preserving a stable abstraction layer independent of underlying algorithms and changes in the architecture.Peer ReviewedPostprint (author's final draft

Construção de um software de elementos finitos usando programação generica/generativa : considerações sobre C++, performance e generalidade

Orientador: João Frederico C. A. MeyerTese (doutorado) - Universidade Estadual de Campinas, Instituto de Matematica, Estatistica e Computação CientificaResumo: Este trabalho descreve a construção de uma biblioteca computacional (chamada Osiris) que implementa as funcionalidades necessárias para a execução de simulações baseadas no método dos elementos finitos. Os objetivos de Osiris são a flexibilidade, o desempenho e a extensibilidade. Estes quesitos são satisfeitos não apenas pela escolha da orientação por objetos (C++), mas também pelo uso e extensão do estado da arte em Programação Genérica e Programação Generativa. Váarios exemplos numéericos são apresentados, alguns de interesse em BiomatemáticaAbstract: This work describes the creation of a computational library (named Osiris) that implements the basic functionalities needed in usual Finite Element simulations. Osiris' objectives are flexibility, performance and extensibility. These requirements are fulfilled not only by the choice of an object oriented language (C++), but also by the use and extension of the state-of-the-art in Generic Programming and Generative Programming. Several numerical examples are discussed, some of interest from a Biomathematics point of viewDoutoradoMatematica AplicadaDoutor em Matemática Aplicad