for "garbage" and "collection" and "1992"
Search term: garbage;collection;1992
No spelling errors allowed, case-insensitive, partial words match.
Information on how to form queries.
@InProceedings{DV,
title = "Binding Techniques and Garbage Collection for
{OR}-Parallel {CLP} Systems",
author = "M. Dorochevsky and A. {V\'{e}ron}",
booktitle = "Proceedings of the Fourth International Symposium on
Programming Language Implementation and Logic
Programming",
editor = "M. Bruynooghe and M. Wirsing",
publisher = "LNCS 631, Springer-Verlag",
year = "1992",
address = "Leuven, Belgium",
pages = "39--53",
}
@TechReport{dorochevsky-binding,
author = "Michel Dorochevsky and Andr{\'{e}} V{\'{e}}ron",
title = "Binding Techniques and Garbage Collection for
{OR}-Parallel {CLP} Systems",
institution = "{ECRC}",
year = "1992",
number = "ECRC-92-21",
}
@TechReport{KSA:GCDSMS,
author = "Rammohan Kordale and John Shilling and Mustaque
Ahamad",
title = "Garbage Collection in Distributed Shared Memory
Systems",
institution = "Georgia Institute of Technology",
number = "GIT-CC-92/45",
year = "1992",
}
@MastersThesis{Ma:DGCCSTS,
author = "U. Maheshwari",
title = "Distributed Garbage Collection in a Client-Server
Transaction System",
school = "Massachusetts Institute of Technology {EECS}
Department",
year = "1992",
}
@Article{nilsen:92,
author = "Kelvin D. Nilsen and William J. Schmidt",
title = "Cost-Effective Object Space Management for
Hardware-Assisted Real-Time Garbage Collection",
pages = "338--354",
journal = "ACM Letters on Programming Languages and Systems",
year = "1992",
month = dec,
volume = "1",
number = "4",
}
@TechReport{PWMNIPKRHCmar92,
author = "Peter W. Madany and Nayeem Islam and Panos Kougiouris
and Roy H. Campbell",
title = "Reification and Reflection in {C}++: an operating
systems perspective",
institution = "University of Illinois",
address = "Department of Computer Science, Urbana-Champaign",
number = "{UIUCDCS--R--92--1736}",
year = "1992",
month = mar,
abstract = "The paper discusses using reification (the
representation of an attribute of an object-oriented
program such as method dispatch, inheritance, or object
structure within the program) and reflection (the
ability to make attributes like method invocation,
interface, inheritance, object implementation the
subject of computation) in Choices. Reification is
used, for example, to modify the behaviour of pointers
so reference-counting can be done safely. The system
includes inheritance and classes as run-time entities,
allowing dynamic extension of the system functions.",
keyword = "Choices, garbage collection, object-oriented
programming, inheritance, class structure, run-time
extension",
}
@Article{zorn93:spe-conservative-gc-measurement,
author = "Benjamin Zorn",
title = "The Measured Cost of Conservative Garbage Collection",
journal = "Software---Practice and Experience",
year = "1993",
volume = "23",
number = "7",
pages = "733--756",
month = Jul,
note = "${}^{\clubsuit}$Also Computer Science Technical Report
{CU-CS-573-92}, University of Colorado, Campus Box 430,
Boulder, {CO} 80309, April 1992",
}
@MastersThesis{TJCmastersthesis92,
author = "${}^{\clubsuit}$Terence J. Critchlow",
title = "A Distributed Garbage Collection Algorithm",
school = "University of Utah",
address = "Salt Lake City, Utah",
year = "1992",
month = aug,
}
@Article{HM92,
author = "Maurice P. Herlihy and J. Eliot B. Moss",
title = "Lock-Free Garbage Collection on Multiprocessors",
journal = "IEEE Transactions on Parallel and Distributed
Systems",
year = "1992",
volume = "3",
number = "3",
pages = "304--311",
month = may,
}
@PhdThesis{Schmidt:phd,
author = "${}^{\clubsuit}$William J. Schmidt",
title = "Issues in the Design and Implementation of a Real-Time
Garbage Collection Architecture",
year = "1992",
school = "Iowa State University",
address = "Ames, Iowa",
note = "Technical report ISUTR 92-25",
}
@Unpublished{Wi:HRRTGC,
title = "How Real is ``Real Time'' Garbage Collection?",
author = "${}^{\clubsuit}$P. T. Withington",
note = "OOPSLA '92 Workshop on Garbage Collection in
Object-Oriented Systems",
year = "1992",
}
@InProceedings{Ba:Treadmill,
author = "${}^{\surd\clubsuit}$Henry G. {Baker, Jr.}",
title = "The {Treadmill}: Real-time garbage collection without
motion sickness",
crossref = "OOPSLA-GC91",
note = "Also appears as {\em SIGPLAN Notices 27}(3):66--70,
March 1992",
}
Aussi en rapport technique X
@InProceedings{Queinnec92a,
author = "Bernard Lang and Christian Queinnec and Jos\'e
Piquer",
title = "Garbage Collecting the World",
booktitle = popl92,
year = "1992",
pages = "39--50",
address = "Albuquerque (New Mexico, USA)",
month = jan,
ecritsdicsla = "6",
sourcefile = "themes/GChd/gc",
ftpfile = "gc",
w3keyword = "POPL92",
abstract = "Distributed symbolic computations involve the
existence of {\em remote references} allowing an
object, local to a processor, to designate another
object located on another processor. To reclaim
inaccessible objects is the non trivial task of a
distributed Garbage Collector (GC). We present in this
paper a new distributed GC algorithm which { \em(i)\/}
is fault-tolerant, { \em(ii)\/} is largely independent
of how a processor garbage collects its own data space,
{ \em(iii)\/} does not need centralized control nor
global stop-the-world synchronization, { \em(iv)\/}
allows for multiple concurrent active GCs, { \em(v)\/}
does not require to migrate objects from processor to
processor and { \em(vi)\/} eventually reclaims all
inaccessible objects including distributed cycles.
These results are mainly obtained through the concept
of a {\em group} of processors (or processes).
Processors of a same group cooperate together to a GC
inside this group; this GC is conservative with respect
to the outside of the group. A processor contributes to
the global GC of all groups to which it belongs.
Garbage collection on small groups reclaims quickly
locally distributed garbage clusters, while garbage
collection on large groups ultimately reclaims widely
distributed garbage clusters, albeit more slowly.
Groups can be reorganized dynamically, in particular to
tolerate failures of some member processors. These
properties make the algorithm usable on very large and
evolving networks of processors. Other than distributed
symbolic computations, possible applications include
for example distributed file or database systems.",
}
@Article{diwan:92,
title = "Compiler Support for Garbage Collection in a
Statically Typed Language",
author = "Amer Diwan and Eliot Moss and Richard Hudson",
pages = "273--282",
journal = "SIGPLAN Notices",
year = "1992",
month = jul,
volume = "27",
number = "7",
note = "{\em Proceedings of the ACM SIGPLAN '92 Conference on
Programming Language Design and Implementation}",
}
@InProceedings{MOHAN92,
key = "Mohan et al.",
author = "C. Mohan and H. Pirahesh and R. Lorie",
title = "Efficient and Flexible Methods for Transient
Versioning of Records to Avoid Locking by Read-Only
Transactions",
booktitle = "sigmod",
organization = "acm",
publisher = "Acm Press",
address = "San Diego, California",
editor = "M. Stonebraker",
volume = "21",
month = jun,
year = "1992",
pages = "124--133",
abstract = "We present efficient and flexible methods which permit
read-only transactions that do not mind reading a
possibly slightly old, but still consistent, version of
the data base to execute without acquiring locks. This
approach avoids the undesirable interferences between
such queries and the typically shorter update
transactions that cause unnecessary and costly delficiency (logging,
garbage collection, version selection, and incremental,
record-level versioning). Distributed data base
environments are also supported, including commit
protocols with the read-only optimization. We also
describe efficient methods for garbage collecting
unneeded older versions.",
bibdate = "Mon Jan 25 13:35:57 1993",
owner = "bassili",
}
@InProceedings{Ladin92,
author = "R. Ladin and B. Liskov",
title = "Garbage Collection of a Distributed Heap",
booktitle = "Proc. 12th Int'l. Conf. on Distr. Computing Sys.",
pages = "708",
address = "Yokohama, Japan",
month = jun # " 9-12",
year = "1992",
keywords = "IEEE ICDCS ICDCS12",
}
@InProceedings{dsg-24,
author = "{Gourhant, Y., Louboutin, S., Cahill, V., Condon, A.,
Starovic, G. and B.} Tangney",
title = "{Dynamic Clustering in an Object-Oriented Distributed
System}",
booktitle = "{Proceedings of OLDA-II (Objects in Large Distributed
Applications)}",
year = "1992",
address = "Ottawa, Canada",
month = oct,
note = "OLDA-II Workshop, October 18th",
abstract = "In an O-O distributed system, object grouping is
crucial in order to optimize communications between
objects and disk I/O transfers. In this paper, we
present a general purpose and scalable object
clustering method which is integrated with garbage
collection and load balancing processing. We proposed a
mixed dynamic and user-driven approach.",
keywords = "k-clustering, k-gc, k-lb, k-o-o",
source = "work/doc/TCD/published/ConferencesJournals/DynamicClusteringInOODS.OLDA-II92/",
url = "file://ftp.dsg.cs.tcd.ie:/pub/doc/dsg-24.ps.Z",
}
@Proceedings{IB-A925009,
editor = "ACM Press",
title = "19th Annual {ACM} Sigplan-Sigact Symposium on
Principles of Programming Languages 1992",
address = "Baltimore",
year = "1992",
descriptor = "Compilation, Effizienz, Funktionales Programmieren,
Garbage collection, Partielle Auswertung,
Polymorphismus, Statische Analyse, Objekt-orientierte
Programmierung, Programmiersprache, Semantik",
annote = "Tagungsband 19th POPL '92: Grundlagen der
Programmiersprachen",
}
@Unpublished{Cheong92c,
author = "Fah-Chun Cheong",
title = "Almost tag-free garbage collection for strongly-typed
object-oriented languages",
type = "unpublished",
month = "[3]",
year = "1992",
note = "Department of Electrical Engineering and Computer
Science, University of Michigan and Ann Arbor, MI
48109-2122",
}
@Article{Jones92,
author = "Richard E. Jones",
title = "Tail recursion without space leaks.",
journal = "Journal of Functional Programming",
volume = "2",
number = "1",
pages = "73--79",
month = jan,
year = "1992",
keywords = "FP, functional programming, FP, lazy, call by need,
space, garbage, memory leak, JFP, management,
collection",
abstract = "via enews",
}
@Article{Baker:1990:CSC,
author = "Henry G. {Baker, Jr.}",
title = "{CONS} Should Not {CONS} its Arguments, or, {A} Lazy
Alloc is a Smart Alloc",
journal = "ACM SIGPLAN Notices",
volume = "27",
number = "3",
pages = "24--34",
month = mar,
year = "1992",
note = "Submitted to {\em Communications of the ACM}.",
bibsource = "file://sunspot.math.utah.edu/usr/local/src/bib/bibliography/Compiler/garbage.collection.bib",
}
@InProceedings{Bailey93,
author = "P. Bailey and M. Newey",
title = "Implementing {ML} on Distributed Memory
Multiprocessors",
booktitle = "Workshop on Languages, Compilers and Run-Time
Environments for Distributed Memory Multiprocessors,
Boulder, CO, 1992.",
pages = "56--59",
year = "1993",
keywords = "functional parallel garbage collection",
abstract = "The advent of distributed memory multicomputers,
enables the implementation of parallel programming
languages where every processing element is capable of
supporting a runtime system large enough for languages
such as Lisp and ML. The language ML is a 'mostly
functional' programming language which requires
significant runtime support for features such as
garbage collection. Most existing concurrent
implementations of ML use shared memory and a single
runtime system. In a distributed memory multicomputer,
the cost of non-local memory access can be orders of
magnitude more expensive than local memory access, and
so these existing concurrent implementations are not
suitable. The paper describes an implementation of ML
to enable the user to utilise the advantages of that
style of architecture.",
note = "Published as ACM SIGPLAN Notices, volume 28, number
1",
}
@InProceedings{Baker92,
author = "H. G. Baker",
editor = "Y. Bekkers and J. Cohen",
title = "{NREVERSAL} of Fortune - the Thermodynamics of Garbage
Collection",
booktitle = "Memory Management; International Workshop IWMM 92;
Proceedings",
pages = "507--524",
publisher = "Springer-Verlag",
address = "Berlin, Germany",
year = "1992",
keywords = "functional",
ISBN = "3-540-55940-X",
abstract = "This paper proposes an abstract computer model and a
programming language- Psi-Lisp-whose primitive
operations are injective and hence reversible, thus
allowing arbitrary undoing, without the overheads of
checkpointing. Such a computer can be built from
reversible conservative logic circuits, with the
serendipitous advantage of dissipating far less heat
than traditional Boolean AND/OR/NOT circuits. Unlike
functional languages, which have one 'stage' for all
times, Psi-Lisp has at all times one 'state', with
unique predecessor and successor states. Compiling into
a reversible pseudocode can have benefits even when
targeting a traditional computer. Certain
optimizations, e.g., update-in-place, and compile-time
garbage collection may be more easily performed,
because the information may be elicited without the
difficult and time-consuming iterative abstract
interpretation required for most non-reversible models.
In a reversible machine, garbage collection for
recycling storage can always be performed by a reversed
(sub)computation. While this 'collection is reversed
mutation' insight does not reduce space requirements
when used for the computation as a whole, it does save
space when used to recycle at finer scales. This
insight also provides an explanation for the
fundamental importance of the push-down stack both for
recognizing palindromes and for managing storage.",
}
@Article{Cooper92,
author = "E. Cooper and S. Nettles and I. Subramanian",
title = "Improving the Performance of {SML} Garbage Collection
using Application-Specific Virtual Memory Management",
journal = "ACM LISP Pointers",
volume = "5",
number = "1",
pages = "43--52",
year = "1992",
ISBN = "0-89791-481-3",
note = "Proceedings of the 1992 ACM Conference on LISP and
Functional Programming",
}
@Article{Goldberg92,
author = "B. Goldberg and M. Gloger",
title = "Polymorphic Type Reconstruction for Garbage Collection
without Tags",
journal = "ACM LISP Pointers",
volume = "5",
number = "1",
pages = "53--65",
year = "1992",
ISBN = "0-89791-481-3",
note = "Proceedings of the 1992 ACM Conference on LISP and
Functional Programming",
}
@InCollection{Heck92,
author = "B. C. Heck and D. S. Wise",
editor = "Y. Bekkers and J. Cohen",
title = "An Implementation of an Applicative File System",
booktitle = "Memory Management",
pages = "248--263",
publisher = "Springer-Verlag",
address = "New York, NY",
year = "1992",
keywords = "persistence scheme reference counting functional input
output",
abstract = "A purely functional file system has been built on top
of pure Scheme. It provides persistent structures and
massive storage expected of file systems, without
explicit side-effects like read and write. The file
system becomes an additional, lazy argument to programs
that would read from it, and an additional result from
functions that would alter it. Functional programming
on lazy structures replaces in-place side-effects with
a significant storage management problem, handled by
conjoining the heap to the file system. A hardware
implementation of reference counting is extended out to
manage sectors, as well as the primary heap. Backing it
is a garbage collector of heap and of disk (i.e. UNIX's
fsck), needed only at reboot.",
note = "INRIA/IRISA/SIGPLAN International Workshop on Memory
Management, St. Malo; Lecture Notes in Computer Science
637.",
}
@Article{Hughes92a,
author = "S. Hughes",
title = "Compile-time Garbage Collection for Higher-order
Functional Languages",
journal = "Journal of Logic and Computation",
volume = "2",
number = "4",
pages = "483--509",
year = "1992",
abstract = "Functional languages suffer from problems associated
with inefficient use of store. The paper presents a
compile-time garbage collection optimization for a
strict higher-order functional language to mitigate
these problems. Compile-time garbage collection
involves the determination, at compile-time, of points
in a program's execution at which garbage collection
will take place and of the parts of store to be garbage
collected. Actual collection still takes place at
run-time. The compile-time garbage collection
optimisation is validated by two static (compile-time)
analyses. Generation analysis gives sharing information
about a given list while inheritance analysis
essentially tells which parts of lists evaluated during
the application of a function are part of the result of
the application. Correctness of the analyses and
optimizations is considered, using a denotational store
semantics as a reference. The analyses and
optimizations are applied to an example quicksort
program and the improvement is quantified. It is found
that the program is significantly improved to the
extent that its consumption of store is optimal after
optimization.",
}
@TechReport{Jones92b,
author = "R. E. Jones and R. D. Lins",
title = "Cyclic Weighted Reference Counting without Delay",
institution = "Computing Laboratory, University of Kent",
type = "Technical Report No.",
number = "28/92",
address = "Canterbury, UK",
year = "1992",
keywords = "functional",
abstract = "Weighted Reference Counting is a low communication
distributed storage reclamation scheme for
loosely-couple multiprocessors. The algorithm we
present herein extends weighted reference counting to
allow the collection of cyclic data structures. To do
so, the algorithm identifies candidate objects that may
be part of cycles and performs a tricolour mark-scan on
their subgraph in a lazy manner to discover whether the
subgraph is still in use. The algorithm is concurrent
in the sense that multiple useful computation processes
and garbage collection processes can be performed
simultaneously.",
}
@InProceedings{Langendoen92a,
author = "K. Langendoen and P. H. Hartel",
editor = "U. Kastens and P. Pfahler",
title = "{FCG}: a Code Generator for Lazy Functional
Languages",
booktitle = "Compiler Construction; 4th International Conference
CC'92 Proceedings",
pages = "278--296",
publisher = "Springer-Verlag",
address = "Berlin, Germany",
year = "1992",
ISBN = "3-540-55984-1",
abstract = "The FCG code generator produces portable code that
supports efficient two-space copying garbage
collection. The code generator transforms the output of
the FAST compiler front end into an abstract machine
code. This code explicitly uses a call stack, which is
accessible to the garbage collector. In contrast to
other functional language compilers that generate
assembly directly, FCG uses the C compiler for code
generation, providing high-quality code optimisations
and portability. To make full use of the C compiler's
capabilities, FCG includes an optimisation scheme that
transforms the naively generated stack-based code into
a register-based equivalent form. The results for a
benchmark of functional programs show that code
generated by FCG performs well in comparison with the
LML compiler.",
}
@TechReport{Lester92,
author = "D. Lester",
editor = "H. Kuchen and R. Loogen",
title = "Distributed Garbage Collection of Cyclic Structure",
institution = "RWTH Aachen, Fachgruppe Informatik",
type = "Bericht Nr.",
number = "92-19",
address = "Aachen, DE",
year = "1992",
note = "Proceedings of the 4th International Workshop on the
Parallel Implementation of Functional Languages.",
}
@InProceedings{Rojemo92,
author = "N. Rojemo",
editor = "Y. Bekkers and J. Cohen",
title = "A Concurrent Generational Garbage Collector for a
Parallel Graph Reducer",
booktitle = "Memory Management; International Workshop IWMM 92.
Proceedings",
pages = "440--453",
publisher = "Springer-Verlag",
address = "Berlin, Germany",
year = "1992",
keywords = "functional",
ISBN = "3-540-55940-X",
abstract = "This paper describes a garbage collector for an
implementation of a lazy functional language using
parallel graph reduction. The garbage collector is an
extension to the Appel-Ellis-Li garbage collector. The
extension consists of two parts. Firstly, generations
has been added: this often decreases the garbage
collection time with nearly 20\%. This shows that
generational garbage collection is useful even for a
lazy functional language implemented with graph
reduction (which performs a lot of updates). Secondly,
the Appel-Ellis-Li garbage collector has been changed
so that it can collect garbage processes (which is
essential if the author does speculative evaluation).",
}
@InProceedings{Sansom92,
author = "P. Sansom",
editor = "R. Heldal and C. K. Holst and P. L. Wadler",
title = "Combining Single-Space and Two-Space Compacting
Garbage Collectors",
booktitle = "Functional Programming, Glasgow 1991: Proceedings of
the 1991 Workshop, Portree, UK",
pages = "312--323",
publisher = "Springer-Verlag",
address = "Berlin, DE",
year = "1992",
ISBN = "3-540-19760-5",
abstract = "The garbage collector presented makes use of two well
known compaction garbage collection algorithms with
very different performance characteristics: C.J.
Cheney's (1970) two-space copying collector and H.B.M.
Jonker's (1979) single-space sliding compaction
collector. The author proposes a scheme which allows
either collector to be used. The run-time memory
requirements of the program being executed are used to
determine the most appropriate collector. This enables
one to achieve a fast collector for heap requirements
less than half of the heap memory but allows the heap
utilization to increase beyond this threshold. Using
these ideas the author develops a particularly
attractive extension to A.W. Appel's (1989)
generational collector.",
}
@InProceedings{Seward92,
author = "J. Seward",
editor = "Y. Bekkers and J. Cohen",
title = "Generational Garbage Collection for Lazy Graph
Reduction",
booktitle = "Memory Management; International Workshop IWMM 92;
Proceedings",
pages = "200--217",
publisher = "Springer-Verlag",
address = "Berlin, Germany",
year = "1992",
keywords = "functional",
ISBN = "3-540-55940-X",
abstract = "Although the LISP community have been exploiting the
fruits of generational garbage collection for some
time, little attempt has been made to apply these ideas
in lazy functional language implementations. This paper
attempts to plug that gap. The action of overwriting an
unevaluated thunk with its final value, known as
updating, is central to lazy reduction systems.
Unfortunately, updating creates pointers from older to
younger generations. A simple two-generation scheme
which allows heap occupancy to approach 100\% is
presented. This collector is a hybrid semispace and
mark-scan collector. The author shows that keeping
track of old-to-new pointers imposes virtually zero
time and space overhead on the mutator. Consequently a
new performance gain can be had by using generational
collection. This paper describes how a generational
collector was incorporated into a standard G-machine
interpreter. Detailed performance measurements
presented indicate that a significant improvement in
overall performance is achieved, compared to both
semispace and compacting mark-scan collectors. Some
interesting variants of the basic scheme are discussed.
Finally, a possible compiled-code implementation is
presented.",
}
@InProceedings{Tarau92,
author = "P. Tarau",
editor = "Y. Bekkers and J. Cohen",
title = "Ecological Memory Management in a Continuation Passing
Prolog Engine",
booktitle = "Memory Management; International Workshop IWMM 92;
Proceedings",
pages = "344--356",
publisher = "Springer-Verlag",
address = "Berlin, Germany",
year = "1992",
keywords = "logic functional",
ISBN = "3-540-55940-X",
abstract = "Starting from a simple 'ecological'the author
introduces a new memory management scheme
(heap-lifting) implemented in BinProlog, a continuation
passing style variant of WAM. He discusses copying
garbage collection mechanisms based on heap-lifting and
an OR-parallel execution model. He points out some
surprising similarities with related work on functional
languages and the difficulties that arise in the
context of nondeterministic execution. Finally, he
describes the full implementation of two builtins: a
recursive copy-term and a very fast heap-lifting based
find all and evaluates their impact on the performance
of BinProlog.",
}
@Article{Wilson92,
author = "P. R. Wilson and M. S. Lam and T. G. Moher",
title = "Caching Considerations for Generational Garbage
Collection",
journal = "ACM LISP Pointers",
volume = "5",
number = "1",
pages = "32--42",
year = "1992",
ISBN = "0-89791-481-3",
note = "Proceedings of the 1992 ACM Conference on LISP and
Functional Programming",
}
@TechReport{Edelson92,
author = "Daniel R. Edelson",
title = "Smart Pointers: They're Smart, but They're not
Pointers",
institution = "Baskin Center for Computer Engineering and Information
Sciences, University of California, Santa Cruz",
year = "1992",
number = "UCSC-CRL-92-27",
address = "Santa Cruz, CA 95064, USA",
month = jun,
abstract = "There are numerous times when a C++ user could benefit
from a pointer variant that has more functionality than
is provided by the basic,language-defined pointer. For
example, type-accurate garbage collection, reference
counting, or transparent references to distributed or
persistent objects, might be implemented with classes
that provide pointer functionality. The C++ language
directly supports one kind of pointer substitute, the
smart pointer, in the form of overloadable indirection
operators: -> and *. In this paper we evaluate how {\em
seamlessly} smart pointers can replace raw pointers.
The ideal is for client code not to care whether it is
using raw pointers or smart pointers. For example, if a
typedef selects whether raw or smart pointers are used
throughout the program, changing the value of the
typedef should not introduce syntax errors.
Unfortunately, C++ does not support pointer substitutes
well enough to permit seamless integration. This paper
presents the desired behavior of smart pointers in
terms of the semantics of raw pointers that the smart
pointers try to emulate. Then, we describe several ways
of implementing smart pointers. For each, we show cases
in which the smart-pointers fail to behave like raw
pointers. From among the choices, we explain which is
the best for emulating the standard pointer
conversions. {\em Accessors} are similar to smart
pointers, but have certain advantages. This paper
discusses the differences between accessors and smart
pointers, and shows why our conclusions about type
conversion behavior also apply to accessors. Whether a
programmer prefers smart pointers or accessors, this
paper shows the limitations and recommends an
implementation.",
}
@TechReport{Edelson92a,
author = "Daniel R. Edelson",
title = "Precompiling {C}++ for Garbage Collection",
institution = "Baskin Center for Computer Engineering and Information
Sciences, University of California, Santa Cruz",
year = "1992",
number = "UCSC-CRL-92-28",
address = "Santa Cruz, CA 95064, USA",
month = jun,
abstract = "Our research is concerned with compiler-independent,
efficient and convenient garbage collection for C++.
Most collectors proposed for C++ have either been
implemented in a library or in a compiler. As an
intermediate step between those two, this paper
proposes using precompilation techniques to augment a
C++ source program with code to allow mostly
type-accurate garbage collection. There are two key
precompiler transformations. The first is automatic
generation of {\em smart pointer} classes. The
precompiler defines the smart pointer classes and the
user utilizes them instead of raw pointers. These smart
pointers supply functionality that allows the collector
to locate the root set for collection. The second
transformation augments the C++ program with code that
allows the garbage collector to locate internal
pointers within objects. This paper describes the
precompiler and the garbage collector. The paper
includes a brief (1500 word) survey of related
techniques.",
}
@InProceedings{gc:rep:pan:981,
author = "Marc Shapiro and Peter Dickman and David
Plainfoss\'{e}",
title = "Robust, Distributed References and Acyclic Garbage
Collection",
pages = "135--146",
note = "Superseded by \cite{sor:nom:1083}: corrects a bug,
more elegant, more informative",
booktitle = "Symp.\ on Principles of Distributed Computing",
year = "1992",
organization = "ACM",
address = "Vancouver (Canada)",
month = aug,
}
@InProceedings{sos:c++:gc:1040,
author = "Daniel R. Edelson",
title = "Precompiling {C}++ for Garbage Collection",
pages = "299--314",
booktitle = "Proc.\ 1992 International Workshop on Memory
Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@TechReport{sor:nom:1083,
author = "Marc Shapiro and Peter Dickman and David
Plainfoss\'{e}",
title = "{SSP} Chains: Robust, Distributed References
Supporting Acyclic Garbage Collection",
institution = "Institut National de la Recherche en Informatique et
Automatique",
year = "1992",
type = "Rapport de Recherche",
number = "1799",
address = "Rocquencourt (France)",
month = nov,
note = "Also available as Broadcast Technical Report \#1",
}
@InProceedings{gc:rep:1086,
author = "S. E. Abdullahi and E. E. Miranda and G. A. Ringwood",
title = "Collection Schemes for Distributed Garbage",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "43--81",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:rep:1087,
author = "N. C. Juul and E. Jul",
title = "Comprehensive and Robust Garbage Collection in a
Distributed System",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "103--115",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:rep:1088,
author = "N. Venkatasubramanian and G. Agha and C. Talcott",
title = "Scalable Distributed Garbage Collection for Systems of
Active Objects",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "116--133",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:rep:1089,
author = "I. Puaut",
title = "Distributed Garbage Collection of Active Objects with
no Global Synchronisation",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "148--164",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:par:1091,
author = "T. Le Sergent and B. Berthomieu",
title = "Incremental Multi-Threaded Garbage Collection on
Virtually Shared Memory Architectures",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "179--199",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{c++:gc:1093,
author = "A. D. Samples",
title = "Garbage Collection-Cooperative {C}++",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "315--329",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:1095,
author = "E. K. Kolodner and W. E. Weihl",
title = "Atomic Incremental Garbage Collection",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "365--387",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
publisher = "Springer-Verlag",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:1097,
author = "M. S. Lam and P. R. Wilson and T. G. Moher",
title = "Object Type Directed Garbage Collection to Improve
Locality",
number = "637",
series = "Lecture Notes in Computer Science",
pages = "404--425",
booktitle = "Proc.\ Int.\ Workshop on Memory Management",
year = "1992",
address = "Saint-Malo (France)",
month = sep,
}
@InProceedings{gc:mv:1110,
author = "M. Wolczko and I. Williams",
title = "Multi-Level Garbage Collection in a High-Performance
Persistent Object System",
pages = "395--418",
booktitle = "Proc.\ of the Fifth International Workshop on
Persistent Object Systems Design, Implementation and
Use",
year = "1992",
address = "San Miniato Pisa (Italy)",
month = sep,
}
@Article{gc:par:1130,
author = "Jan E. Jonker",
title = "On-the-Fly Garbage Collection for Several Mutators",
journal = "Distributed Computing",
year = "1992",
number = "5",
pages = "187--199",
month = jan,
}
@InProceedings{Detlefs92,
author = "David Detlefs",
title = "Garbage Collection and Run-Time Typing as a {C}++
Library",
booktitle = "C++ Conference Proceedings",
location = "Digital Equipment Corporation",
pages = "37--56",
publisher = "USENIX",
address = "Portland, OR",
month = aug # " 10-13",
year = "1992",
}
@InProceedings{Merrall_Padget:92,
author = "S. C. Merrall and J. A. Padget",
title = "Collections and Garbage Collection",
editor = "B. Lang",
number = "637",
series = "LNCS",
pages = "473--489",
booktitle = "Proc. of International Workshop on Memory Management",
year = "1992",
publisher = "Springer Verlag",
}
@TechReport{Kusc92a,
author = "Klaus Kusche",
title = "{Practical Experiments with Various Garbage Collection
Methods}",
number = "92-07",
institution = "RISC-Linz",
address = "Johannes Kepler University, Linz, Austria",
year = "1992",
}
@InProceedings{lan:gc:1035,
author = "Amer Diwan and Eliot Moss and Richard Hudson",
title = "Compiler Support for Garbage Collection in a
Statically Typed Language",
number = "27(7)",
series = "SIGPLAN Notices",
pages = "273--282",
booktitle = "Proc.\ Conf.\ on Programming Language Design and
Implementation",
year = "1992",
organization = "ACM SIGPLAN",
address = "San Francisco, CA ({USA})",
month = jun,
}
@TechReport{WiLM90b,
title = "Caching Consideration For Generational Garbage
Collection",
author = "Paul R. Wilson and Michael S. Lam and Thomas G.
Moher",
institution = "University of Illinois at Chicago EECS Dept.",
type = "Technical Report",
number = "UIC-EECS-90-5",
address = "Chicago, Illinois",
month = Dec,
year = "1990",
note = "A much improved version will appear in ACM 1992 Conf
on Lisp and Functional Programming. Technical summary
available from wilson@cs.utexas.edu",
}
@Article{HerlihyMoss92,
key = "Herlihy \&{} Moss",
author = "M. P. Herlihy and J. E. B. Moss",
title = "Lock-Free Garbage Collection for Multiprocessors",
journal = "IEEE Transactions on Parallel and Distributed
Systems",
pages = "304--311",
volume = "3",
number = "3",
month = may,
year = "1992",
location = "CMU E\&{}S Library",
}
@Article{FernandezHanson92,
key = "Fernandez \&{} Hanson",
author = "M. F. Fernandez and D. R. Hanson",
title = "Garbage Collection Alternatives for Icon",
journal = "Software - Practice And Experience",
pages = "659--672",
volume = "22",
number = "8",
month = aug,
year = "1992",
location = "CMU Engineering \&{} Science Library",
}
@TechReport{Lester92,
author = "D. Lester",
title = "Distributed Garbage Collection of Cyclic Structures
(Draft version)",
institution = "Technical University of Aachen (RWTH Aachen)",
number = "92-19-19",
year = "1992",
url = "ftp://ftp.informatik.rwth-aachen.de/pub/reports/1992/92-19-19.ps.gz",
}
@TechReport{Bansal92,
author = "Arvind K. Bansal and Jerry Potter",
title = "Exploiting Data Parallelism for Large Knowledge
Bases",
institution = "Kent State University",
number = "CS-9202-03",
year = "1992",
url = "mailto::sommers@mcs.kent.edu",
abstract = "A model is presented which exploits data level massive
parallelism present in associative computers for the
efficient execution of logic programs with large
knowledge bases. The exploitation of data parallelism
in goal reduction efficiently prunes non-unifiable
clauses resulting into effective reduction of shallow
backtracking, and marks the potential bindings for the
variables with single occurrence in a manner which is
independent of the number of clauses. During deep
backtracking, bindings are released simultaneously
using associative search resulting in a significant
reduction in execution time overhead of backtracking
and garbage collection. A scheme for a logical data
structure representation incorporating direct interface
between lists and vectors is described. This allows the
efficient integration of symbolic computation and a
large class of vectorizable numerical computation on
associative supercomputers.",
}
@TechReport{UIUCDCS-R-1992-1740,
author = "Nalini Venkatasubramanian and Gul Agha and Carolyn
Talcott",
title = "Hierarchical garbage collection in scalable
distributed systems",
institution = "Department of Computer Science, University of Illinois
at Urbana-Champaign",
address = "Urbana, Illinois",
year = "1992",
number = "1740",
pages = "20",
}
@PhdThesis{MIT/LCS/TR-534,
author = "E. K. Kolodner",
title = "{ATOMIC} {INCREMENTAL} {GARBAGE} {COLLECTION} {AND}
{RECOVERY} {FOR} {A} {LARGE} {STABLE} {HEAP}",
school = "MIT Laboratory for Computer Science",
type = "Ph.{D}. Thesis",
number = "MIT/LCS/TR-534",
pages = "191",
month = feb,
year = "1992",
price = "USD 21.00",
abstract = "A stable heap is a storage that is managed
automatically using garbage collection, manipulated
using atomic transactions, and accessed using a uniform
storage model. These features enhance reliability and
simplify programming by preventing errors due to
explicit deallocation, by masking failures and
concurrency using transactions, and by eliminating the
distinction between accessing temporary storage and
permanent storage. Stable heap management is useful for
programming language for reliable distributed
computing, programming languages with persistent
storage, and object-oriented database systems. Many
applications that could benefit from a stable heap
(e.g., computer-aided design, computer-aided software
engineering, and office information systems) require
large amounts of storage, timely responses for
transactions, and high availability. We present garbage
collection and recovery algorithms for a stable heap
implementation that meet these goals and are
appropriate for stock hardware. The collector is
incremental: it does not attempt to collect the whole
heap at once. The collector is also atomic: it is
coordinated with the recovery system to prevent
problems when it moves and modifies objects. The time
for recovery is independent of heap size, and can be
shortened using checkpoints.",
}
@TechReport{MIT/LCS/TR-555,
author = "J. E. {Hicks, Jr.}",
title = "{COMPILER}-{DIRECTED} {STORAGE} {RECLAMATION} {USING}
{OBJECT} {LIFETIME} {ANALYSIS}",
institution = "MIT Laboratory for Computer Science",
number = "MIT/LCS/TR-555",
pages = "183",
month = nov,
year = "1992",
price = "USD 21.00",
abstract = "Many heap-oriented languages such as Lisp and Id
depend on run-time garbage collection to reclaim
storage. Garbage collection can be a significant
run-time expense, especially for functional languages
that tend to allocate structures often.
Compiler-directed storage reclamation reduces the
run-time overhead of garbage collection by having the
compiler insert deallocation code. Compilers must
perform object lifetime analysis in order to insert
storage reclamation code. Current approaches to
lifetime analysis assume a strict or sequential
interpreter. We formulate an operational semantics for
a parallel, non-strict language in order to precisely
define when it is safe to deallocate an object. Our
operational semantics yields exact information about
what objects are allocated, deallocated, and referenced
at any point during the execution of a program. Using
this information, we define precise run-time conditions
that must be met by safe deallocation commands. We use
abstract interpretation to yield at compile-time a
summary of what objects are allocated and reachable at
any point in a program. We define static conditions
that must be met by safe deallocation commands. We
describe our implementation of the lifetime analysis,
the verification algorithm, and the insertion
algorithm. We then discuss the effectiveness of the
compiler at verifying and inserting deallocation
commands in several medium-sized Id programs. We also
discuss the performance of each program in terms of
storage allocated and reclaimed. Our implementation is
quite effective for programs with simple patterns of
sharing between objects.",
}
@InProceedings{Goldberg92,
author = "Goldberg",
title = "Incremental Garbage Collection without Tags",
booktitle = "4th European Symposium on Programming",
year = "1992",
}
Found 63 references in 29 bibliographies.
You used 21 seconds of our CPU time.