Markus Schordan

A Source-To-Source Architecture for User-Defined Optimizations

We present an architecture for the specification of source-to-source transformations. New source code can be specified as source-fragments. The translation of source-fragments to the intermediate representation is accomplished by invoking the frontend. For any inserted fragment we can guarantee that it is typed correctly. If no error is reported on inserted fragments, the whole program can always be compiled without errors. Based on a given abstract attribute grammar the user can specify transformations as semantic actions and can combine the computation of attributes with restructure operations on the intermediate representation.

Parallel object-oriented framework optimization

Sophisticated parallel languages are difficult to develop; most parallel distributed memory scientific applications are developed using a serial language, expressing parallelism through third party libraries (e.g. MPI). As a result, frameworks and libraries are often used to encapsulate significant complexities. We define a novel approach to optimize the use of libraries within applications. The resulting tool, named ROSE, leverages the additional semantics provided by library‐defined abstractions enabling library specific optimization of application codes. It is a common perception that performance is inversely proportional to the level of abstraction. Our work shows that this is not the case if the additional semantics can be leveraged. We show how ROSE can be used to leverage the semantics within the compile‐time optimization. Copyright

Semantic-Driven Parallelization of Loops Operating on User-Defined Containers

We describe ROSE, a C++ infrastructure for source-to-source translation, that provides an interface for programmers to easily write their own translators for optimizing the use of high-level abstractions. Utilizing the semantics of these high-level abstractions, we demonstrate the automatic parallelization of loops that iterate over user-defined containers that have interfaces similar to the lists, vectors and sets in the Standard Template Library (STL). The parallelization is realized in two phases. First, we insert OpenMP directives into a serial program, driven by the recognition of the high-level abstractions, containers, that are thread-safe. Then, we translate the OpenMP directives into library routines that explicitly create and manage parallelism. By providing an interface for the programmer to classify the semantics of their abstractions, we are able to automatically parallelize operations on containers, such as linked-lists, without resorting to complex loop dependence analysis techniques. Our approach is consistent with general goals within telescoping languages.

The specification of source-to-source transformations for the compile-time optimization of parallel object-oriented scientific applications

The performance of object-oriented applications in scientific computing often suffers from the inefficient use of high-level abstractions provided by underlying libraries. Since these library abstractions are user-defined and not part of the programming language itself there is no compiler mechanism to respect their semantics and thus to perform appropriate optimizations. In this paper we outline the design of ROSE and focus on the discussion of two approaches for specifying and processing complex source code transformations. These techniques are intended to be as easy and intuitive as possible for potential ROSE users; i.e., for designers of object-oriented scientific libraries, people most often with no compiler expertise.

Treating a user-defined parallel library as a domain-specific language

The software crisis within scientific computing has been that application codes become larger and more complex. The only conceivable solution is to make application codes smaller and less complex. We know of no way to resolve this crisis, except to make each line of code mean more; this is the process of defining high-level abstractions. Achieving high-performance from high-level abstractions represents an essential key to simplifying scientific software.This paper presents several high-level abstractions used within scientific computing. These abstractions are part of multiple object-oriented libraries and represent complex and precise semantics. In each case the semantics of the abstraction is user-defined and ignored by the compilation process at a significant performance penalty for the application code. Our research work presents a mechanism to analyze and optimize the use of high-level abstractions within scientific applications. In this paper, we show that the high-level abstractions are not just significantly easier to use in the development of application code but can be made to perform equivalently to hand-coded C and Fortran. Our research work shows how to effectively treat any object-oriented library and its abstractions as if it where a domain-specific language with equivalent builtin types and specialized compile-time analysis and optimizations. With acceptable performance of high-level abstractions within scientific software, we expect that application codes can be made smaller and less complex; allowing much more complex applications to be built in the future.

Reverse Code Generation for Parallel Discrete Event Simulation

Reverse computation has become a central notion in discrete event simulation over the last decade. It is not just a theoretical line of research, but an immensely practical one that is necessary to achieve high performance for large parallel discrete event simulations (PDES). The models that are implemented for PDES are of increasing complexity and size and require various language features to support abstraction, encapsulation, and composition when building a simulation model. In this paper we focus on parallel simulation models that are written in C++ and present an approach for automatically generating reverse code for C++. The strategy we have adopted for our approach is to first assure that we can correctly handle event methods that use the entire C++ language. Although a significant runtime overhead is introduced with our technique, the assurance that the reverse code is always generated fully automatically is an enormous win that can open the door to routine optimistic simulation with models that can be implemented using the entire C++ language.

Verification of Polyhedral Optimizations with Constant Loop Bounds in Finite State Space Computations

As processors gain in complexity and heterogeneity, compilers are asked to perform program transformations of ever-increasing complexity to effectively map an input program to the target hardware. It is critical to develop methods and tools to automatically assert the correctness of programs generated by such modern optimizing compilers.

A C++ infrastructure for automatic introduction and translation of OpenMP directives

In this paper we describe a C++ infrastructure for source-to-source translation. Wedemonstrate the translation of a serial program with high-level abstractions to a lower-level parallel program in two separate phases. In the first phase OpenMP directives are introduced, driven by the semantics of high-level abstractions. Then the OpenMP directives are translated to a C++ program that explicitly creates and manages parallelism according to the specified directives. Both phases are implemented using the same mechanisms in our infrastructure.

Classification and utilization of abstractions for optimization

We define a novel approach for optimizing the use of libraries within applications. We propose that library-defined abstractions be annotated with additional semantics to support their automated optimization. By leveraging these additional semantics we enable specialized optimizations of application codes which use library abstractions. We believe that such an approach entails the use of formal methods. It is a common perception that performance is inversely proportional to the level of abstraction. Our work shows that this is not the case if the additional semantics of library-defined abstractions can be leveraged. We describe ROSE, a framework for building source-to-source translators that perform high-level optimizations on scientific applications. ROSE allows the recognition of library abstractions and the optimization of their use in applications. We show how ROSE can utilize the semantics of user-defined abstractions in libraries within the compile-time optimization of applications.

ALL-TIMES – A European Project on Integrating Timing Technology

ALL-TIMES is a research project within the EC 7th Framework Programme. The project concerns embedded systems that are subject to safety, availability, reliability, and performance requirements. Increasingly, these requirements relate to correct timing. Consequently, the need for appropriate timing analysis methods and tools is growing rapidly. An increasing number of sophisticated and technically mature timing analysis tools and methods are becoming available commercially and in academia. However, tools and methods have historically been developed in isolation, and the potential users are missing a process-related and continuous tool- and methodology-support. Due to this fragmentation, the timing analysis tool landscape does not yet fully exploit its potential.