Martin Griebl

Index set splitting

There are many algorithms for the space-time mapping of nested loops. Some of them even make the optimal choices within their framework. We propose a preprocessing phase for algorithms in the polytope model, which extends the model and yields space-time mappings whose schedule is, in some cases, orders of magnitude faster. These are cases in which the dependence graph has small irregularities. The basic idea is to split the index set of the loop nests into parts with a regular dependence structure and apply the existing space-time mapping algorithms to these parts individually. This work is based on a seminal idea in the more limited context of loop parallelization at the code level. We elevate the idea to the model level (our model is the polytope model), which increases its applicability by providing a clearer and wider range of choices at an acceptable analysis cost. Index set splitting is one facet in the effort to extend the power of the polytope model and to enable the generation of competitive target code.

Code generation in the polytope model

Automatic parallelization of nested loops, based on a mathematical model, the polytope model, has been improved significantly over the last decade: state-of-the-art methods allow flexible distributions of computations in space and time, which lead to high-quality parallelism. However, these methods have not found their way into practical parallelizing compilers due to the lack of code generation schemes which are able to deal with the new-found flexibility. To close this gap is the purpose of this paper.

Automatic code generation for distributed memory architectures in the polytope model

The polytope model has been used successfully as a tool for program analysis and transformation in the field of automatic loop parallelization. However, for the final step of automatic code generation, the generated code is either only usable on shared memory architectures or severely restricts the parallelization methods that can be applied. In this paper, we present a fully automated method for generating efficient target code, which is executable on clusters that are based on a distributed memory architecture. We also provide speedup results of experiments on a local cluster

Forward communication only placements and their use for parallel program construction

The context of this paper is automatic parallelization by the space-time mapping method. One key issue in that approach is to adjust the granularity of the derived parallelism. For that purpose, we use tiling in the space and time dimensions. While space tiling is always legal, there are constraints on the possibility of time tiling, unless the placement is such that communications always go in the same direction (forward communications only). We derive an algorithm that automatically constructs an FCO placement – if it exists. We show that the method is applicable to many familiar kernels and that it gives satisfactory speedups.

The Loop Parallelizer LooPo-Announcement

1 What is LooPo? LooPo is a new loop parallelizing framework developed at the University of Passau to aid us in research on the space-time mapping of loop nests. LooPo is available on the Web 10] and uses only free software. It runs under SunOS 4.1.x, Solaris 2.x, and Linux. LooPo is based on the polytope model 8]. Anybody interested in one special aspect of the parallelization can plug his/her own module into LooPo and obtai a customized source-to-source compilation environment. The central data structures (restricting the applicability of LooPo) are|according to the model| polyhedra and piecewise aane functions. The next major version will also have the capability of parallelizing loop nests containing while loops 9]. 2 The Structure of LooPo LooPo consists of a number of modules, listed below, which transform the source program to an executable parallel target program. A front end provides the user with a graphical interface by which he/she can control LooPo. There is also a graphical displayer of index spaces and iteration dependence graphs of loop nests. The input. LooPo accepts (possibly imperfect) loop nests in C, Fortran or a number of abstract loop notations, and declarations of functions, procedures and symbolic constants. The inequality solvers. We considered several methods for parametric linear programming, which is the central mathematical problem of the polyhe-dron model 10]. The current implementation of LooPo is based on PIP and Fourier-Motzkin. Fourier-Motzkin is the standard doubly exponential method of polytope projection 1]. PIP is Feautriers system for parametric integer programming 3]. The dependence analyzer. At present, LooPo features the dependence analysis method described by Banerjee 1]. We are working on the implementation of Feautriers method 4], which allows potentially for more parallelism, due to a more precise analysis. The schedulers. Presently, LooPo provides three automatic schedulers. The hyperplane method of Lamport 7] handles perfectly nested for loops with uniform dependences. The Feautrier scheduler 5] determines an optimal (concave) schedule for imperfectly nested for loops with aane dependences, at the cost of a longer computation time caused by parametric integer linear programming 3]. The scheduler of Darte/Vivien 2] is fast and produces reasonably good results for arbitrary loop programs with uniform and non-uniform dependences. The allocator. Presently, LooPo provides only Feautriers allocation method 6] which determines the placement of operations on virtual processors based on the owner computes rule. The target code generator. The target code generation proceeds in three …

Generation of Synchronous Code for Automatic Parallelization of while Loops

Automatic parallelization of imperative programs has focused on nests of do loops with affine bounds and affine dependences, because in this case execution domains and dependences can be precisely known at compile-time. When dynamic control structures, such as while loops, are used, existing methods for conversion to single-assignment form and domain scanning are inapplicable. This paper gives an algorithm to automatically generate parallel code, together with an algorithm to possibly convert the program to single-assignment form.

Space–time mapping and tiling: a helpful combination

Tiling is a well‐known technique for sequential compiler optimization, as well as for automatic program parallelization. However, in the context of parallelization, tiling should not be considered as a stand‐alone technique, but should be applied after a dedicated parallelization phase, in our case after space–time mapping. We show how tiling can benefit from space–time mapping, and we derive an algorithm for computing tiles which can minimize the number of communication startups, taking the number of physically available processors into account. We also present how the use of a simple cost model reduces real execution time. Copyright

On the parallelization of loop nests containing while loops

Recently, efforts have been made to devise automatic methods, based on a mathematical model, for the parallelization of loop nests with while loops. These methods are extensions of methods for the parallelization of nested for loops. As we present the theory, the parallelization of a nest of d loops is guaranteed to lay out one loop in time and d-l loops in space (one can trade off additional dimensions from space to time). The spacetime complexity of the target loop nest is equal to the time complexity of the source loop nest (whose space complexity is constant).<<ETX>>

ON THE SPACE-TIME MAPPING OF WHILE-LOOPS

A WHILE-loop can be viewed as a FOR-loop with a dynamic upper bound. The computational model of polytopes is useful for the automatic parallelization of FOR-loops. We investigate its potential for the parallelization of WHILE-loops.

Quantifier elimination in automatic loop parallelization

Abstract We present an application of quantifier elimination techniques in the automatic parallelization of nested loop programs. The technical goal is to simplify affine inequalities whose coefficients may be unevaluated symbolic constants. The values of these so-called structure parameters are determined at run time and reflect the problem size. Our purpose here is to make the research community of quantifier elimination, in a tutorial style, aware of our application domain–loop parallelization–and to highlight the role of quantifier elimination, as opposed to alternative techniques, in this domain. Technically, we focus on the elimination method of Weispfenning.