% % (Compiled by) 1993 % % Wolfgang Schreiner % Research Institute for Symbolic Computation (RISC-Linz) % Johannes Kepler University, A-4040 Linz, Austria % % PLEASE DO NOT REMOVE THIS NOTICE. % @mastersthesis{Schr90, author = {Schreiner, Wolfgang}, title = {{ADAM {\&} EVE --- An Abstract Dataflow Machine and Its Programming Language}}, year = {1990}, month = {October}, school = {RISC-Linz, Johannes Kepler University}, address = {Linz, Austria}, note = {Also: Technical Report 90-42.0, RISC-Linz, Johannes Kepler University, Linz, Austria. Also: Technical Report 91-1, Austrian Center for Parallel Computation.}, abstract = { This thesis describes the design and the implementation of the ADAM Abstract Dataflow Machine and the functional programming language EVE that will be used for programming this machine. ADAM is an abstract parallel computer with a hybrid distributed memory architecture that combines features from register machines and from dataflow computers. Its processor has a rather conventional set of two-address instructions augmented by primitives for the creation and synchronization of parallel tasks that allow the simulation of dataflow behavior. Special memory units on each ADAM module are responsible for the management of non-strict data structures. EVE is a simple purely functional language that shows most of the features known in functional programming: strong typing, higher order functions, non-strict functions and data types. A prototype of the ADAM concept has been implemented on a multi-transputer system and shows very promising results.}, keywords = {Abstract Machine, Dataflow, Controlflow}, } @inproceedings{Schr91, author = {Schreiner, Wolfgang}, title = {{ADAM --- An Abstract Dataflow Machine and Its Transputer Implementation}}, booktitle = {{Distributed Memory Computing, 2nd European Conference, EDMCC2}}, address = {Munich, Germany, April 22--24}, year = {1991}, pages = {392--401}, volume = {487}, series = {Lecture Notes in Computer Science}, publisher = {Springer, Berlin}, note = {Also: Technical Report 90-53, RISC-Linz, Johannes Kepler University, Linz, Austria. Also: Technical Report 91-3, Austrian Center for Parallel Computation.}, abstract = {This paper describes the design of the ADAM \underline{A}bstract \underline{Da}taflow \underline{M}achine. This abstract machine has a hybrid distributed-memory architecture combining features from conventional register machines and from dataflow computers. The ADAM processor has a conventional instruction set augmented by primitives for the creation and synchronization of parallel tasks. Memory units on each ADAM module are responsible for the management of non-strict data structures. A prototype implementation of the concept on a multi-transputer system shows promising speed-ups.}, keywords = {Abstract Machine, Dataflow, Controlflow}, } @inproceedings{Schr92d, author = {Schreiner, Wolfgang}, title = {{On the Automatic Parallelizaton of List-Based Functional Programs}}, booktitle = {Third International Workshop on Compilers for Parallel Computers}, address = {Vienna, Austria, July 6--9}, publisher = {Austrian Center for Parallel Computation Technical Report Series ACPC/TR 92-8}, pages = {44-57}, year = {1992}, abstract = { We investigate the behavior of functional programs operating on list structures with respect to automatic parallelization. Many list-processing functions follow typical patterns of recursion that contain inherent {\it horizontal parallelism\/}, {\it data parallelism\/}, {\it vertical parallelism\/} and {\it stream parallelism\/}. Starting from a simple classification of list-processing functions, more and more general versions of functional patterns are presented and it is shown how they cover many concrete programs. The operational behavior of these functional patterns in a parallel environment is discussed and criteria are presented that allow the automatic classification of functional programs.}, keywords = {Streams, Data Parallelism}, } @inproceedings{Schr90n, author = {Wolfgang Schreiner}, title = {{The {\sc Adam} Abstract Dataflow Machine}}, booktitle = {Parallelization in Inference Systems}, address ={Dagstuhl Castle, Germany, December 17--18}, year = {1990}, editor = {Furbach, Ulrich and Suttner, Christian and Fronh{\"o}fer, Bertram}, volume = {590}, series = {Lecture Notes in Artificial Intelligence}, pages = {270--290}, publisher = {Springer, Berlin}, abstract = { This paper describes the design and implementation of the ADAM \underline{A}bstract \underline{Da}taflow \underline{M}achine. This abstract machine has a hybrid distributed-memory architecture combining features from conventional register machines and from dataflow computers. The ADAM processor has a conventional two-address instruction set augmented by primitives for the creation and synchronization of parallel tasks that allow the simulation of dataflow behavior. Special memory units on each ADAM module are responsible for the management of non-strict data structures. The system will be programmed in the non-strict functional (dataflow) programming language EVE that will be compiled to ADAM machine code. A prototype implementation of the concept on a multi-transputer system shows promising speed-ups.}, keywords = {Abstract Machine, Dataflow, Controlflow}, } @mastersthesis{Loid92, author = {Loidl, Hans Wolfgang}, title = {{A Parallelizing Compiler for the Functional Programming Language EVE}}, month = {May}, year = {1992}, school = {RISC-Linz}, address = {Johannes Kepler University, Linz, Austria}, note = {Also: Technical Report 92-30, RISC-Linz, Johannes Kepler University, Linz, Austria}, abstract = {This thesis describes the design and implementation of an automatically parallelizing compiler for the purely functional programming language EVE. The target language of the compilation process is the assembler code of the abstract dataflow machine ADAM that has been implemented in the frame of another thesis. In this compilation process dataflow graphs are used as an intermediate language. These dataflow graphs must then be translated into a controlflow program with explicit statements for creating and synchronizing parallel threads of control. A prototype version of the EVE compiler is running.}, keywords = {Compilation, Dataflow, Controlflow}, } @techreport{Loid92a, author = {Loidl, Hans Wolfgang}, title = {{Circular Programs on Compound Data Structures}}, number = {92-06}, institution = {RISC-Linz}, address = {Johannes Kepler University, Linz, Austria}, year = {1992}, month = {January}, abstract = {A circular program creates a data structure whose computation depends upon (parts of) the structure itself. This paper provides a survey of what has been published about circular programs during the last years. So, in this paper it is shown that a non-strict semantics and local recursion are necessary properties of the underlying functional language. Furthermore, it will be shown that circular programs can have a better efficiency (e.g.\ by avoiding the production of intermediate temporary structures or by being able to traverse a compound data structure only once) than conventional programs. As the termination of a circular program is by no means obvious, a strategy will be outlined how to prove if every element of a list that is defined by a circular program can be computed in finite time.}, keywords = {Circular Programs, Streams}, } @inproceedings{Loid92c, author = {Loidl, Hans Wolfgang}, title = {{A Parallelizing Compiler for the Functional Programming Language EVE (Extended Abstract)}}, booktitle = {Proceedings of the 1st Austrian-Hungarian Workshop on Transputer Applications}, address = {Sopron, Hungary, October 8--10}, editor = {Ferenczi, Szabolcs}, series = {Technical Report Series of the Hungarian Academy of Sciences Central Research Insitute for Physics}, number = {KFKI-1992-34/M,N}, year = {1992}, pages = {1--10}, abstract = {This paper describes the compilation process from the non-strict functional programming language EVE to the assembler code of the abstract hybrid dataflow/controlflow machine ADAM. In this compilation process dataflow graphs are used as an intermediate language. However, the resulting assembler code is a controlflow program that simulates the behavior of the dataflow graph. The non-strict semantics of EVE ensures that it contains maximal inherent parallelism. The target language of the compilation process is ADAM assembler code which is essentially a controlflow code that is augmented with instructions for explicit creation and synchronization of parallel tasks. The compiler is written in Modula-2 and runs on a PC.}, keywords = {Compilation, Dataflow, Controlflow}, } @techreport{Schr93x, author = {Schreiner, Wolfgang}, title = {{Parallel Functional Programming --- An Annotated Bibliography}}, institution = {RISC-Linz}, address = {Johannes Kepler University, Linz, Austria}, month = {March}, year = {1993}, abstract = { This bibliography cites and comments more than 350 publications on the parallel functional programming research of the last 15 years. It focuses on the software aspect of this area i.e.\ on languages, compile-time analysis techniques (in particular for strictness and weight analysis), code generation, and runtime systems. Excluded from this bibliography are publications on special architectures and on garbage collection unless they contain aspects interesting for above areas. Most bibliographic items are listed inclusive their full abstracts. }, keywords = {Bibliography}, }