Garbage collection in an uncooperative environment
Software—Practice & Experience
A hybrid execution model for fine-grained languages on distributed memory multicomputers
Supercomputing '95 Proceedings of the 1995 ACM/IEEE conference on Supercomputing
Lazy threads: implementing a fast parallel call
Journal of Parallel and Distributed Computing - Special issue on multithreading for multiprocessors
A machine-independent debugger
Software—Practice & Experience
Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
The implementation of the Cilk-5 multithreaded language
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
StackThreads/MP: integrating futures into calling standards
Proceedings of the seventh ACM SIGPLAN symposium on Principles and practice of parallel programming
A single intermediate language that supports multiple implementations of exceptions
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Accurate garbage collection in an uncooperative environment
Proceedings of the 3rd international symposium on Memory management
Lazy Task Creation: A Technique for Increasing the Granularity of Parallel Programs
IEEE Transactions on Parallel and Distributed Systems
C--: A Portable Assembly Language that Supports Garbage Collection
PPDP '99 Proceedings of the International Conference PPDP'99 on Principles and Practice of Declarative Programming
A Message Passing Implementation of Lazy Task Creation
Proceedings of the US/Japan Workshop on Parallel Symbolic Computing: Languages, Systems, and Applications
Backtracking-based load balancing
Proceedings of the 14th ACM SIGPLAN symposium on Principles and practice of parallel programming
Experience with SC: transformation-based implementation of various extensions to C
Proceedings of the 2007 International Lisp Conference
Managing continuations for proper tail recursion
Proceedings of the 2010 international conference on Lisp
Hi-index | 0.00 |
We propose a new language concept called “L-closures” for a running program to legitimately inspect/modify the contents of its execution stack. L-closures are lightweight lexical closures created by evaluating nested function definitions. A lexical closure can access the lexically-scoped variables in the creation-time environment and indirect calls to it provide legitimate stack access. By using an intermediate language extended with L-closures in high-level compilers, high-level services such as garbage collection, check-pointing, multithreading and load balancing can be implemented elegantly and efficiently. Each variable accessed by an L-closure uses private and shared locations for giving the private location a chance to get a register. Operations to keep coherency with shared locations as well as operations to initialize L-closures are delayed until an L-closure is actually invoked. Because most high-level services create L-closures very frequently but call them infrequently (e.g., to scan roots in garbage collection), the total overhead can be reduced significantly. Since the GNU C compiler provides nested functions, we enhanced GCC at relatively low implementation costs. The results of performance measurements exhibit quite low costs of creating and maintaining L-closures.