Showing papers on "Source transformation published in 2008"

OpenAD/F: A Modular Open-Source Tool for Automatic Differentiation of Fortran Codes

Abstract: The Open/ADF tool allows the evaluation of derivatives of functions defined by a Fortran program. The derivative evaluation is performed by a Fortran code resulting from the analysis and transformation of the original program that defines the function of interest. Open/ADF has been designed with a particular emphasis on modularity, flexibility, and the use of open source components. While the code transformation follows the basic principles of automatic differentiation, the tool implements new algorithmic approaches at various levels, for example, for basic block preaccumulation and call graph reversal. Unlike most other automatic differentiation tools, Open/ADF uses components provided by the Open/AD framework, which supports a comparatively easy extension of the code transformations in a language-independent fashion. It uses code analysis results implemented in the OpenAnalysis component. The interface to the language-independent transformation engine is an XML-based format, specified through an XML schema. The implemented transformation algorithms allow efficient derivative computations using locally optimized cross-country sequences of vertex, edge, and face elimination steps. Specifically, for the generation of adjoint codes, Open/ADF supports various code reversal schemes with hierarchical checkpointing at the subroutine level. As an example from geophysical fluid dynamics, a nonlinear time-dependent scalable, yet simple, barotropic ocean model is considered. OpenAD/F's reverse mode is applied to compute sensitivities of some of the model's transport properties with respect to gridded fields such as bottom topography as independent (control) variables.

On the implementation of automatic differentiation tools

Abstract: Automatic differentiation is a semantic transformation that applies the rules of differential calculus to source code. It thus transforms a computer program that computes a mathematical function into a program that computes the function and its derivatives. Derivatives play an important role in a wide variety of scientific computing applications, including numerical optimization, solution of nonlinear equations, sensitivity analysis, and nonlinear inverse problems. We describe the forward and reverse modes of automatic differentiation and provide a survey of implementation strategies. We describe some of the challenges in the implementation of automatic differentiation tools, with a focus on tools based on source transformation. We conclude with an overview of current research and future opportunities.

On the Practical Exploitation of Scarsity

Abstract: Scarsity is the notion that the Jacobian J for a given function f: ℝ n ↦ ℝ m may have fewer than n * m degrees of freedom. A scarse J may be represented by a graph with a minimal edge count. So far, scarsity has been recognized only from a high-level application point of view, and no automatic exploitation has been attempted. We introduce an approach to recognize and use scarsity in computational graphs in a source transformation context. The goal is to approximate the minimal graph representation through a sequence of transformations including eliminations, reroutings, and normalizations, with a secondary goal of minimizing the transformation cost. The method requires no application-level insight and is implemented as a fully automatic transformation in OpenAD. This paper introduces the problem and a set of heuristics to approximate the minimal graph representation. We also present results on a set of test problems.

Using Source-to-Source Transformation Tools to Provide Distributed Parallel Applications from OpenMP Source Code

Abstract: Thanks to an easy way to express parallel opportunities, OpenMP has become the reference to develop applications for shared-memory architectures. As a result, several works have tried to provide an OpenMP compiler for distributed architectures. This article presents how the Turing eXtended Language (TXL) has been interfaced with the GCC compiler to implement the Checkpointing Aided Parallel Execution (CAPE) concepts in order to provide an OpenMP compiler for distributed architectures.

Source Transformation Theorem Revisited

Abstract: It is known that a parallel combination of a current source and a resistance can be replaced by a series combination of a voltage source and a resistance and vice versa according to the source transformation theorem. Thus, the source transformation gives only one current to voltage or voltage to current equivalent circuit. In this short paper, we show that there is a large number of current to voltage, voltage to current, current to current and voltage to voltage source transformations possible under certain given terminal condition. This result is not given in the text books.

Language Implementation by Source Transformation

Abstract: ...........................................................................................................................................ii Acknowledgements.........................................................................................................................iii Table of

Coping with a Variable Number of Arguments when Transforming MATLAB Programs

Abstract: The programming language MATLAB supports default values for arguments as well as argument lists of variable length. This work analyzes the effects of these two language concepts on the design of source transformation tools for automatic differentiation. The term automatic differentiation refers to a collection of techniques to augment a given computer code with statements for the computation of user-specified derivatives. The focus here is on the source transformation tool ADiMat implementing automatic differentiation for programs written in MATLAB. The approach taken by ADiMat to cope with default arguments and argument lists of variable length is described. Implementation techniques and remaining open questions are discussed.