Template Metaprogramming Research Articles

Algorithm 940

In this article we present a compile-time algorithm, implemented using C++ template metaprogramming techniques, that minimizes the use of temporary storage when evaluating expressions. We present the basic building blocks of our algorithm---transformations that act locally on nodes of the expression parse tree---and demonstrate that the application of these local transformations generates a (nonunique) expression that requires a minimum number of temporary storage objects to evaluate. We discuss a C++ implementation of our algorithm using expression templates, and give results demonstrating the effectiveness of our approach.

Towards a performance portable, architecture agnostic implementation strategy for weather and climate models

We propose a software implementation strategy for complex weather and climate models that produces performance portable, architecture agnostic codes. It relies on domain and data structure specific tools that are usable within common model development frameworks - Fortran today and possibly high-level programming environments like Python in the future. We present the strategy in terms of a refactoring project of the atmospheric model COSMO, where we have rewritten the dynamical core and refactored the remaining Fortran code. The dynamical core is built on top of the domain specific Stencil Loop Language for stencil computations on structured grids, a generic framework for halo exchange and boundary conditions, as well as a generic communication library that handles data exchange on a distributed memory system. All these tools are implemented in C++ making extensive use of generic programming and template metaprogramming. The refactored code is shown to outperform the current production code and is performance portable to various hybrid CPU-GPU node architectures.

CU++: an object oriented framework for computational fluid dynamics applications using graphics processing units

The application of graphics processing units (GPU) to solve partial differential equations is gaining popularity with the advent of improved computer hardware. Various lower level interfaces exist that allow the user to access GPU specific functions. One such interface is NVIDIA's Compute Unified Device Architecture (CUDA) library. However, porting existing codes to run on the GPU requires the user to write kernels that execute on multiple cores, in the form of Single Instruction Multiple Data (SIMD). In the present work, a higher level framework, termed CU++, has been developed that uses object oriented programming techniques available in C++ such as polymorphism, operator overloading, and template meta programming. Using this approach, CUDA kernels can be generated automatically during compile time. Briefly, CU++ allows a code developer with just C/C++ knowledge to write computer programs that will execute on the GPU without any knowledge of specific programming techniques in CUDA. This approach is tremendously beneficial for Computational Fluid Dynamics (CFD) code development because it mitigates the necessity of creating hundreds of GPU kernels for various purposes. In its current form, CU++ provides a framework for parallel array arithmetic, simplified data structures to interface with the GPU, and smart array indexing. An implementation of heterogeneous parallelism, i.e., utilizing multiple GPUs to simultaneously process a partitioned grid system with communication at the interfaces using Message Passing Interface (MPI) has been developed and tested.

Implementing monads for C++ template metaprograms

C++ template metaprogramming is used in various application areas, such as expression templates, static interface checking, active libraries, etc. Its recognized similarities to pure functional programming languages–like Haskell–make the adoption of advanced functional techniques possible. Such a technique is using monads, programming structures representing computations. Using them actions implementing domain logic can be chained together and decorated with custom code. C++ template metaprogramming could benefit from adopting monads in situations like advanced error propagation and parser construction. In this paper we present an approach for implementing monads in C++ template metaprograms. Based on this approach we have built a monadic framework for C++ template metaprogramming. As real world examples we present a generic error propagation solution for C++ template metaprograms and a technique for building compile-time parser generators. All solutions presented in this paper are implemented and available as an open source library.

Emulating C++0x concepts

A library for the emulation of C++0x concepts developed using the emerging C++11 programming language is presented. The library integrates existing techniques for concept checking and template metaprogramming to provide a uniform interface to defining and using concepts. The purpose of this work is to establish a concrete foundation for experimentation of design techniques for concepts and to motivate and evaluate language design. The viability of the approach is demonstrated by applying it to characterize a number of previously identified usability problems with concepts in the proposed C++0x language. In particular, issues related to the use of explicit and automatic concepts in generic library design from the perspective of this experiment are examined. Issues related to concept refinement, default implementations of requirements, and the generation of error messages are also discussed.

Tools and techniques for non-invasive explicit parallelization

