Guy-René Perrin

Calculus of space-optimal mappings of systolic algorithms on processor arrays

We present a method to find mappings of systolic algorithms that use the minimal number of processors. This method is based on geometrical interpretations on the convex polyhedra in Zn. We use our results to derive two space-optimal mappings for the Gaussian elimination algorithm.

Geometrical tools to map systems of affine recurrence equations on regular arrays

We propose a method based on geometrical tools to map problems onto regular and synchronous processor arrays. The problems we consider are defined by systems of affine recurrence equations (SARE). From such a problem specification we extract the data dependencies in terms of two classes of vectors: the utilization vectors and the dependence vectors. We use these vectors to express constraints on the timing or the allocation functions. We differentiate two classes of constraints. The causal ones are intrinsic timing constraints induced by the system of equations defining the problem. A given choice of target architecture may impose new constraints on the timing or the allocation. We call them the architecture-related constraints. We use these constraints to determine first an affine timing function and next an allocation by projection. We finally illustrate the method with three examples: the matrix multiplication, the recursive convolution and the LLt Cholesky factorization.

Synthesis of Systolic arrays for Inductive Problems

We present a method for the synthesis of systolic arrays from a system of recurrent equations of a problem. The class of solved problems involves the inductive ones. For an inductive problem, the result sequence is calculated using its own elements : after its calculation, each element of this sequence is used as a data for other elements calculations. Therefore, the systolic arrays solutions are characterized by a ‘reinjection’ of each element of the result sequence in a data stream after its calculation.

Optimal mapping of systolic algorithms by regular instruction shifts

This paper addresses the problem of determining efficient mappings of systems of affine recurrence equations into regular arrays, in a nearly space-optimal fashion. A new nonlinear allocation technique is presented: the Instruction Shift. It allows to synthesize planar regular arrays without increasing the initial linear schedule. This technique is illustrated with the LL/sup t/ Cholesky factorization.<<ETX>>

PEI: A language and its refinement calculus for parallel programming☆

Abstract The aim of this paper is to introduce a new modeling, using symbols and functional notations, called the language PEI (as Parallel Equations Interpretor), which could unify the classical approaches of program parallelization, according to the sorts of problems and the target computation schemes. Due to its fundamental structure, disconnected from concrete drawings, this modeling offers a straightforward generalization to adress convex or non-convex computation domains, synchronous or asynchronous computations. This sort of programming formalism allows a powerful structuration of statements and a stepwise tranformation technique based on a semantical equivalence definition and a refinement calculus. From initial problem statements, transformations of expressions lead to various definition structures, which can match given computation models.

A geometrical coding to compile affine recurrence equations on regular arrays

The paper is devoted to the problem of mapping algorithms onto regular and synchronous processor arrays. The authors consider problems which are defined by Systems of Affine Recurrence Equations. From such statements, a geometrical coding is proposed to express the data dependencies in terms of two classes of vectors: the generating vectors and the inductive vectors. These vectors are used to implement constraints on the timing or the allocation functions. The authors differentiate two classes of constraints: the causal ones induced by the system of equations and the architecture-related ones. These constraints are taken into account to compile affine timing functions and allocations by projection. The authors illustrate these tools with the examples of the Gaussian elimination and the recursive convolution.<<ETX>>

Synthesis of size-optimal toroïdal arrays for the algebraic path problem : a new contribution

Abstract In this paper we present the main ideas of a general mapping method for systolic algorithms. We focus on particular target architectures: the 2D toroidal arrays. To illustrate the method we consider the Algebraic Path Problem for which size-optimal mappings can be determined.

PEI: a simple unifying model to design parallel programs

A lot of programming models have been proposed to deal with parallelism in order to express program transformations and refinements. This justifies to introduce an unifying theory to abstract different concepts. The aim of this paper is to introduce such a theory. This theory includes the definitions of problems, programs and transformation rules. It is founded on the simple mathematical concepts of multiset and of an equivalence between their representations as data fields. Program transformations are founded on this equivalence and defined from a refinement relation. Due to the unifying aspect of this theory, solutions that can be reached by these transformations are relevant to various synchronous or asynchronous computing models.

Refinement of data parallel programs in PEI

Parallel programs mainly differ from sequential ones in that they include geometrical aspects involved by the hardware architecture. We present in this paper the PEI formalism, which enables to take into account both the geometrical and functional aspects of programs. It provides a refinement calculus mainly used to transform the geometrical characteristics of parallel programs, and we show how it may apply on data parallel programs, in particular for data alignments.

Reduction in PEI

Reduction is one of the major issues in data parallel languages: it can be defined as a rule of program refinement. This article presents a theoretical framework, called Pei, the foundation of a formalism for parallel programming, where this rule can easily be expressed and applied. This formalism is founded on a small but powerful set of primitives: they are three operations on data fields and inverse operations. They induce a clear refinement calculus to transform specifications in executable programs by ensuring a safe process of design or optimization. We show how this approach allows to generalize the classical notion of reduction, by introducing a geometrical reduction and a functional one.