The IFIP TC2/WG 2.1 Working Conference on Program specification and transformation
Foundations of logic programming; (2nd extended ed.)
Foundations of logic programming; (2nd extended ed.)
The craft of Prolog
Compile-time garbage collection by sharing analysis
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
High level synthesis of pipelined instruction set processors and back-end compilers
DAC '92 Proceedings of the 29th ACM/IEEE Design Automation Conference
Parallel logic programming
Warren's abstract machine: a tutorial reconstruction
Warren's abstract machine: a tutorial reconstruction
Can logic programming execute as fast as imperative programming?
Can logic programming execute as fast as imperative programming?
Multiple specialization using minimal-function graph semantics
Journal of Logic Programming
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
Implementation and analysis of compile-time garbage collection
New Generation Computing
On copy avoidance in single assignment languages
ICLP'93 Proceedings of the tenth international conference on logic programming on Logic programming
Live-structure dataflow analysis for Prolog
ACM Transactions on Programming Languages and Systems (TOPLAS)
The aggregate update problem in functional programming systems
POPL '85 Proceedings of the 12th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Computers and Intractability: A Guide to the Theory of NP-Completeness
Computers and Intractability: A Guide to the Theory of NP-Completeness
A Compile-Time Memory-Reuse Scheme for Concurrent Logic Programs
IWMM '92 Proceedings of the International Workshop on Memory Management
Path analysis and the optimization of nonstrict functional languages
Path analysis and the optimization of nonstrict functional languages
Compile-time memory reuse in single-assignment programming languages: updating recursive data structures in place
Practical Aspects for a Working Compile Time Garbage Collection System for Mercury
Proceedings of the 17th International Conference on Logic Programming
Resource-Passing Concurrent Programming
TACS '01 Proceedings of the 4th International Symposium on Theoretical Aspects of Computer Software
Storage Size Reduction by In-place Mapping of Arrays
VMCAI '02 Revised Papers from the Third International Workshop on Verification, Model Checking, and Abstract Interpretation
Heap recycling for lazy languages
PEPM '08 Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Scheduling Tasks to Maximize Usage of Aggregate Variables in Place
CC '09 Proceedings of the 18th International Conference on Compiler Construction: Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009
| Hi-index | 0.00 |
Standard implementation techniques for single-assignment languages modify a data structure without destroying the original, which may subsequently be accessed. Instead a variant structure is created by using newly allocated cells to represent the changed portion and to replace any cell that references a newly allocated cell. The rest of the original structure is shared by the variant. The effort required to leave the original uncorrupted is unnecessary when the program will never reference the original again. This effort includes allocating and initializing new cells, as well as garbage collecting replaced cells. This article specifies a transformation system that introduces update-in-place operations, making Prolog programs update recursive data structures much as an imperative program would. The article introduces the notion of a reuse map, which formalizes reallocation decisions. Because optimal memory reuse is intractable, a heuristical method is presented that performs well in practice. Small Prolog programs that manipulate recursive data structures have their speed increased up to about five times (naive recurse), not counting any speedup obtained by avoiding garbage collection. Quicksort is about three times as fast, merge-sort about one and a half, matrix transposition about twice, and Gaussian elimination is about 1.2 times as fast.