This paper describes the language 8 1/2 , an embedding of data-parallelism in a declarative framework.

Many tools have been developed to date that employ intensionalized identifiers, markup, or files to accomplish versioning; however, most of these tools have been localized in utility. Packages such as Lemur and IHTML have effectively applied versioning to specific systems (in the case of Lemur and IHTML, to C projects and HTML files, respectively) but were not generally applicable to projects and source-files in other programming environments. In this thesis, I will present some general tools and languages that can be used to version arbitrary projects in a structured fashion. Vmake is a make tool, similar in design to traditional make programs, but which operates on versioned source-files of arbitrary types, and which allows the target-names and dependencies of each rule to be versioned. That is to say, just as every file can exist in multiple versions, so too can each of the rules in the makefile. At every level of the resulting make tree, an intensional best-fit is made on each of the targets for a given rule, to determine which rule or file will be used for the target. Because the rule names and file names in a make program are the true identifiers of the program, Vmake can be thought of as a general, intensional, rulebased build-language. It can be used to apply versioning to any software entity that can be constructed from source files and/or shell commands. ISE, for "Intensional Sequential Evaluator", is an imperative scripting language written in the spirit of Perl, but which uses versioning for all of its identifiers, including variables, files and functions. The language has most of the flow-control and data structures of Perl and C, but allows each construct to be versioned. The basic idea of ISE is that a thread of execution carries with it a current context (or global ...

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...

We develop an eductive algorithm for the ecient implementation of Multidimensional Lucid, which includes dimensions as rst-class values. By focusing on simple multi-dimensional expressions, we develop a series of operational semantics, ultimately leading to an algorithm that should lead to ecient implementations of Lucid for a variety of physical architectures.

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.

We advocate a data-flow approach to data-parallelism to ensure both parallelism expressiveness and efficient exploitation of data-parallel applications on new massively parallel architectures. The rational of this approach is introduced in the first part of the paper. Then we develop an experimental language following these lines and sketch the techniques used to compile such a data-flow data-parallel language. Its compilation, based upon a static execution model enabling an efficient execution of programs, is introduced. 1. The Parallelism and its Expression Through Data 1.1. A Short Taxonomy of Parallelism Expression in Programming Languages The many existing models and languages for parallel programming lead to an overlap of concepts making the design of a taxonomy a hard task. However, we propose in table 1 a framework used to specify the concepts presented in this paper. Two criteria have been selected to classify the languages: the way they let the programmer express control an...

8 ½, an experimental language combining features of collection and stream oriented languages...

Iterative programs are more elegant than their recursive counterparts for many problems and can be executed more efficiently than recursive programs run in the usual way on sequential computers. Moreover, they can often be executed with low overhead on parallel computers. We propose to employ bounded quantifications as an explicit iteration construct for Prolog programs and show that they do run efficiently on both sequential and data parallel computers. We increase the usefulness of our approach by showing how the iteration in an interesting class of recursive programs can be made explicit by transformation to bounded quantification programs. 1 INTRODUCTION The main thesis proposed and defended in this article is that iteration, in particular definite iteration, can be run more efficiently than general recursion also for logic programs, and that this should be exploited. A second point, which we have already developed elsewhere [5], is that including an explicit definite i...