Programs and systems of recurrence equations may be represented as sets of actions which are to be executed subject to precedence constraints. In many cases, actions may be labelled by integral vectors in some iteration domain, and precedence constraints may be described by affine relations. A schedule for such a program is a function which assigns an execution date to each action. Knowledge of such a schedule allows one to estimate the intrinsic degree of parallelism of the program and to compile a parallel version for multiprocessor architectures or systolic arrays. This paper deals with the problem of finding closed form schedules as affine or piecewise affine functions of the iteration vector. An efficient algorithm is presented which reduces the scheduling problem to a parametric linear program of small size, which can be readily solved by an efficient algorithm.

: 81/2 is a declarative data-parallel language designed for the simulation of large dynamical systems. Such simulations are of growing importance and they requires more and more computing power. In consequence, 81/2 introduces a new entity, the web, that combines features of collection-oriented and data-flow language to express data-, stream- and control-parallelism. In this paper, we present the language 81/2, some examples of dynamical systems programmed in 81/2 and we describe the compilation process of a 81/2 programme. Key-words: data-parallelism, collection-oriented languages, declarative languages, synchronous data-flow languages, simulation of dynamical systems. I. Introduction Nowadays, simulation of large dynamical systems represents the majority of supercomputers applications. In this article, a dynamical system refers as any application that modelizes space-time phenomena. Three usual examples are: . numerical resolution of partial differential equations [1] describing con...

81/2 is a data-parallel language that relies on the notions of stream and collection in a high-level declarative framework. We describe in this research report semantics and compilation of sequential streams of collections for this language. Firstly, a denotational semantics is associated with recursively defined sequential 81/2 streams. Furthermore, we explain how the fixed point calculus corresponding to the foregoing semantics is implemented. Secondly, we describe an effective code generation scheme targetted towards either sequential, vector or SIMD architectures. Then we present four optimization processes for the generated code: the sharing of common control expressions, the optimization of delay copies, the loop fusion and the concatenation optimization. Next, some elements for the evaluation of the generated code are given. As a conclusion, we recall the overall effectiveness of the stream compilation and draw the future work. Key-words: stream, compilation of data-flow graphs...

this paper, we address the problem of names and name capture on its own by designing, through the use of three operators, a complete and consistent mechanism of name capture for a declarative framework. We perceive expressions with free names as incomplete expressions which will be dynamically completed by a name capture mechanism. The formalism allows the denition of rst-class environments (which can be the result of a computation). We apply this mechanism to model distributed incremental program construction and to dene an object oriented programming style in a declarative language

Recursive definition of streams (infinite lists of values) have been proposed as a fundamental programming structure in various fields. A problem is to turn such expressive recursive definitions into an efficient imperative code for their evaluation. One of the main approach is to restrict the stream expressions to interpret them as a temporal sequence of values. Such sequential stream rely on a clock analysis to decide at what time a new stream value must be produced. In this paper we present a denotational semantics of recursively defined sequential streams. We show how an efficient implementation can be derived as guarded statements wrapped into a single imperative loop.

The data flow concept of computation seeks to achieve high performance by allowing concurrent execution of instructions based on the availability of data. This thesis explores the translation of a subset of the high level language VAL tO data flow graphs. The major problem in performing this translation for the target machine. the i)ennis-Misunas data flow computer, stems from the restriction that graph execution sequences place at most one value on any given arc at any time. The data/acknowledge art' pair transformation is intrMuced as a means of implementing this required operational behavior. its effect on data flow graph operation is subsequently explored as it relates to correctness ald performance.