Polyhedra are geometric representations of linear systems of equations and inequalities. Since polyhedra are used to represent the iteration domains of nested loop programs, procedures for operating on polyhedra are useful for doing loop transformations and other program restructuring transformations which are needed in parallelizing compilers. Thus a need for a library of polyhedral operations has recently been recognized in the parallelizing compiler community. Polyhedra are also used in the definition of domains of variables in systems of affine recurrence equations (SARE). Alpha is a language which is based on the SARE formalism in which all variables are declared over finite unions of polyhedra. This report describes a library of polyhedral functions which was developed to support the Alpha language environment, and which is general enough to satisfy the needs of researchers doing parallelizing compilers. This report describes the data structures used to represent domains, gives...

Synchronous data-flow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory data-flow networks. In particular, these networks are not recursively defined, and obey some kind of "synchronous" constraints (clock calculus). Based on Kahn's relationship between data-flow and stream functions, the synchronous constraints can be related to Wadler's listlessness, and can be seen as sufficient conditions ensuring listless evaluation. As a by-product, those networks enjoy efficient compiling techniques. In this paper, we show that it is possible to extend the class of static synchronous data-flow to higher order and dynamical networks, thus giving sense to a larger class of synchronous data-flow networks.

We report our current research in a computer assisted methodology for synthesizing regular array processors using the Alpha language and design environment. The design process starts from an algorithmic level description of the function and finishes with a netlist of an array processor which performs the specified function. To illustrate the proposed approach, we present the design of an array processor to do polynomial division.

In the context of developing a compiler for a Alpha, a functional dataparallel language based on systems of affine recurrence equations (SAREs), we address the problem of transforming scheduled single-assignment code to multiple assignment code. We show how the polyhedral model allows us to statically compute the lifetimes of program variables, and thus enables us to derive necessary and sufficient conditions for reusing memory. 1. Introduction The methodology of automatic systolic array synthesis from Systems of Affine Recurrence Equations (SAREs) has a close bearing on parallelizing compilers and on efficient implementation of functional languages. To study this relationship, we are currently developing a compiler for Alpha [9], a functional, data parallel language based on SAREs defined over polyhedral index domains. The language semantics directly lead to sequential code based on demand driven evaluation. However, the resulting context switches can be avoided if the program is tra...

This report is a formal description of the Alpha language, as it is currently implemented. Alpha is a strongly typed, functional language which embodies the formalism of systems of affine recurrence equations. In this report, Alpha language constructs are described, and denotational and type semantics are given. The theorems which are the basis for doing transformations on an Alpha program are stated. And finally, the syntax and semantics of Alpha are given.

. To improve the performances of parallelizing compilers, one must detect recurrences in scientific programs and subject them to special parallelization methods. We present a method for detecting recurrences which is based on the analysis of Systems of Recurrence Equations. This method identifies recurrences on arrays, recurrences of arbitrary order and multi-equations recurrences. We explain how to associate a SRE to a restricted class of imperative programs. We present a normalization of such SRE that allows the detection of recurrences by simple inspection of equations. When detected, a recurrence may be replaced by a symbolic expression of its solution. To iterate the process can lead to the identification of multi-dimensional recurrences. 1 Introduction One of the most important challenges in present day computer science is the efficient compilation of programs for the newly emerging massively parallel architectures. In contrast of the situation for the last generation of superco...

We have been investigating problems which arise in compiling single assignment languages (in which memory is not explicitly allocated) into parallel code. Like standard parallelizing compilers, different index space transformations are performed on variables declared over convex polyhedral regions. Polyhedra can be transformed in such a way as to reduce the volume of the bounding box which we use to reduce the amount of memory allocated to a variable. Allocation of memory to variables which are defined over finite convex polyhedral regions requires a tradeoff in the complexity of the memory addressing function versus the amount of memory used. We present a tradeoff in which the memory address function is limited to an affine function of the indices (thus memory is allocated to a rectangular parallelepiped region). Given this constraint, we seek a unimodular transformation which minimizes the volume of the bounding box of the polyhedron. This is a non-linear programming problem. We pr...

In recognition of the fundamental relation between regular arrays and systems of affine recurrence equations, the Alpha language was developed as the basis of a computer aided design methodology for regular array architectures. Alpha is used to initially specify algorithms at a very high algorithmic level. Regular array architecures can then be derived from the algorithmic specification using a transformational approach supported by the Alpha environment. This design methodology guarantees the final design to be correct by construction, assuming the initial algorithm was correct. In this paper, we address the problem of validating an initial specification. We demonstrate a translation methodolody which compiles Alpha into the imperative sequential language C. The C-code may then be compiled and executed to test the specification. We show how an Alpha program can be naively implemented by viewing it as a set of monolithic arrays and their filling functions, implemented usin...

: Alpha is a data parallel functional language which has the capability of specifying algorithms at a very high level. Our ultimate objective is to generate efficient parallel imperative code from an Alpha program. In this paper, we discuss the related problem of generating efficient single processor imperative code. Analysis techniques that were developed for the synthesis of systolic arrays are extended and adapted for the compilation of functional programming languages. We also demonstrate how a transformational methodology can be used as a compilation engine to transform an Alpha program to a sequential form. C--code is then generated using a straightforward pretty printer from the sequential form Alpha program. The C--code may then be compiled to efficiently execute the program. Key-words: parallelizing compilers, functional languages (R'esum'e : tsvp) Supported by NSF grant MIP-910852 and Esprit Basic Research Action NANA2, Number 6632 email: quinton@irisa.fr email: rajopadh@...

The paper presents some solutions for the generation of HPF code from Pei specifications. We delimit the class of specifications that can be translated and we discuss the operational semantics given to these specifications. In