Performance and evaluation of LISP systems
Performance and evaluation of LISP systems
Typestate: A programming language concept for enhancing software reliability
IEEE Transactions on Software Engineering
Theoretical Computer Science
Theoretical Computer Science - International Joint Conference on Theory and Practice of Software Development, P
Communications of the ACM
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Common LISP: the language (2nd ed.)
Common LISP: the language (2nd ed.)
Deciding ML typability is complete for deterministic exponential time
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Copying and Swapping: Influences on the Design of Reusable Software Components
IEEE Transactions on Software Engineering
Is there a use for linear logic?
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Selected papers of the Second Workshop on Concurrency and compositionality
Proving memory management invariants for a language based on linear logic
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Lively linear Lisp: “look ma, no garbage!”
ACM SIGPLAN Notices
The Boyer Benchmark at warp speed
ACM SIGPLAN Lisp Pointers
Computational interpretations of linear logic
Theoretical Computer Science - Special volume of selected papers of the Sixth Workshop on the Mathematical Foundations of Programming Semantics, Kingston, Ont., Canada, May 1990
ACM SIGPLAN Notices
Linear logic and permutation stacks—the Forth shall be first
ACM SIGARCH Computer Architecture News - Special issue: panel sessions of the 1991 workshop on multithreaded computers
Sparse polynomials and linear logic
ACM SIGSAM Bulletin
An empirical study of list structure in Lisp
Communications of the ACM
Shifting garbage collection overhead to compile time
Communications of the ACM
A method for overlapping and erasure of lists
Communications of the ACM
Mechanisms for compile-time enforcement of security
POPL '83 Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
NREVERSAL of Fortune - The Thermodynamics of Garbage Collection
IWMM '92 Proceedings of the International Workshop on Memory Management
Notes on Data Base Operating Systems
Operating Systems, An Advanced Course
Programming without pointer variables
Proceedings of the 1976 conference on Data : Abstraction, definition and structure
Containment defines a class of recursive data structures
ACM SIGPLAN Notices
Generational garbage collection and the radioactive decay model
Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
Type-preserving garbage collectors
POPL '01 Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An experimental study of renewal-older-first garbage collection
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Mechanization Of Real-Time Linear Csp With Higher Order Logic
Fundamenta Informaticae
Hi-index | 0.00 |
Of the Gabriel Lisp Benchmarks, the Boyer Benchmark ("Boyer") is the most representative of real AI applications, because it performs Prolog-like rule-directed rewriting, and because it relies heavily on garbage collection (GC) for the recovery of storage. We investigated the notion that such programs are unsuitable for explicit storage management---e.g., by means of a "linear" programming style in which every bound name dynamically occurs exactly once. We programmed Boyer in a "linear" fragment of Lisp in both interpretive-rule and compiled-rule versions, using both true linear (unshared) and reference count methods.We found that since the intermediate result of rewrite is unshared, the linear interpreted version is slower than the non-linear interpreted version, while the linear compiled version is slightly faster than the non-linear compiled version. When sharing is allowed, requiring reference counts for the linear versions, the linear shared versions are not competitive with the non-linear versions, except when "anchored pointers" are used. The anchored pointer reference count version, which reclaims storage, is still 1.25X slower than the non-linear version, which reclaims no storage.