Pseudoknot: A Float-Intensive Benchmark for Functional Compilers

Over 20 implementations of different functional languages are compared using one program. Aspects studied are compile time and execution time. Another important point is how the program can be modified and tuned to obtain maximal performance on each language implementation. Finally, an interesting question is whether laziness is or is not beneficial for this application. With few exceptions, the compilers take a long time to compile this program. Compilers that generate C or Lisp are much slower than those that generate native code directly. Interestingly, there is no clear distinction between the runtime performance of eager and lazy implementations when appropriate annotations are used: lazy implementations have clearly come of age for this application. The speed of C can even be approached by some implementations, but not without special measures such as strictness annotations. No implementation that has been tested actually equals the performance

[1]  Alexandru Nicolau,et al.  Parallel processing: a smart compiler and a dumb machine , 1984, SIGP.

[2]  Marc Feeley,et al.  Using Multilisp for solving constraint satisfaction problems: An application to nucleic acid 3D structure determination , 1994, LISP Symb. Comput..

[3]  Simon L. Peyton Jones,et al.  Cheap Deforestation in Practice: An Optimizer for Haskell , 1994, IFIP Congress.

[4]  D. H. Bartley,et al.  Revised4 report on the algorithmic language scheme , 1991, LIPO.

[5]  Philip Wadler,et al.  Deforestation: Transforming Programs to Eliminate Trees , 1990, Theor. Comput. Sci..

[6]  Mark P. Jones,et al.  The implementation of the Gofer functional programming system , 1994 .

[7]  Wolfram Schulte,et al.  Generating Efficient Portable Code for a Strict Applicative Language , 1991, Declarative Programming.

[8]  Niklas Röjemo,et al.  nhc-Nearly a Haskell Compiler , 1994 .

[9]  Pieter H. Hartel,et al.  Compilation of functional languages using flow graph analysis , 1994, Softw. Pract. Exp..

[10]  D. A. Turner,et al.  Miranda: A Non-Strict Functional language with Polymorphic Types , 1985, FPCA.

[11]  Bogumil Hausman Turbo Erlang: Approaching the Speed of C , 1993, ICLP-Workshops on Implementation of Logic Programming Systems.

[12]  Marinus J. Plasmeijer,et al.  Generating Efficient Code for Lazy Functional Languages , 1991, FPCA.

[13]  Robin Milner,et al.  Definition of standard ML , 1990 .

[14]  Joe Armstrong,et al.  Concurrent programming in ERLANG , 1993 .

[15]  Robert A. MacLachlan CMU Common Lisp User''s Manual , 1992 .

[16]  Simon L. Peyton Jones,et al.  Unboxed Values as First Class Citizens in a Non-Strict Functional Language , 1991, FPCA.

[17]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[18]  Xavier Leroy,et al.  Unboxed objects and polymorphic typing , 1992, POPL '92.

[19]  Philip Wadler,et al.  The Glasgow Haskell Compiler: a technical overview , 1993 .

[20]  Pierre Weis,et al.  1+1=1 : an optimizing Caml compiler , 1993 .

[21]  Xavier Leroy,et al.  Le langage Caml , 1993 .

[22]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

[23]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[24]  Berthold Hoffmann,et al.  Program Development by Specification and Transformation , 1993, Lecture Notes in Computer Science.

[25]  Wolfgang Grieskamp,et al.  OPAL: Design and Implementation of an Algebraic Programming Language , 1994, Programming Languages and System Architectures.

[26]  Marc Feeley,et al.  A parallel virtual machine for efficient scheme compilation , 1990, LISP and Functional Programming.