Structure and interpretation of computer programs
Structure and interpretation of computer programs
TIM: A simple, lazy abstract machine to execute supercombinators
Proc. of a conference on Functional programming languages and computer architecture
An abstract machine for Lambda-terms normalization
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Improving the three instruction machine
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
A natural semantics for lazy evaluation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 1992 Glasgow Workshop on Functional Programming
Definitional interpreters for higher-order programming languages
ACM '72 Proceedings of the ACM annual conference - Volume 2
A functional correspondence between evaluators and abstract machines
Proceedings of the 5th ACM SIGPLAN international conference on Principles and practice of declaritive programming
Deriving a lazy abstract machine
Journal of Functional Programming
Algol-60 Implementation
On the correctness of the Krivine machine
Higher-Order and Symbolic Computation
A tail-recursive semantics for stack inspections
ESOP'03 Proceedings of the 12th European conference on Programming
A functional correspondence between call-by-need evaluators and lazy abstract machines
Information Processing Letters
A concrete framework for environment machines
ACM Transactions on Computational Logic (TOCL)
Lazy evaluation and delimited control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
New Developments in Environment Machines
Electronic Notes in Theoretical Computer Science (ENTCS)
Defunctionalized interpreters for call-by-need evaluation
FLOPS'10 Proceedings of the 10th international conference on Functional and Logic Programming
Theoretical Computer Science
The call-by-need lambda calculus, revisited
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
A synthetic operational account of call-by-need evaluation
Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming
Hi-index | 0.00 |
Krivine presents the $\mathcal {K}$ machine, which produces weak head normal form results. Sestoft introduces several call-by-need variants of the ${\mathcal {K}}$ machine that implement result sharing via pushing update markers on the stack in a way similar to the TIM and the STG machine. When a sequence of consecutive markers appears on the stack, all but the first cause redundant updates. Improvements related to these sequences have dealt with either the consumption of the markers or the removal of the markers once they appear. Here we present an improvement that eliminates the production of marker sequences of length greater than one. This improvement results in the ${\mathcal {C}}$ machine, a more space and time efficient variant of ${\mathcal {K}}$ . We then apply the classic optimization of short-circuiting operand variable dereferences to create the call-by-need ${\mathcal {S}}$ machine. Finally, we combine the two improvements in the ${\mathcal {CS}}$ machine. On our benchmarks this machine uses half the stack space, performs one quarter as many updates, and executes between 27% faster and 17% slower than our 驴 variant of Sestoft's lazy Krivine machine. More interesting is that on one benchmark 驴, ${\mathcal {S}}$ , and ${\mathcal {C}}$ consume unbounded space, but ${\mathcal {CS}}$ consumes constant space. Our comparisons to Sestoft's Mark 2 machine are not exact, however, since we restrict ourselves to unpreprocessed closed lambda terms. Our variant of his machine does no environment trimming, conversion to deBruijn-style variable access, and does not provide basic constants, data type constructors, or the recursive let. (The Y combinator is used instead.)