Sibylle Schupp

User-Extensible SimplificationType-Based Optimizer Generators

For abstract data types (ADTs) there are many potential optimizations of code that current compilers are unable to perform. These optimizations either depend on the functional specification of the computational task performed through an ADT or on the semantics of the objects defined. In either case the abstract properties on which optimizations would have to be based cannot be automatically inferred by the compiler. In this paper our aim is to address this level-of-abstraction barrier by showing how a compiler can be organized so that it can make use of semantic information about an ADT at its natural abstract level, before type lowering, inlining, or other traditional compiler steps obliterate the chance. We present an extended case study of one component of a C++ compiler, the simplifier; discuss the design decisions of a new simplifier (simplifier generator) and its implementation in C++; and give performance measurements. The new simplifier is connected to the Gnu C++ compiler and currently performs optimizations at very high level in the front end. When tested with the Matrix Template Library, a library already highly fine-tuned by hand, we achieved run-time improvements of up to six percent.

Semantic and behavioral library transformations

While software methodology encourages the use of libraries and advocates architectures of layered libraries, in practice the composition of libraries is not always seamless and the combination of two well-designed libraries not necessarily well designed, since it could result in suboptimal call sequences, lost functionality, or avoidable overhead. In this paper we introduce Simplicissimus, a framework for rewrite-based source code transformations that allows for code replacement in a systematic and safe manner. We discuss the design and implementation of the framework and illustrate its functionality with applications in several areas.

Making the Usage of STL Safe

The use of the C++ Standard Template Library has many advantages, but comes with a unique set of problems that have not been addressed by compilers or development tools. Many of these problems are due to misuses of the STL components and algorithms that are syntactically correct but semantically flawed. We motivate the case for the use of static analysis to diagnose such problems and describe our approach to checking STL usage with an STL-aware static analysis.

Garbage collection in generic libraries

This paper demonstrates a unified and garbage-collector independent way to describe the information required for precise collection. Thereby it is possible to construct, a library that can be used with various garbage collectors, without modifying the code of the library or the collector itself. The library design presented applies the adaptor idiom of generic programming which guarantees no overhead incurred if the library is used with manual allocators or with garbage collectors that do not require programmer cooperation. As an illustration of our approach we provide sample adaptors for Bartletts and CMM primary collectors. We also show that the Standard Template Library (STL) can be easily modified to become garbage-collector aware.

SUCHTHAT - Generic Programming Works

This paper introduces SUCHTHAT, a language for experiments in generic programming. SUCHTHAT forms the synthesis of two independently developed languages: Aldes, a language for algorithm descriptions, and TECTON, a specification language for generic components. The SUCHTHAT language is characterized by its support of algorithmic requirements and dependent genericity. We discuss the underlying design decisions and show that the semantic interpretation of overloading plays a key role in determining optimal instantiations.

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.

A Polymorphic Radix-n Framework for Fast Fourier Transforms

We provide a polymorphic framework for radix-n Fast Fourier Transforms (FFTs) where all known kinds of monomoporhic radix-n algorithms can be obtained by specialization. The framework is mathematically based on the Cooley-Tukey mapping, and implemented as a C++ template meta-program. Avoiding run-time overhead, all specializations are performed statically.

Lifting a butterfly - A component-based FFT

While modern software engineering, with good reason, tries to establish the idea of reusability and the principles of parameterization and loosely coupled components even for the design of performance-critical software, Fast Fourier Transforms (FFTs) tend to be monolithic and of a very low degree of parameterization. The data structures to hold the input and output data, the element type of these data, the algorithm for computing the so-called twiddle factors, the storage model for a given set of twiddle factors, all are unchangeably defined in the so-called butterfly, restricting its reuse almost entirely. This paper shows a way to a component-based FFT by designing a parameterized butterfly. Based on the technique of lifting, this parameterization includes algorithmic and implementation issues without violating the complexity guarantees of an FFT. The paper demonstrates the lifting process for the Gentleman-Sande butterfly, i.e., the butterfly that underlies the large class of decimation-in-frequency (DIF) FFTs, shows the resulting components and summarizes the implementation of a component-based, generic DIF library in C++.

Base Class Injection

Class hierarchies, though theoretically reusable, have generally not seen much practical reuse in applications, due in part to the inflexibility of the inheritance relationship. We present a technique, base class injection, that allows the creation of generative class hierarchies that may be adapted by adding new methods, data members, and ancestor classes without modification to the class library code; an implementation of this technique in the C++ language is given.

A mostly-copying collector component for class templates

Class templates represent a difficulty for C++ garbage collectors since relevant information is available only very late, at instantiation time. Current collectors therefore either fail to work with class templates or have to run in a non‐optimized mode. This paper introduces the template garbage collector (TGC), the first mostly‐copying collector that can handle class templates. It discusses the design decisions that are suggested by the specifics of generic template programming and presents performance results and memory measurements of tests with MTL and GTL, two generic C++ libraries based on the Standard Template Library. The tests show that TGC substantially improves the run times of programs with many small objects with short lifetimes or large objects with long lifetimes. The memory usage at the same time is reasonable. Since TGC modifies the mostly‐copying technique, the heap sizes are in many cases considerably smaller than they are for traditional mostly‐copying collectors. The tests also show that TGC is competitive with the Boehm–Demers–Weiser collector, the most widely used collector for C++. Copyright