This paper presents an overview of our experiments in integrating modern software engineering tools and techniques with the process of developing parallel applications for distributed memory architectures. The main goal was to determine the methods that have the potential of reducing the complexities associated with explicit parallelization. We experimented with template metaprogramming, aspect-oriented programming, program transformation engine, and a domain-specific language called Hi-PaL. The pros and cons of using each technique for explicit parallelization are presented in this paper. Our experiments demonstrate that through a combination of modern software engineering tools and techniques, the effort involved in explicit parallelization can be reduced by 90 % without any significant loss in performance.

C++QEDv2: The multi-array concept and compile-time algorithms in the definition of composite quantum systems

C++QED is a versatile framework for simulating open quantum dynamics. It allows to build arbitrarily complex quantum systems from elementary free subsystems and interactions, and simulate their time evolution with the available time-evolution drivers. Through this framework, we introduce a design which should be generic for high-level representations of composite quantum systems. It relies heavily on the object-oriented and generic programming paradigms on one hand, and on the other hand, compile-time algorithms, in particular C++ template-metaprogramming techniques. The core of the design is the data structure which represents the state vectors of composite quantum systems. This data structure models the multi-array concept. The use of template metaprogramming is not only crucial to the design, but with its use all computations pertaining to the layout of the simulated system can be shifted to compile time, hence cutting on runtime. Program summaryProgram title: C++QEDCatalogue identifier: AELU_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AELU_v1_0.htmlProgram obtainable from: CPC Program Library, Queenʼs University, Belfast, N. IrelandLicensing provisions:http://cpc.cs.qub.ac.uk/licence/aelu_v1_0.html. The C++QED package contains other software packages, Blitz, Boost and FLENS, all of which may be distributed freely but have individual license requirements. Please see individual packages for license conditions.No. of lines in distributed program, including test data, etc.: 597 974No. of bytes in distributed program, including test data, etc.: 4 874 839Distribution format: tar.gzProgramming language: C++Computer: i386–i686, x86_64Operating system: In principle cross-platform, as yet tested only on UNIX-like systems (including Mac OS X).RAM: The framework itself takes about 60 MB, which is fully shared. The additional memory taken by the program which defines the actual physical system (script) is typically less than 1 MB. The memory storing the actual data scales with the system dimension for state-vector manipulations, and the square of the dimension for density-operator manipulations. This might easily be GBs, and often the memory of the machine limits the size of the simulated system.Classification: 4.3, 4.13, 6.2, 20External routines: Boost C++ libraries (http://www.boost.org/), GNU Scientific Library (http://www.gnu.org/software/gsl/), Blitz++ (http://www.oonumerics.org/blitz/), Linear Algebra Package – Flexible Library for Efficient Numerical Solutions (http://flens.sourceforge.net/).Nature of problem: Definition of (open) composite quantum systems out of elementary building blocks [1]. Manipulation of such systems, with emphasis on dynamical simulations such as Master-equation evolution [2] and Monte Carlo wave-function simulation [3].Solution method: Master equation, Monte Carlo wave-function method.Restrictions: Total dimensionality of the system. Master equation – few thousands. Monte Carlo wave-function trajectory – several millions.Unusual features: Because of the heavy use of compile-time algorithms, compilation of programs written in the framework may take a long time and much memory (up to several GBs).Additional comments: The framework is not a program, but provides and implements an application-programming interface for developing simulations in the indicated problem domain. Supplementary information: http://cppqed.sourceforge.net/.Running time: Depending on the magnitude of the problem, can vary from a few seconds to weeks.

Tpetra, and the Use of Generic Programming in Scientific Computing

We present Tpetra, a Trilinos package for parallel linear algebra primitives implementing the Petra object model. We describe Tpetra's design, based on generic programming via C++ templated types and template metaprogramming. We discuss some benefits of this approach in the context of scientific computing, with illustrations consisting of code and notable empirical results.

Nested Lambda Expressions with Let Expressions in C++ Template Metaprograms

