Data parallelism means operating on distributed tables, data fields, in parallel. An abstract model of data parallelism treats data fields as functions explicitly restricted to a finite set. Data parallel functional languages based on this view vill reach a very high level of abstraction. In this report we consider two static analyses that, when successful, give information about the extent of a recursively defined data field. This information can be used to preallocate the data fields and map then efficiently to distributed memory, and to aid the static scheduling of operations. The analyses are cast in the framework of abstract interpretation: a forward analaysis propagates restrictions on inputs to restrictions on outputs, and a backward analysis propagates restrictions the other way. Fixpoint iteration can sometimes be used to solve the equations that arise, and we devise some cases where this is possible.

Sac is a functional C variant with efficient support for high-level array operations. This paper investigates the applicability of a Sac specific optimization technique called with-loop-folding to real world applications. As an example program which originates from the Numerical Aerodynamic Simulation (NAS) Program developed at NASA Ames Research Center, the so-called NAS benchmark MG is chosen. It comprises a kernel from the NAS Program which implements 3-dimensional multigrid relaxation. Several run-time measurements exploit two different benefits of with-loop-folding: First, an overall speed-up of about 20 % can be observed. Second, a comparison between the run-times of a hand-optimized specification and of Apl-like specifications yields identical run-times, although a naive compilation that does not apply with-loop-folding leads to slowdowns of more than an order of magnitude. Furthermore, With-loop-folding makes a slight variation of the algorithm feasible which substantially simplifies the program specification and requires less memory during execution. Finally, the optimized run-times are compared against run-times gained from the original Fortran program, which shows that for different problem sizes, the code generated from the Sac program does not only reach the execution times of the code generated from the Fortran program but even outperforms them by about 10%.

Abstract. In this paper, we propose a topological metaphor for computations: computing consists in moving through a path in a data space and making some elementary computations along this path. This idea underlies an experimental declarative programming language called mgs. mgs introduces the notion of topological collection: a set of values organized by a neighborhood relationship. The basic computation step in mgs relies on the notion of path: a path C is substituted for a path B in a topological collection A. This step is called a transformation and several features are proposed to control the transformation applications. By changing the topological structure of the collection, the underlying computational model is changed. Thus, mgs enables a unified view on several computational mechanisms. Some of them are initially inspired by biological or chemical processes (Gamma and the CHAM, Lindenmayer systems, Paun systems and cellular automata).

If functional programs are to be used for high-performance computing, efficient data representations and operations must be provided. Our contribution is a calculus for the analysis of the lengths of (nested) lists and a transformation into a form which is liberated from the chain of cons-operations and which sometimes permits array implementations even if the length depends on run-time values. A major advantage of functional programs vs. imperative programs is that dependence analysis is much easier, due to the absence of reassignments. One severe disadvantage of functional programs as of yet is that efficient, machine-oriented data structures (like the array) absolutely necessary for high-performance computing play a minor role in many language implementations since they do not harmonize with functional evaluation schemata (like graph reduction), which are at a higher level of abstraction. We propose to construct programs by composition of skeletons, i.e., functi...

We give a brief description of what we consider to be data parallel programming and processing, trying to pinpoint the typical problems and pitfalls that occur. We then proceed with a short annotated history of data parallel programming, and sketch a taxonomy in which data parallel languages can be classified. Finally we present our own model of data parallel programming, which is based on the view of parallel data collections as functions. We believe that this model has a number of distinct advantages, such as being abstract, independent of implicitly assumed machine models, and general.

This position paper describes the data field model, a general model for indexed data structures. The aim of this model is to capture the essence of the style of programming where computing on data structures is expressed by operations directly on the structures rather than operations on the individual elements. Array and and data parallel languages support this programming style, and functional languages often provide second order operations on lists and other data structures for the same purpose. The data field model is designed to be abstract enough to encompass a wide range of explicitly or implicitly indexed structures. Thus, algorithms which are expressed in terms of data fields and general operations on them will be independent of the choice of structure from this range -- i.e., generic w.r.t. this choice. This means that the data field approach has some in common with polytypic programming and the theory of shapes.

. We propose an alternate approach to the usual introduction of parallelism in logic programming. Instead of detecting the intrinsic parallelism by an automatic and complex data-flow analysis, or upgrading standard logic languages by explicit concurrent control structures leading to task-oriented languages, we tightly integrate the concepts of the data-parallel programming model and of logic programming in a kernel language, called DP-Log. It offers a simple centralized and synchronous vision to the programmer. We give this language a declarative and a distributed asynchronous operational semantics. The equivalence theorem of these semantics establishes the soundness of the implementation. The expressiveness of the language is illustrated on examples. Keywords : Logic programming --- Data-parallel languages --- Design of programming languages --- Semantics --- MIMD architectures Introduction The introduction of parallelism in programming languages enables to extend the expressiveness ...

. Most imperative languages only offer arrays as "first-class" data structures. Other data structures, especially recursive data structures such as trees, have to be manipulated using explicit control of memory, i.e., through pointers to explicitly allocated portions of memory. We believe that this severe limitation is mainly due to historical reasons, and this paper will try and demonstrate that modern analysis techniques, such as data flow analysis, allow to cope with the compilation problems associated with recursive data structures. As a matter of fact, recursion in the flow of control also is a current open issue in automatic parallelization: to our knowledge, no theory allows the parallelization of, e.g., recursive Pascal programs. This paper uniformly handles both issues. We propose a kernel language that manipulates recursive data structures in an elegant, algebraic way. In this preliminary work, both data- and control- recursive structures are restricted, so that a data flow a...

Indexed data structures are prevalent in many programming applications. Collection-oriented languages provide means to operate directly on these structures, rather than having to loop or recurse through them. This style of programming will often yield clear and succinct programs. However, these programming languages will often provide only a limited choice of indexed data types and primitives, and the exact semantics of these primitives will sometimes vary with the data type and language. In this paper we develop a unifying semantical model for indexed data structures. The purpose is to support the construction of abstract data types and language features for such structures from first principles, such that they are largely generic over many kinds of data structures. The use of these abstract data types can make programs and their semantics less dependent of the actual data structure. This makes programs more portable across different architectures and facilitates the early design phase. The model is a generalisation of arrays, which we call data fields: these are functions with explicit information about their domains. This information can be conventional array bounds but it could also define other shapes, for instance sparse. Data fields can be interpreted as partial functions, and we define a metalanguage for partial functions. In this language we define abstract versions of collection-oriented operations, and we show a number of identities for them. This theory is used to guide the design of data fields and their operations so they correspond closely to the more abstract notion of partial functions. We define phi-abstraction, a lambda-like syntax for defining data fields in a shape-independent manner, and prove a theorem which relates phi-abstraction and lambda-abstraction semantically. We also define a small data field language whose semantics is given by formal data fields, and give examples of data field programming for parallel algorithms with arrays and sparse structures, database quering and computing, and specification of symbolic drawings.

. Data fields provide a flexible and highly general model for indexed collections of data. Data Field Haskell is a Haskell dialect that provides an instance of data fields. It can be used for very generic collection-oriented programming, with a special emphasis on multidimensional structures. We give a brief description of the data field model and its underlying theory. We then describe Data Field Haskell, and an implementation. 1 Introduction Indexed data structures are important in many computing applications. The canonical indexed data structure is the array, but other indexed structures like hash tables and explicitly parallel entities are also common. In many applications the indexing capability provides an important part of the model: when solving partial differential equations, for instance, the index is often closely related to a physical coordinate, and explicitly parallel algorithms often use processor ID's as indices. Since the time of APL [5] it has been recognised ...