Fixing Letrec: A Faithful Yet Efficient Implementation of Scheme's Recursive Binding Construct

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

2013

Self Cite

Contemporary compilers must typically handle sophisticated highlevel source languages, generate efficient code for multiple hardware architectures and operating systems, and support source-level debugging, profiling, and other program development tools. As a result, compilers tend to be among the most complex of software systems. Nanopass frameworks are designed to help manage this complexity. A nanopass compiler is comprised of many singletask passes with formally defined intermediate languages. The perceived downside of a nanopass compiler is that the extra passes will lead to substantially longer compilation times. To determine whether this is the case, we have created a plug replacement for the commercial Chez Scheme compiler, implemented using an updated nanopass framework, and we have compared the speed of the new compiler and the code it generates against the original compiler for a large set of benchmark programs. This paper describes the updated nanopass framework, the new compiler, and the results of our experiments. The compiler produces faster code than the original, averaging 15-27% depending on architecture and optimization level, due to a more sophisticated but slower register allocator and improvements to several optimizations. Compilation times average well within a factor of two of the original compiler, despite the slower register allocator and the replacement of five passes of the original 10 with over 50 nanopasses.

Section: Workings Of the Existing Chez Scheme Compilermentioning

confidence: 99%

Section: Workings Of the Existing Chez Scheme Compilermentioning

confidence: 99%

A nanopass framework for commercial compiler development

Keep

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

2013

Self Cite

“…Next, we partition the bindings into strongly connected components, producing one letrec expression for each [9,19]. g and h are mutually recursive, and, thus, must be bound by the same letrec expression, while f and q each get their own.…”

Section: Examplementioning

confidence: 99%

Optimizing closures in O(0) time

Keep¹,

Hearn

Proceedings of the 2012 Annual Workshop on Scheme and Functional Programming

2012

Self Cite

The flat-closure model for the representation of first-class procedures is simple, safe-for-space, and efficient, allowing the values or locations of free variables to be accessed with a single memory indirect. It is a straightforward model for programmers to understand, allowing programmers to predict the worst-case behavior of their programs. This paper presents a set of optimizations that improve upon the flat-closure model along with an algorithm that implements them, and it shows that the optimizations together eliminate over 50% of run-time closure-creation and free-variable access overhead in practice, with insignificant compile-time overhead. The optimizations never add overhead and remain safe-for-space, thus preserving the benefits of the flat-closure model.

“…For example, let is not included among the core forms because expanding let to an application of a direct procedure does not lose any information, and we expect that optimizing compilers know how to treat them efficiently. On the other hand, letrec is included because expanding letrec to the equivalent set of bindings and assignments loses information, and would therefore inhibit certain optimizations (Waddell et al 2005).…”

Section: Core Formsmentioning

confidence: 99%

Implicit phasing for R6RS libraries

Ghuloum

2007

SIGPLAN Not.

Self Cite

The forthcoming Revised 6 Report on Scheme differs from previous reports in that the language it describes is structured as a set of libraries. It also provides a syntax for defining new portable libraries. The same library may export both procedure and hygienic macro definitions, which allows procedures and syntax to be freely intermixed, hidden, and exported.This paper describes the design and implementation of a portable version of R 6 RS libraries that expands libraries into a core language compatible with existing R 5 RS implementations. Our implementation is characterized by its use of inference to determine when the bindings of an imported library are needed, e.g., run time or compile time, relieving programmers of the burden of declaring usage requirements explicitly.