How much non-strictness do lenient programs require?

Lenient languages, such as Id90, have been touted as among the best functional languages for massively parallel machines [AHN88]. Lenient evaluation combines non-strict semantics with eager evaluation [Tra9 1]. Non-strictness gives these languages more expressive power than strict semantics, while eager evaluation ensures the highest degree of parallelism. Unfortunately, non-strictness incurs a large overhead, as it requires dynamic scheduling and synchronization. As a result, many powerful program analysis techniques have been developed to statically determine when non-strictness is not required [CPJ85, Tra91, Sch94]. This paper studies a large set of lenient programs and quantifies the degree of non-strictness they require. We identify several forms of non-strictness, including functional, conditional, and data structure non-strictness. Surprisingly, most Id90 programs require neither functional nor conditional non-strictness. Many benchmark programs, however, make use of a limited form of data structure non-strictness. The paper refutes the myth that lenient programs require extensive non-strictness.

[1]  Seth Copen Goldstein,et al.  Separation constraint partitioning: a new algorithm for partitioning non-strict programs into sequential threads , 1995, POPL '95.

[2]  David E. Culler,et al.  Compiler-Controlled Multithreading for Lenient Parallel Languages , 1991, FPCA.

[3]  Paul Hudak,et al.  Path Semantics , 1987, MFPS.

[4]  A. P. Wim Böhm,et al.  Analysis of non-strict functional implementations of the Dongarra-Sorensen eigensolver , 1994, ICS '94.

[5]  Seth Copen Goldstein,et al.  Evaluation of mechanisms for fine-grained parallel programs in the J-machine and the CM-5 , 1993, ISCA '93.

[6]  Zena M. Ariola,et al.  P-TAC: a parallel intermediate language , 1989, FPCA.

[7]  V. Gerald Grafe,et al.  Compile-time partitioning of a non-strict language into sequential threads , 1991, Proceedings of the Third IEEE Symposium on Parallel and Distributed Processing.

[8]  Klaus Erik Schauser,et al.  Compiling lenient languages for parallel asynchronous execution , 1994 .

[9]  Keshav Pingali,et al.  I-structures: data structures for parallel computing , 1986, Graph Reduction.

[10]  David E. Culler,et al.  Fine-grain parallelism with minimal hardware support: a compiler-controlled threaded abstract machine , 1991, ASPLOS IV.

[11]  Simon L. Peyton Jones,et al.  Strictness Analysis - A Practical Approach , 1985, FPCA.

[12]  Arvind,et al.  M-Structures: Extending a Parallel, Non-strict, Functional Language with State , 1991, FPCA.

[13]  K. R. Traub,et al.  A COMPILER FOR THE MIT TAGGED-TOKEN DATAFLOW ARCHITECTURE , 1986 .

[14]  Derek Chiou,et al.  Performance Studies of Id on the Monsoon Dataflow System , 1993, J. Parallel Distributed Comput..

[15]  Rishiyur S. Nikhil.  An Overview of the Parallel Language Id (a foundation for pH, a parallel dialect of Haskell) , 1993 .

[16]  John Hughes,et al.  Why Functional Programming Matters , 1989, Comput. J..

[17]  R. E. Hiromoto,et al.  A functional implementation of the Jacobi eigen-solver , 1993 .

[18]  I. V. Ramakrishnan,et al.  Small domains spell fast strictness analysis , 1989, POPL '90.

[19]  Arvind,et al.  Programming Generality and Parallel Computers , 1988 .

[20]  Thomas Johnsson,et al.  Attribute grammars as a functional programming paradigm , 1987, FPCA.

[21]  Lloyd Allison.  Applications of Recursively Defined Data Structures , 1993, Aust. Comput. J..

[22]  Kenneth R. Traub.  Implementation of non-strict functional programming languages , 1991, Research monographs in parallel and distributed computing.

[23]  S Sur,et al.  Eecient Declarative Programs: Experience in Implementing Nas Benchmark Ft Colorado State University Eecient Declarative Programs: Experience in Implementing Nas Benchmark Ft Address for Correspondence , 1993 .

[24]  Matthias Felleisen,et al.  On the Expressive Power of Programming Languages , 1990, European Symposium on Programming.

[25]  Seth Copen Goldstein.  Implementation of a threaded abstract machine on sequential and multiprocessors , 1994 .

[26]  Simon Peyton Jones,et al.  The Implementation of Functional Programming Languages (Prentice-hall International Series in Computer Science) , 1987 .

[27]  Pieter H. Hartel,et al.  Pseudoknot: A Float-Intensive Benchmark for Functional Compilers , 1994 .

[28]  Patrick J. Burns,et al.  Vectorization on Monte Carlo particle transport: an architectural study using the LANL benchmark “GAMTEB” , 1989, Proceedings of the 1989 ACM/IEEE Conference on Supercomputing (Supercomputing '89).

[29]  Paul Hudak,et al.  Pomset interpretations of parallel functional programs , 1987, FPCA.

[30]  Arvind,et al.  Future Scientific Programming on Parallel Machines , 1988, J. Parallel Distributed Comput..

[31]  Simon L. Peyton Jones,et al.  The Implementation of Functional Programming Languages , 1987 .

[32]  Lloyd Allison,et al.  Lazy Dynamic-Programming Can Be Eager , 1992, Inf. Process. Lett..

[33]  Rishiyur S. Nikhil.  The Parallel Programming Language Id and its Compilation for Parallel Machines , 1993, Int. J. High Speed Comput..

[34]  Guy Tremblay.  Parallel implementation of lazy functional languages using abstract demand propagation , 1996 .

[35]  Seth Copen Goldstein,et al.  TAM - A Compiler Controlled Threaded Abstract Machine , 1993, J. Parallel Distributed Comput..

[36]  Steven K Heller,et al.  Efficient Lazy Data-Structures on a Dataflow Machine , 1989 .