Compile-time Algorithm Research Articles

Algorithms for the Structural Analysis of Multimode Modelica Models

Since its 3.3 release, Modelica offers the possibility to specify models of dynamical systems with multiple modes having different DAE-based dynamics. However, the handling of such models by the current Modelica tools is not satisfactory, with mathematically sound models yielding exceptions at runtime. In this article, we propose several contributions to this multifaceted issue, namely: an efficient and scalable multimode extension of the structural analysis of Modelica models; a systematic way of rewriting a multimode Modelica model, based on this analysis, so that the rewritten model is guaranteed to be correctly compiled by state-of-the-art Modelica tools; a proposal for the handling of the consistent initialization of multimode models; multimode structural analysis algorithms that handle both multiple modes and mode change events in a unified framework, coupled with a compile-time algorithm for identifying and quantifying impulsive behaviors at mode changes. Our approach is illustrated on relevant example models, and the performance of our implementations is assessed on a variable dimension large-scale model.

Compiler-assisted detection of transient memory errors

The probability of bit flips in hardware memory systems is projected to increase significantly as memory systems continue to scale in size and complexity. Effective hardware-based error detection and correction require that the complete data path, involving all parts of the memory system, be protected with sufficient redundancy. First, this may be costly to employ on commodity computing platforms, and second, even on high-end systems, protection against multi-bit errors may be lacking. Therefore, augmenting hardware error detection schemes with software techniques is of considerable interest. In this paper, we consider software-level mechanisms to comprehensively detect transient memory faults. We develop novel compile-time algorithms to instrument application programs with checksum computation codes to detect memory errors. Unlike prior approaches that employ checksums on computational and architectural states, our scheme verifies every data access and works by tracking variables as they are produced and consumed. Experimental evaluation demonstrates that the proposed comprehensive error detection solution is viable as a completely software-only scheme. We also demonstrate that with limited hardware support, overheads of error detection can be further reduced.

C++QEDv2 Milestone 10: A C[formula omitted]/Python application-programming framework for simulating open quantum dynamics