More and more C++ applications use template metaprograms directly or indirectly by using libraries based on them. Since C++ template metaprograms follow the functional paradigm, the well known and widely used tools of functional programming should be available for developers of C++ template metaprograms as well. Many functional languages support let expressions to bind expressions to names locally. It simplifies the source code, reduces duplications and avoids the pollution of the namespace or namespaces. In this paper we present how let expressions can be introduced in C++ template metaprograms. We also show how let expressions can be used to implement lambda expressions. The Boost Metaprogramming Library provides lambda expressions for template metaprograms, we show their limitations with nested lambda expressions and how our implementation can handle those cases as well.

Functional Extensions to the Boost Metaprogram Library

More and more C++ applications use template metaprograms directly or indirectly by using libraries based on that. Given the complexity of template metaprogramming, developers need supporting libraries. The most widely used one is the Boost template metaprogramming library. It implements commonly used compile time algorithms and meta-data structures in an extensible and reusable way. Despite the wellknown commonality of template metaprogramming and the functional programming paradigm, boost::mpl lacks a few important features directly supporting the functional style. In this paper we evaluate how and in what degree boost::mpl supports functional programming and present new elements it can be improved with.

Domain-specific language integration with compile-time parser generator library

Smooth integration of domain-specific languages into a general purpose host language requires absorbing of domain code written in arbitrary syntax. The integration should cause minimal syntactical and semantic overhead and introduce minimal dependency on external tools. In this paper we discuss a DSL integration technique for the C++ programming language. The solution is based on compile-time parsing of the DSL code. The parser generator is a C++ template metaprogram reimplementation of a runtime Haskell parser generator library. The full parsing phase is executed when the host program is compiled. The library uses only standard C++ language features, thus our solution is highly portable. As a demonstration of the power of this approach, we present a highly efficient and type-safe version of printf and the way it can be constructed using our library. Despite the well known syntactical difficulties of C++ template metaprograms, building embedded languages using our library leads to self-documenting C++ source code.

A generic interface for parallel and adaptive discretization schemes: abstraction principles and the Dune-Fem module

