Compilers: principles, techniques, and tools
Compilers: principles, techniques, and tools
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Computer algorithms: introduction to design and analysis
Computer algorithms: introduction to design and analysis
The semantics of destructive LISP
The semantics of destructive LISP
Analysis of functional programs to detect run-time garbage cells
ACM Transactions on Programming Languages and Systems (TOPLAS)
Real-time concurrent collection on stock multiprocessors
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Lifetime analysis of dynamically allocated objects
POPL '88 Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Dependence analysis for pointer variables
PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
Polymorphic unification and ML typing
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Deciding ML typability is complete for deterministic exponential time
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Update analysis and the efficient implementation of functional aggregates
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Compile-time garbage collection by sharing analysis
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
On the complexity of type inference with coercion
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
The aggregate update problem in functional programming systems
POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
A semantic model of reference counting and its abstraction (detailed summary)
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
A real-time garbage collector based on the lifetimes of objects
Communications of the ACM
List processing in real time on a serial computer
Communications of the ACM
Shifting garbage collection overhead to compile time
Communications of the ACM
SIGPLAN '84 Proceedings of the 1984 SIGPLAN symposium on Compiler construction
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Flow analysis and optimization of LISP-like structures
POPL '79 Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
POPL '82 Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '84 Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Garbage collection in a large LISP system
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Generation Scavenging: A non-disruptive high performance storage reclamation algorithm
SDE 1 Proceedings of the first ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments
POPL '76 Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
Rabbit: A Compiler for Scheme
Preexecution analysis based on denotational semantics
Preexecution analysis based on denotational semantics
Dynamic memory allocation techniques based on the lifetime of objects
Dynamic memory allocation techniques based on the lifetime of objects
Garbage collection and other optimizations
Garbage collection and other optimizations
Restructuring symbolic programs for concurrent execution on multiprocessors
Restructuring symbolic programs for concurrent execution on multiprocessors
Rationale for the design of the Ada programming language
ACM SIGPLAN Notices - Rationale for the deisgn of the Ada programming language
Shallow binding makes functional arrays fast
ACM SIGPLAN Notices
CLOStrophobia: its etiology and treatment
ACM SIGPLAN OOPS Messenger
CONS should not CONS its arguments, or, a lazy alloc is a smart alloc
ACM SIGPLAN Notices
The treadmill: real-time garbage collection without motion sickness
ACM SIGPLAN Notices
Analysis of recursive types in Lisp-like languages
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Lively linear Lisp: “look ma, no garbage!”
ACM SIGPLAN Notices
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
ACM Letters on Programming Languages and Systems (LOPLAS)
Equal rights for functional objects or, the more things change, the more they are the same
ACM SIGPLAN OOPS Messenger
Implementation of the typed call-by-value λ-calculus using a stack of regions
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A general data dependence test for dynamic, pointer-based data structures
PLDI '94 Proceedings of the ACM SIGPLAN 1994 conference on Programming language design and implementation
The Boyer benchmark meets linear logic
ACM SIGPLAN Lisp Pointers
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Semantic models and abstract interpretation techniques for inductive data structures and pointers
PEPM '95 Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Abstract models of memory management
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Garbage collection and local variable type-precision and liveness in Java virtual machines
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Type-based analysis of uncaught exceptions
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Compositional pointer and escape analysis for Java programs
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Type-based analysis of uncaught exceptions
ACM Transactions on Programming Languages and Systems (TOPLAS)
From ML to Ada: Strongly-typed language interoperability via source translation
Journal of Functional Programming
Formal semantics of weak references
Proceedings of the 5th international symposium on Memory management
Generic ownership for generic Java
Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Tunable static inference for generic universe types
Proceedings of the 25th European conference on Object-oriented programming
Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems
Hi-index | 0.00 |
Type inference is the process by which an expression in an untyped computer language such as the lambda-calculus, Lisp, or a functional language can be assigned a static data type in order to improve the code generated by a compiler. Storage use inference is the process by which a program in a computer language can be statically analyzed to model its run-time behavior, particularly the containment and sharing relations among its run-time data structures. The information generated by storage use information can also be used to improve the code generated by a compiler, because knowledge of the containment and sharing relations of run-time data structures allows for methods of storage allocation and deallocation which are cheaper than garbage-collected heap storage and allows for the in-place updating of functional aggregates.Type inference and storage use inference have traditionally been considered orthogonal processes, with separate traditions and literature. However, we show in this paper than this separation may be a mistake, because the best-known and best-understood of the type inferencing algorithms—Milner's unification method for ML—already generates valuable sharing and containment information which is then unfortunately discarded. We show that this sharing information is already generated by standard unification algorithms with no additional overhead during unification; however, there is some additional work necessary to extract this information. We have not yet precisely characterized the resolving power of this sharing and containment information, but we believe that it is similar to that generated by researchers using other techniques. However, our scheme seems to only work for functional languages like pure Lisp.The unification of type and storage inferencing yields new insights into the meaning of “aggregate type”, which should prove valuable in the design of future type systems.