The v2 Milestone 10 release of C++QED is primarily a feature release, which also corrects some problems of the previous release, especially as regards the build system. The adoption of C++11 features has led to many simplifications in the codebase. A full doxygen-based API manual [1] is now provided together with updated user guides. A largely automated, versatile new testsuite directed both towards computational and physics features allows for quickly spotting arising errors. The states of trajectories are now savable and recoverable with full binary precision, allowing for trajectory continuation regardless of evolution method (single/ensemble Monte Carlo wave-function or Master equation trajectory). As the main new feature, the framework now presents Python bindings to the highest-level programming interface, so that actual simulations for given composite quantum systems can now be performed from Python. New version program summaryProgram title: C++QEDCatalogue identifier: AELU_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AELU_v2_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: yesNo. of lines in distributed program, including test data, etc.: 492422No. of bytes in distributed program, including test data, etc.: 8070987Distribution format: tar.gzProgramming language: C++/Python.Computer: i386-i686, x86 64.Operating system: In principle cross-platform, as yet tested only on UNIX-like systems (including Mac OS X).RAM: The framework itself takes about 60MB, which is fully shared. The additional memory taken by the program which defines the actual physical system (script) is typically less than 1MB. 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.External routines: Boost C++ libraries, GNU Scientific Library, Blitz++, FLENS, NumPy, SciPyCatalogue identifier of previous version: AELU_v1_0Journal reference of previous version: Comput. Phys. Comm. 183 (2012) 1381Does the new version supersede the previous version?: YesNature of problem:Definition of (open) composite quantum systems out of elementary building blocks [2,3]. Manipulation of such systems, with emphasis on dynamical simulations such as Master-equation evolution [4] and Monte Carlo wave-function simulation [5].Solution method:Master equation, Monte Carlo wave-function methodReasons for new version:The new version is mainly a feature release, but it does correct some problems of the previous version, especially as regards the build system.Summary of revisions:We give an example for a typical Python script implementing the ring-cavity system presented in Sec. 3.3 of Ref. [2]:C+ + codePython codeinvoking the framework#include “EvolutionComposite.h”#include “ParticleTwoModes.h” int main(int argc, char* argv[]) {import sys from cpypyqed import *command-line parametersParameterTable p; evolution::Pars pe(p); particle::Pars pp(p); mode::ParsLossy pmP(p,“P”); mode::ParsPumpedLossy pmM(p,“M”); particlecavity::ParsAlong ppcP(p,“P”); particlecavity::ParsAlong ppcM(p,“M”); ppcP.modeCav=MFT_PLUS; ppcM.modeCav=MFT_MINUS; auto qmp=updateWithPicture(p,argc,argv,“--”);p=parameters.ParameterTable() pe=evolution.Pars(p) pp=particle.Pars(p) pmP=mode.ParsLossy(p,“P”) pmM=mode.ParsLossy(p,“M”) ppcP=particlecavity.ParsAlong(p,“P”) ppcM=particlecavity.ParsAlong(p,“M”) ppcP.modeCav=ModeFunctionType.PLUS ppcM.modeCav=ModeFunctionType.MINUS qmp=updateWithPicture(p,sys.argv,“--”)defining free elementsparticle::Ptr part (make(pp,qmp)); mode ::Ptr plus (make(pmP,qmp)); mode ::Ptr minus(make(pmM,qmp));part=particle.make(pp,qmp) plus = mode.make(pmP,qmp) minus= mode.make(pmM,qmp)initial conditionsauto psi(wavePacket(pp)* init(pmP)*init(pmM));psi=particle.wavePacket(pp)** mode.init(pmP)**mode.init(pmM)defining interactions & composite on the fly, and evolving the systemevolve<0>(psi, composite::make(_<1,0>(ParticleAlongCavity(plus,part,ppcP)), _<2,0>(ParticleAlongCavity(minus,part,ppcM)), _<1,2,0>(ParticleTwoModes(plus,minus,part, ppcP,ppcM))), pe);}evolve(psi, makeComposite({(1,0):ParticleAlongCavity(plus,part,ppcP), (2,0):ParticleAlongCavity(minus,part,ppcM), (1,2,0):ParticleTwoModes(plus,minus,part, ppcP,ppcM)}), pe)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.•We use several C++11 features which limits the range of supported compilers (g++ 4.7, clang++ 3.1)•Documentation, http://cppqed.sourceforge.net/Running time:Depending on the magnitude of the problem, can vary from a few seconds to weeks.

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.

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.

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.

Dynamic algorithm selection for runtime concepts

A key benefit of generic programming is its support for producing modules with clean separation. In particular, generic algorithms are written to work with a wide variety of types without requiring modifications to them. The Runtime concept idiom extends this support by allowing unmodified concrete types to behave in a runtime polymorphic manner. In this paper, we describe one implementation of the runtime concept idiom, in the domain of the C++ standard template library (STL). We complement the runtime concept idiom with an algorithm library that considers both type and concept information to maximize performance when selecting algorithm implementations. We present two implementations, one in ISO C++ and one using an experimental language extension. We use our implementations to describe and measure the performance of runtime-polymorphic analogs of several STL algorithms. The tests demonstrate the effects of different compile-time vs. run-time algorithm selection choices.

Direct address translation for virtual memory in energy-efficient embedded systems

This article presents a methodology for virtual memory support in energy-efficient embedded systems. A holistic approach is proposed, where the combined efforts of compiler, operating system, and hardware architecture achieve a significant system power reductions. The application information extracted and analyzed by the compiler is utilized dynamically by the microarchitecture and the operating system to perform energy-efficient and, for many memory references, time-deterministic address translations. We demonstrate that by using application information regarding virtual memory layout, an efficient and conflict-free translation process can be implemented through the utilization of a small hardware direct translation table (DTT) accessed in an application-specific manner. The set of virtual pages is partitioned into groups, such that for each group only a few of the least significant bits are used as an index to obtain the physical page number. We outline an efficient compile-time algorithm for identifying these groups and allocate their translation entries optimally into the DTT. The introduced hardware is minimal in terms of area, performance, and power overhead, while offering the flexibility of software programmability. This is achieved through a small set of registers and tables, which are made software accessible. We have quantitatively evaluated the proposed methodology on a number of embedded applications, including voice, image, and video processing.

