ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
TICL—a type inference system for common Lisp
Software—Practice & Experience
Polymorphic type inference and assignment
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
SPLASH: Stanford parallel applications for shared-memory
ACM SIGARCH Computer Architecture News
Global tagging optimization by type inference
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
A practical approach to type inference for EuLisp
Lisp and Symbolic Computation
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Storage use analysis and its applications
Proceedings of the first ACM SIGPLAN international conference on Functional programming
A practical soft type system for scheme
ACM Transactions on Programming Languages and Systems (TOPLAS)
Infinitary control flow analysis: a collecting semantics for closure analysis
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Scheme for the Automatic Inference of Variable Types
Journal of the ACM (JACM)
POPL '76 Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
A Compilation Strategy for Numerical Programs Based on Partial Evaluation
A Compilation Strategy for Numerical Programs Based on Partial Evaluation
Efficient floating-point number handling for dynamically typed scripting languages
DLS '08 Proceedings of the 2008 symposium on Dynamic languages
| Hi-index | 0.00 |
It is well known that dynamic typing in languages like Lisp is costly in terms of performance. Besides the cost of tag checking, the other major source of inefficiency comes from the need to place and retrieve data from dynamically allocated objects, i.e. boxing and unboxing. This makes it unacceptable in general to write numerical code in Lisp. Such programs involve ''tight'' loops in which boxing, unboxing and tag checking will dominate the computation time. With advances in the compilation of Lisp programs, it has been suggested that type checking and inference can be used to alleviate the problem. In this paper we shall examine a sub-problem, namely using type inference to aid compilation of numerical intensive Lisp code. A type inference algorithm for floating point operations will be described. This has been implemented in a Scheme compiler. Implementation issues and performance results on fairly large numerical code will also be reported. The results suggest that significant performance gains can be obtained. It is our hope that as an augmentation to other general type inferencing scheme, it will contribute towards the realization of highly optimizing Scheme compilers.