Starting from an abstract mathematical notion of discrete function spaces and operators, we derive a general abstraction for a large class of grid-based discretization schemes for stationary and instationary partial differential equations. Special emphasis is put on concepts for local adaptivity and parallelization with dynamic load balancing. The concepts are based on a corresponding abstract definition of a parallel and hierarchical adaptive grid given in Bastian et al. (Computing 82(2–3):103–119, 2008). Based on the abstract framework, we describe an efficient object oriented implementation of a generic interface for grid-based discretization schemes that is realized in the Dune-Fem library (http://dune.mathematik.uni-freiburg.de). By using interface classes we manage to separate functionality from data structures. Efficiency is obtained by using modern template based generic programming techniques, including static polymorphism, the engine concept, and template metaprogramming. We present numerical results for several benchmark problems and some advanced applications.

Effcient programming techniques for the SACLIB computer algebra library

This dissertation describes three contributions to the SACLIB computer algebra library. Using generic programming we specify the Recursively Fixed Iterator and the Structure Protecting Iterator concepts. We prove that models of these concepts cannot leak or double delete resources. Through template metaprogramming, we implement models of these concepts that provide this memory safety at compile-time and without any run-time overhead. Using aspect oriented programming, we allow unit and regression tests to be automatically obtained from an executing SACLIB program. This program instrumentation is transparent both to SACLIB maintainers and clients. This mechanism allows the automated creation of regression test suites during the execution of normal SACLIB programs. Using code generation and auto-tuning, we allow high performance implementations of the Taylor shift, de Casteljau's algorithm, and the Descartes Method for polynomial root isolation to be automatically tuned for different architectures. This allows a speedup of 10-20 over existing methods to be obtained on modern CPU architectures. The key to this speedup is the creation of a tiling scheme that allows the irregular structure of the computation to be tiled using a small number of tiles that are easy for a code generator to produce code for. The implementation of the Recursively Fixed Iterator and the Structure Protecting Iterator provide memory safety by using C++ template metaprograms that selectively disable certain classes of side effects in programs using the iterators. Other safety properties can be achieved using similar disabling of side effects. We believe that the most important continuation of the work presented here is the development of programming language techniques to allow programmers to control where their code should sit along the spectrum of the absence of side effects in pure functional languages and the unrestricted side effects of imperative language.

Toward foundations for type-reflective metaprogramming

C++ template metaprogramming has been used with great success to build software applications and libraries. In practice, however, template metaprogramming suffers usability, reliability, and capability shortcomings, and it is not well understood in theory. Template metaprogramming has these problems because it relies on emergent properties of disparate language features that were tailored to other purposes. As a step toward solid and sound language support for metaprogramming, this paper establishes firm semantic foundations for select capabilities of template metaprogramming. We analyze C++ and the idioms of template metaprogramming and isolate, in a language-neutral fashion, fundamental capabilities of C++ that enable metaprogramming. Guided by this analysis, we present a design for a core calculus that directly expresses fundamental metaprogramming capabilities, including static computation, code generation, and type reflection. We prove a typesafety property for compile-time evaluation of metaprograms. To formally connect the core calculus to programming practice, we present a more convenient surface language for metaprogramming. Its semantics are captured by type-directed translation to the core calculus. We prove that this translation preserves well-typing. This idealized presentation averts some of the shortcomings of C++ template metaprogramming and provides a framework for further study.

EClean - An Embedded Functional Language

C++ template metaprogramming is often regarded as a functional language, however, nowadays metaprogram libraries are not implemented in functional programming style. In this paper we discuss a compile-time graph-rewriting engine based on the properties of the functional language Clean. The most important property imported from the functional paradigm is the lazy evaluation strategy. With the help of the engine it is possible to embed lazy functional-style code into C++ programs, and transform it into template metaprograms. We present the implemented lazy evaluation strategy by examples including also infinite lists.

High-Level Models for Transformation-Oriented Design of Hardware and Embedded Systems

Abstract —Evolution of design methodologies follows a common trail: technology scaling leads to growing design complexity and rising abstraction level in the domain. Introduction of new (higher) abstraction levels emphasizes the importance of reuse and transformations. The design process can be seen as a sequence of high-level transformations from the higher-level specification to the lower-level one. We analyze high-level modeling and metaprogramming techniques for supporting transformations based on domain variability models. Next, we present a reuse evolution model for domain component design at a higher abstraction level to support the transformation-oriented approaches. Finally, high-level modeling techniques (UML-domain language metamodels for domain code generation, parameterized UML classes for template metaprogramming, feature models for explicit representation of variability) for specification of transformations and metaprograms are analyzed. Index Terms —design automation, transformation, hardware and embedded system design

APPLICATION OF TEMPLATE METAPROGRAMMING TECHNOLOGIES TO IMPROVE THE EFFICIENCY OF PARALLEL ARRAYS

Parallel array library ParSol is an easy way to parallelize data parallel algorithms implemented in C/C++. However, in order to use all the features provided by C++ and OOP in real life applications, the efficiency of C++ code that uses ParSol library must be similar to the one of C code. Template metaprogramming is one of the ways to achieve this goal. This paper describes the details of application of this technology to parallel arrays, and presents the efficiency tests.

E.V.E., An Object Oriented SIMD Library

This paper describes the Expressive Velocity Engine library, an object oriented C++ library designed to ease the process of writing efficient numerical applications using AltiVec, the SIMD extension designed by Apple, Motorola and IBM. AltiVec-powered applications typically show off a relative speed up of 4 to 16 but need a complex and awkward programmation style. By using various template metaprogramming techniques, E.V.E. provides an easy to use, STL-like, interface that allows developer to quickly write efficient and easy to read code. Typical applications written with E.V.E. can benefit from a large fraction of theorical maximum speed up while being written as simple C++ arithmetic code.

A generic toolkit for multivariate fitting designed with template metaprogramming

We present a toolkit developed to perform Unbinned Maximum Likelihood and Chi-square fits for parameters and yields estimates. The design of the toolkit is based on template metaprogramming in order to provide users with a generic interface to minimization tools. The default implementation is based on ROOT wrapper of MINUIT. Commonly used Probability Density Functions (PDFs) are provided with the toolkit and users may add custom PDFs for their own analyses. Description of fit models can be done using a package for symbolic manipulation of analytic functions.

Lazy lists in C++

Languages that support lazy evaluation allow computations with "infinite" data structures (lazy lists); C++ is not among these languages. Using an idiom of generic programming in C++, template metaprogramming, this paper shows how to provide lazy lists nevertheless.