A semantics for procedure local heaps and its abstractions

The goal of this work is to develop compile-time algorithms for automatically verifying properties of imperative programs that manipulate dynamically allocated storage. The paper presents an analysis method that uses a characterization of a procedure's behavior in which parts of the heap not relevant to the procedure are ignored. The paper has two main parts: The first part introduces a non-standard concrete semantics, LSL , in which called procedures are only passed parts of the heap. In this semantics, objects are treated specially when they separate the "local heap" that can be mutated by a procedure from the rest of the heap, which---from the viewpoint of that procedure---is non-accessible and immutable. The second part concerns abstract interpretation of LSL and develops a new static-analysis algorithm using canonical abstraction.

Combining flow and dependence analyses to expose redundant array accesses

The success of large-scale, hierarchical and distributed shared memory systems hinges on our ability to reduce delays resulting from remote accesses to shared data. To facilitate this, we present a compile-time algorithm for analyzing programs with doall-style parallelism to determine when read and write accesses to shared data areredundant (unnecessary). One identified, redundant remote accesses can be replaced by local accesses or eliminated entirely. This optimization improves program performance in two ways. First, slow memory accesses are replaced by faster ones. Second, the time to perform other remote memory accesses may be reduced as a result of the decreased traffic level. We also show how the information obtained through redundancy analysis can be used for other compiler optimizations such as prefetching and cache management.

Scheduling synchronous dataflow graphs for efficient looping

Synchronous dataflow (SDF) has been used to synthesize code for programmable DSPs to implement multirate and block oriented signal processing systems. However, with large block sizes, or significant sample rate changes, program memory consumption becomes a critical problem. This article develops a compile-time algorithm for scheduling SDF graphs to exploit opportunities for looping--the successive reoccurrence of identical firing patterns. Because SDF graphs allow actors to produce or consume an arbitrary number of tokens on each input or output, complicated control flow may result. Yet in static scheduling, it is desirable to execute sections of the target code within loop constructs, such as "do-while," to reduce program-memory requirements. To do this, the SDF graph is hierarchically clustered, carefully avoiding deadlock while exposing looping opportunities. Results of applying these loop-extraction algorithms show orders of magnitude of compaction for target program code space on programmable DSPs compared to in-line code.

Compile-time optimization of near-neighbor communication for scalable shared-memory multiprocessors

Scalable shared-memory multiprocessor systems are typically NUMA (nonuniform memory access) machines, where the exploitation of the memory hierarchy is critical to achieving high performance. Iterative data parallel loops with near-neighbor communication account for many important numerical applications. In such loops, the communication of partial results stresses the memory system performance. In this paper, we develop data placement schemes that minimize communication time where the near-neighbor interaction is determined by a stencil. Under a given loop partition, our compile-time algorithm partitions global data into four classes for each processor, with each class requiring specific consistency maintenance requirements. The ADAPT (Automatic Data Allocation and Partitioning Tool) system was implemented to automatically partition parallel code segments for the BBN TC2000, a scalable shared-memory multiprocessor. ADAPT caches global arrays and maintains data consistency in software through instructions that flush data from private caches. Restructuring of a fluid flow code segment by ADAPT improved performance by a factor of more than 3 on the BBN TC2000. Features in current generation pipelined processors with multiple functional units permit the overlap of memory accesses with computation. Our experiments on the BBN TC2000 show that the degree of overlap is limited by architectural parameters, such as the number of CPU registers.