Results 11 
16 of
16
Onebit Counts between Unique and Sticky
 ACM SIGPLAN Notices
, 1998
"... Stoye's onebit reference tagging scheme can be extended to local counts of two or more via two strategies. The first, suited to pure register transactions, is a cache of referents to two shared references. The analog of Deutsch's and Bobrow's multiplereference table, this cache is sufficient to ma ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Stoye's onebit reference tagging scheme can be extended to local counts of two or more via two strategies. The first, suited to pure register transactions, is a cache of referents to two shared references. The analog of Deutsch's and Bobrow's multiplereference table, this cache is sufficient to manage small counts across successive assignment statements. Thus, accurate reference counts above one can be tracked for short intervals, like those bridging one function 's environment to its successor's. The second, motivated by runtime stacks that duplicate references, avoids counting any references from the stack. It requires a local pointerinversion protocol in the mutator, but one still local to the referent and the stack frame. Thus, an accurate reference count of one can be maintained regardless of references from the recursion stack. CCS categories and Subject Descriptors: D.4.2 [Storage Management]: Allocation/Deallocation strategies; E.2 [Data Storage Representations]: Linked re...
Integrating Generations with Advanced Reference Counting Garbage Collectors
 In International Conference on Compiler Construction
, 2003
"... We study an incorporation of generations into a modern reference counting collector. We start with the two onthey collectors suggested by Levanoni and Petrank: a reference counting collector and a tracing (mark and sweep) collector. We then propose three designs for combining them so that the ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
We study an incorporation of generations into a modern reference counting collector. We start with the two onthey collectors suggested by Levanoni and Petrank: a reference counting collector and a tracing (mark and sweep) collector. We then propose three designs for combining them so that the reference counting collector collects the young generation or the old generation or both. Our designs maintain the good properties of the LevanoniPetrank collector. In particular, it is adequate for multithreaded environment and a multiprocessor platform, and it has an ecient write barrier with no synchronization operations. To the best of our knowledge, the use of generations with reference counting has not been tried before.
A Chemical Abstract Machine for Graph Reduction
, 1992
"... Graph reduction is an implementation technique for the lazy lcalculus. It has been used to implement many nonstrict functional languages, such as lazy ML, Gofer and Miranda. Parallel graph reduction allows for concurrent evaluation. In this paper, we present parallel graph reduction as a Chemical ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Graph reduction is an implementation technique for the lazy lcalculus. It has been used to implement many nonstrict functional languages, such as lazy ML, Gofer and Miranda. Parallel graph reduction allows for concurrent evaluation. In this paper, we present parallel graph reduction as a Chemical Abstract Machine, and show that the resulting testing semantics is adequate wrt testing equivalence for the lazy lcalculus. We also present a πcalculus implementation of the graph reduction machine, and show that the resulting testing semantics is also adequate.
A Scalable Reference Counting Garbage Collector
, 1999
"... We study concurrent garbage collection via reference counting. While tracing variants of garbage collection have been well studied with respect to concurrency, the study of reference counting has been somewhat behind. The straightforward concurrent version of reference counting is not at all scalabl ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We study concurrent garbage collection via reference counting. While tracing variants of garbage collection have been well studied with respect to concurrency, the study of reference counting has been somewhat behind. The straightforward concurrent version of reference counting is not at all scalable. Furthermore, a more advanced study by DeTreville yielded an algorithm which acquires a single lock per update of a pointer, thus, executing all updates sequentially and hindering the scalability of the algorithm. In this paper we propose a new concurrent reference counting algorithm with several desired properties. First, the algorithm employs extremely fine synchronization. In particular, updates of pointers and creation of objects require no synchronization overhead whatsoever (even not a compareandswap type of operation). Furthermore, the algorithm is nondisruptive: the program threads are never stopped simultaneously to cooperate with the...
Pointer Reduction Techniques for Minimising Memory Usage, I/O Bandwidth and Computational Effort in BDD Applications
, 2007
"... BDDs (Binary Decision Diagrams) are often used to represent Boolean expressions in hardware synthesis, hardware and software verification and numerous other applications. BDD computation, implemented using tree data structures with binary nodes, is inherently memory intensive, and therefore suffers ..."
Abstract
 Add to MetaCart
BDDs (Binary Decision Diagrams) are often used to represent Boolean expressions in hardware synthesis, hardware and software verification and numerous other applications. BDD computation, implemented using tree data structures with binary nodes, is inherently memory intensive, and therefore suffers from the von Neumann memory bottleneck.
This thesis examines an approach which can speed up BDD computation through compression of the graphical structure, reducing the overhead of handling memory pointers, and thereby reducing memory access latency. The novel aspect of this work is that a compression technique is used which allows BDD computation directly on the compressed data without the overheads of compression and decompression. The need for such an approach is driven by technology in two ways: the increasing discrepancy between CPU and memory speeds, and the move towards larger (64 bit) memory architectures.
The work applies graph enumeration techniques to classify graph topology using a structural identifier (SID) coding table, providing the basis for algorithms which generate compressed representations. The work uses these new representations to develop algorithms which can precalculate results for specific graphtraversal operations in Combination lookup tables (CLT).
The work distinguishes itself from other methods of reducing BDD access latency, such as index based systems, by improving spatial locality and simplifying computation at the same time.