for "garbage" and "collection" and "1990"
Search term: garbage;collection;1990
No spelling errors allowed, case-insensitive, partial words match.
Information on how to form queries.
@InProceedings{Mulkers90,
author = "A. Mulkers and W. Winsborough and M. Bruynooghe",
title = "{Analysis of Shared Data Structures for Compile-Time
Garbage Collection in Logic Programs}",
booktitle = "{Seventh International Conference on Logic Programming
(ICLP-90)}",
address = "Jerusalem, Israel",
month = jun,
year = "1990",
}
@InCollection{B185,
author = "T Jensen and T Mogensen",
title = "A backwards analysis for compile time garbage
collection",
booktitle = "ESOP'90, Copenhagen, Denmark",
series = "LNCS",
volume = "432",
pages = "227--239",
publisher = "Springer-Verlag",
year = "1990",
}
@InProceedings{Co:ERWGCM,
author = "H. Corporaal and T. Veldman and A. J. van de Goor",
title = "{An Efficient, Reference Weightbased Garbage
Collection Method for Distributed Systems}",
booktitle = "Proceedings of the PARBASE-90 Conference",
year = "1990",
pages = "463--465",
publisher = "{IEEE}",
}
@TechReport{WiLM90b,
title = "Caching Consideration For Generational Garbage
Collection: {A} Case For Large and Set-Associative
Caches",
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",
}
@InProceedings{PRWMSLTGM,
author = "${}^{\surd\clubsuit}$Paul R. Wilson and Michael S. Lam
and Thomas G. Moher",
title = "Caching Considerations for Generational Garbage
Collection",
crossref = "LFP92",
pages = "32--42",
note = "Also Technical Report, {EECS} Dept., {UIC-EECS-90-5},
University of Illinois at Chicago, December 1990",
}
@MastersThesis{Jensen:90:ContextAnalysis,
author = "Thomas P. ${}^{\clubsuit}$Jensen",
title = "Context Analysis of Functional Programs",
school = "DIKU, Denmark",
year = "1990",
semno = "D-45",
OPTaddress = "",
month = Jan,
note = "65 pages",
summary = "Contexts are introduced as a means for describing the
use of a data structure. A backwards analysis for
determining contexts is developed and used to optimise
the use of storage in functional programs.",
keywords = "backwards analysis, compile-time garbage collection",
}
@InProceedings{Jensen:90:ABackwardsAnalysisForCompiler-time,
author = "Thomas P. ${}^{\clubsuit}$Jensen and Torben Mogensen",
title = "A Backwards Analysis for Compile-time Garbage
Collection",
booktitle = "ESOP '90, Copenhagen, Denmark (Lecture Notes in
Computer Science, vol. 432)",
year = "1990",
semno = "D-22",
OPTeditor = "",
pages = "227--239",
OPTorganization = "",
publisher = "Springer-Verlag LNCS 432",
OPTaddress = "",
OPTmonth = "",
summary = "A backwards analysis for determining the use of a data
structure is developed. It is shown how this analysis
can be used to optimise the use of storage in first and
higher order functional programs.",
keywords = "backwards analysis, compile-time garbage collection",
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%
%%%% Positional Papers for 1990 OOPSLA workshop on Memory Management
%%%% and Garbage Collection
%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@Misc{DEIP:OOPSLAGC90,
author = "D. ${}^{\clubsuit}$Edelson and I. Pohl",
title = "The Case for Garbage collection in {C}++",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
@Misc{JDT:OOPSLAGC90,
author = "${}^{\clubsuit}$John DeTreville",
title = "Experience with Garbage Collection for Modula-2+ in
the Topaz Environment",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
@Misc{MWIW:OOPSLAGC90,
author = "Mario ${}^{\clubsuit}$Wolczko and Ifor Williams",
title = "Garbage collection in High-Performance System",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
@Misc{PF:OOPSLAGC90,
author = "Paulo ${}^{\clubsuit}$Ferreira",
title = "Storage Reclamation",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
@Misc{BZ:OOPSLAGC90,
author = "Benjamin ${}^{\clubsuit}$Zorn",
title = "Designing Systems for Evaluation: {A} Case Study of
Garbage Collection",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
@Misc{BH:OOPSLAGC90,
author = "Barry ${}^{\clubsuit}$Hayes",
title = "Open Systems Require Conservative Garbage Collection",
howpublished = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems. Summary appears in
\cite{JJ:GCOOS}",
month = oct,
year = "1990",
}
%L Kafu90a
%K olit oopsla90 ecoop90
%A Dennis Kafura
%A Douglas Washabaugh
%A Jeff Nelson
%T Garbage Collection of Actors
%J Proceedings OOPSLA/ECOOP '90, ACM SIGPLAN Notices
%V 25
%N 10
%D Oct 1990
%P 126-134
@InProceedings{Miller90,
author = "J. Miller and B. Epstein",
title = "Garbage Collection in {M}ulti{S}cheme",
crossref = "ParallelLisp90",
year = "1990",
pages = "138--160",
}
@InProceedings{Co:ERWGCM,
author = "H. Corporaal and T. Veldman and A. J. {Goor, van de}",
title = "An Efficient, Reference Weight based Garbage
Collection Method for Distributed Systems",
booktitle = "Proceedings of the PARBASE-90 Conference",
year = "1990",
pages = "463--465",
publisher = "{IEEE}",
}
@Article{De:MSGCDA,
author = "Margaret H. Derbyshire",
title = "Mark Scan Garbage Collection on a Distributed
Architecture",
journal = "Lisp and Symbolic Computation",
year = "1990",
month = apr,
volume = "3",
number = "2",
pages = "135--170",
}
@TechReport{HMCRLDEC,
author = "${}^{\clubsuit}$Maurice Herlihy and J. Eliot B. Moss",
title = "Non-Blocking Garbage Collection for Multiprocessors",
institution = "Cambridge Research Labs, DEC",
year = "1990",
number = "90/9",
note = "Available by anonymous ftp from crl.dec.com in the
/pub/DEC/CRL/tech-reports directory",
}
@MastersThesis{Stapleton90,
author = "Susan Mayer Stapleton",
title = "Real-time garbage collection for general-purpose
languages",
year = "1990",
school = "Iowa State University",
}
@TechReport{NS:HARTGC,
author = "Kelvin Nilsen and William J. Schmidt",
title = "A High-Level Overview of Hardware Assisted Real-Time
Garbage Collection",
institution = "Dept. of Computer Science, Iowa State University",
address = "Ames, Iowa",
year = "1990",
number = "TR 90-18a",
}
@InProceedings{DMWDKieeertss90,
author = "Douglas M. Wasahbaugh and Dennis Kafura",
title = "Incremental Garbage Collection of Concurrent Objects
for Real-time Applications",
booktitle = "IEEE Real-Time Systems Symposium",
pages = "21--30",
month = dec,
year = "1990",
}
@Article{Yu:RTGCGPM,
title = "Real-Time Garbage Collection on General-Purpose
Machines",
author = "Taichi Yuasa",
journal = "Journal of Systems and Software",
year = "1990",
volume = "11",
pages = "181--198",
}
@Proceedings{OOPSLA-GC90,
title = "Workshop on Garbage Collection",
booktitle = "{OOPSLA/ECOOP} Workshop on Garbage Collection in
Object-Oriented Systems",
key = "{OOPSLA}",
month = oct,
year = "1990",
publisher = "{ACM} Press",
}
@InProceedings{Hudak:Keller:acm:lfp:1982,
author = "Paul Hudak and Robert M. Keller",
title = "Garbage Collection and Task Deletion in Distributed
Applicative Processing",
crossref = "acm:lfp:1982",
pages = "168--178",
checked = "19940213",
source = "dept. library",
keywords = "distributed garbage collection",
abstract = "The problem of automatic storage reclamation for
distributed implementations of applicative languages is
explored. Highly parallel distributed systems have
several unique characteristics that complicate the
reclamation process; in this setting, the deficiencies
of existing storage reclamation schemes are thus noted.
A real-time, effectively distributed, garbage collector
of the mark-sweep variety, called a {\em marking-tree
collector}, is shown to accomplish reclamation in
parallel with the main computation, with no centralized
data or control other than a logical rendezvous between
phases of the collector. In addition, it is capable of
finding and subsequently deleting active processes
which are determined to be no longer relevant to the
computation.",
reffrom = Eckart:LeBlanc:iait:1987,
reffrom = Osborne:acm:lfp:1990,
}
@InProceedings{Brown:rfc:1990a,
author = "R. J. Brown",
title = "Non-Local Exits and Stacks Implemented as Trees",
crossref = "rfc:1990",
checked = "19931205",
keywords = "abstract",
abstract = "A vectored {\bf ABORT} permits the programmer to
recover from certain errors. Some other programming
languages have more sophisticated constructs for this
kind of occurrence: PL/1 has ON conditions; Ada has
EXCEPTIONs; C has setjmp and longjmp; Lisp has CATCH,
THROW, UNWIND-PROTECT, and RETURN-FROM; Prolog has CUT
and FAIL; Icon has the capability for failed
statements. An implementation of {\bf CATCH}, {\bf
THROW}, and {\bf UNWIND-PROTECT} for LMI UR/FORTH will
be discussed, and placed in perspective along with
these foreign language non-local exits. A discussion of
{\bf RETURN-FROM} and {\em bf FAIL}, and their utility
when debugging, will be discussed. The simple
one-dimensional contiguous array implementation of a
stack found in most Forth systems is not really
adequate to implement {\bf CATCH}, {\bf THROW}, and {bf
UNWIND-PROTECT}: the independence of the parameter
stack from the nesting of words, a hallmark of Forth,
can cause the stack to be improperly restored when a
throw is caught. It is totally incapable of
implementing {\bf FAIL}. {\bf RETURN-FROM} can be
confused because of applications program information
temporarily pushed onto the return stack. An
implementation of a stack as a singly linked tree, with
reference counts to eliminate garbage collection, will
be discussed, along with the fuller capabilities given
to the non-local exits. A tree implementation of stacks
in software has excessive overhead for high-end
real-time systems, but the memory allocation and
freeing algorithms for such a stack are simple enough
to permit their implementation in hardware. A hardware
stack controller using hardware memory management will
be explored that implements multiple stacks with shared
sub-structure as singly linked trees with reference
counts.",
}
@InProceedings{Wakeling:Runciman:fplca:1991,
author = "David Wakeling and Colin Runciman",
email = "{dw,colin}@minster.york.ac.uk",
title = "Linearity and Laziness",
crossref = "fplca:1991",
pages = "215--240",
refs = "28",
checked = "19940811",
source = "Main library",
abstract = "A criticism often levelled at functional languages is
that they do not cope elegantly or efficiently with
problems involving changes of state. In a recent
paper~\cite{Wadler:pcam:1990}, Wadler has proposed a
new approach to these problems. His proposal involves
the sue of a type system based on the linear logic of
Girard~\cite{Girard:tcs:1987}. This allows the
programmer to specify the ``natural'' imperative
operations without at the same time sacrificing the
crucial property of referential transparency. \par In
this paper we investigate the practicality of Wadler's
approach, describing the design and implementation of a
variant of Lazy ML. A small example program shows how
imperative operations can be used in a referentially
transparent way, and at the same time it highlights
some of the problems with the approach. Our
implementation is based on a variant of the
G-Machine~\cite{Johnsson:phd:1987,Augustsson:phd:1987}.
We give some benchmark figures to compare the
performance of our machine with the original one. the
results are disappointing: the cost of maintaining
linearity in terms of lost optimisations at
compile-time, and the extra data structures that must
be created at run-time more than cancels out the gains
made by using linear types to reduce the amount of
garbage collection. We also consider how the language
and the implementation can be extended to accommodate
aggregates such as arrays. here the results are more
promising: linear arrays are usually more efficient
than trailered ones, but they are less efficient than
destructively-updated ones. We conclude that larger
aggregates are the most promising area of application
for Wadler's type system.",
}
@InProceedings{KITSUREGAWA89,
key = "Kitsuregawa et al.",
author = "M. Kitsuregawa and L. Harada and M. Takagi",
title = "Join Strategies on {KD}-Tree Indexed Relations",
booktitle = "Proceedings of the Fifth International Conference on
Data Engineering",
address = "Los Angeles, CA",
month = feb,
year = "1989",
pages = "85--93",
abstract = "In this paper we present efficient join algorithms on
very large relations indexed by KD-trees. There are
previous works proposing the join on multi-attribute
clustered relations based on hashing and also on
grid-partitioning, whose shortcomings are non-order
preservation and low load-factor, respectively. KD-tree
indexed relations are characterized by preserving data
order and maintaining high load-factors. However,
KD-tree indexing has the disadvantage of generating
clusters which are overlapped in the join attribute
domain, what causes a very high I/O cost for naive join
algorithms. Here we analyze strategies to deal with
this problem and introduce efficient algorithms to join
two non-resident relations indexed by KD-trees. First
we introduce the concept of wave, which is a set of
pages that is the object of join processing and that
propagates over the relation space in the direction of
the join attribute axis. Based on this new concept, we
present five join algorithms and also four extended
algorithms with a garbage collection mechanism to
increase the effective space of the main memory. We
extensively evaluate these join algorithms with
analytical formulas and simulation results. It is shown
that the join of very large relations indexed by
KD-trees can be performed with one scan of the
relations.",
bibdate = "Fri Jan 12 09:43:55 1990",
owner = "robyn",
}
@InProceedings{Kolodner90,
author = "E. K. Kolodner",
title = "Atomic Incremental Garbage Collection and Recovery for
Large Stable Heap",
booktitle = "Fourth Int'l Workshop on Persistent Object Sys.",
pages = "193",
address = "Martha's Vineyard, MA",
month = sep,
year = "1990",
keywords = "POS",
}
@TechReport{IB-A911608,
author = "J. Heymann",
title = "Mathematical Modelling and Hardware Support of Garbage
Collection",
address = "Muenchen",
year = "1990",
descriptor = "Garbage collection",
annote = "Die Dissertation gibt A) einen Ueberblick ueber
Garbage Collection Algorithmen B) versucht eine
mathematische Modellierung und C) untersucht die
Moeglichkeiten der Hardware-Unterstuetzung.",
}
@Article{Wentwo90,
author = "E. P. Wentworth",
title = "Pitfalls of Conservative Garbage Collection",
journal = "Software, Practice and Experience",
volume = "20",
number = "7",
pages = "719--728",
publisher = "John Wiley & Sons , New York, NY , USA",
month = "[7]",
year = "1990",
}
@InProceedings{KaNeWa90,
author = "D. Kafura and D. Washabaugh and J. Nelson",
editor = "Norman Meyrowitz",
title = "Garbage Collection of Actors",
booktitle = "Proceedings of the Conference on Object-Oriented
Programming Systems, Languages, and Applications
European Conference on Object-Oriented Programming
(OOPSLA) (ECOOP)",
pages = "126--134",
publisher = "ACM Press , New York, NY , USA",
address = "Ottawa, ON CDN",
month = "[10]",
year = "1990",
note = "Published as SIGPLAN Notices, volume 25, number 10",
}
@InProceedings{JuulNielsC1990a,
author = "Niels Christian Juul",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{A} dsutributed garbage collector for emerald",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Juul.ps.Z",
keywords = "incremental mark-sweep",
scope = "gc",
}
@InProceedings{MossJEliot1990a,
author = "J. Eliot B. Moss",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{G}arbage collecting persistent object stores",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Moss.ps.Z",
scope = "gc",
}
@InProceedings{HudsonRich1990a,
author = "Richard Hudson",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{A}daptive garbage collection for {M}odula-3 and
{S}malltalk",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Hudson.ps.Z",
keywords = "generational",
scope = "gc",
}
@InProceedings{BartlettJo1990a,
author = "Joel F. Bartlett",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{A} generational compacting garbage collector for
{C}++",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Bartlett.ps.Z",
scope = "gc",
}
@InProceedings{DeTreville1990a,
author = "John DeTreville",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{E}xperience with garbage collection for {M}odule-2+
in the {T}opaz environment",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/DeTreville.ps.Z",
keywords = "reference counting",
scope = "gc",
}
@InProceedings{BengtssonM1990a,
author = "Mats Bengtsson",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{R}eal-time compacting garbage collection",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Bengtsson.ps.Z",
scope = "gc",
}
@InProceedings{LiKai1990a,
author = "Kai Li",
booktitle = "ECOOP/OOPSLA Workshop on Garbage Collection in
Object-Oriented Systems",
title = "{R}eal-time concurrent collection in user mode",
year = "1990",
address = "Ottawa, Canada",
url = "ftp://cs.utexas.edu/pub/garbage/GC90/Li.ps.Z",
keywords = "incremental copying",
scope = "gc",
}
@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{WEISER89,
key = "Weiser et al.",
author = "M. Weiser and A. Demers and C. Hauser",
title = "The Portable Common Runtime Approach to
Interoperability",
booktitle = "Proceedings of the Twelfth ACM SOSP",
address = "Litchfield Park, AZ",
volume = "23",
month = dec,
year = "1989",
pages = "114--122",
abstract = "Operating system abstractions do not always reach high
enough for direct use by a language or applications
designer. The gap is filled by language-specific
runtime environments, which become more complex for
richer languages (CommonLisp needs more than C++, which
needs more than C). But language-specific environments
inhibit integrated multi-lingual programming, and also
make porting hard (for instance, because of operating
system dependencies). To help solve these problems, we
have built the Portable Common Runtime (PCR), a
language-independent and operating-system-independent
base for modern languages. PCR offers four interrelated
facilities: storage management (including universal
garbage collection), symbol binding (including static
and dynamic linking and loading), threads (lightweight
processes ), and low-level I/O (including network
sockets). PCR is 'common' because these facilities
simultaneously support programs in several languages.
PCR supports C, Cedar, Scheme, and CommonLisp
intercalling and runs pre-existing C and CommonLisp
(Kyoto) binaries. PCR is 'portable' because it uses
only a small set of operating system features. The PCR
source code is available for use by other researchers
and developers.",
bibdate = "Thu Jan 11 11:00:07 1990",
owner = "robyn",
}
@InCollection{Hamilton91,
author = "G. W. Hamilton and S. B. Jones",
editor = "S. L. {Peyton Jones} and G. Hutton and C. K. Holst",
title = "Compile-Time Garbage Collection by Necessity
Analysis",
booktitle = "Functional Programming, Glasgow 1990",
pages = "66--70",
publisher = "Springer-Verlag",
address = "London, UK",
year = "1991",
keywords = "peyton jones",
}
@InCollection{Jones91,
author = "S. B. Jones and M. White",
editor = "S. L. {Peyton Jones} and G. Hutton and C. K. Holst",
title = "Is Compile Time Garbage Collection Worth The Effort?",
booktitle = "Functional Programming, Glasgow 1990",
pages = "172--176",
publisher = "Springer-Verlag",
address = "London, UK",
year = "1991",
keywords = "peyton jones",
}
@Article{Martinez90,
author = "A. D. Martinez and R. Wachenchauzer and R. D. Lins",
title = "Cyclic Reference Counting with Local Mark-Scan",
journal = "Information Processing Letters,",
volume = "34",
pages = "31--35",
year = "1990",
keywords = "functional graph reduction",
abstract = "The process of reclaiming storage space which is no
longer needed is called Garbage Collection. The two
most simple algorithms used for garbage collection are
mark-scan and reference counting. We present a general
garbage collection algorithm based on reference
counting, that deals with cyclic data structures and
prove its correctness.",
}
@TechReport{gc:c++:629,
author = "David L. Detlefs",
title = "Concurrent Garbage Collection for {C++}",
institution = "Department of Computer Science, Carnegie-Mellon
University",
year = "1990",
number = "CMU-CS-90-119",
address = "Pittsburgh {PA} ({USA})",
month = may,
}
@InProceedings{gc:rep:675,
author = "Marc Shapiro",
title = "Distributed Object-Support Operating Systems and
Garbage Collection",
booktitle = "Workshop on Garbage Collection at ECOOP\slash OOPSLA
1990",
year = "1990",
address = "Ottawa (Canada)",
month = oct,
}
%Misc{gc:677,
% author = "G. Tel and F. Mattern",
% title = "The Derivation of Distributed Termination Detection
Algorithms from Garbage Collection Schemes",
% year = 1990,
% month = jul
%}
@TechReport{nom:678,
author = "Mic Bowman and Saumya K. Debray and Larry L.
Peterson",
title = "Reasoning About Naming Systems",
institution = "Dept.\ of Comp.\ Sc., U.\ of Arizona",
year = "1990",
number = "TR 90-19",
address = "Tucson, AZ ({USA})",
month = may,
}
%Misc{gc:rep:684,
% author = "Martin Rudalics",
% title = "Correctness of Distributed Garbage Collection Algorithms",
% year = 1990,
% month = jul
%}
@InProceedings{prs:gc:919,
author = "Elliot K. Kolodner",
title = "Atomic Incremental Garbage Collection and Recovery for
a Large Stable Heap",
pages = "185--198",
booktitle = "Proceedings of the Fourth International Workshop on
Persistent Object Systems",
year = "1990",
address = "Martha's Vineyard, MA {(USA)}",
month = sep,
}
@InProceedings{Sciver90,
author = "Jim Van Sciver",
title = "Zone Garbage Collection",
booktitle = "Mach Workshop Conference Proceedings",
location = "Open Software Foundation",
pages = "1--16",
publisher = "USENIX",
address = "Burlington, VT",
month = oct # " 4-5",
year = "1990",
}
@InProceedings{Monitors-12,
author = "Robert Seliger",
title = "Extending {C++} to Support Remote Procedure Call,
Concurrency, Exception Handling, and Garbage
Collection",
booktitle = "USENIX C++ Conference Proceedings",
year = "1990",
pages = "241--261",
address = "San Francisco, California",
month = "9--11 " # apr,
annote = "The concurrency mechanism used is a variation of
monitors. As such it is not very exciting but it has
been integrated quite well into the C++ language. What
is most surprising is that Monitors are still being
used 16 years after Hoare's paper on them. Not too many
other high level synchronisation mechanisms can claim
that (Path Expressions being the only other example
that springs to mind).",
keywords = "k-monitors, k-C++, k-exceptions, k-RPC,
k-garbage-collection",
}
@InProceedings{Kuechlin:90,
author = "Wolfgang K{\"u}chlin",
title = "{The S-Threads Environment for Parallel Symbolic
Computation}",
booktitle = "{Computer algebra and parallelism, Proceedings of the
second International Workshop on Parallel Algebraic
Computation}",
editor = "Zippel",
address = "Ithaca, USA, May",
year = "1990",
publisher = "LNCS 584, Springer Verlag",
pages = "1--18",
abstract = "This paper presents a programming environment, based
on {\em threads of control}, that is suitable for
parallel {\em symbolic} computation on shared memory
multiprocessors. The S-threads system offers a solution
to the problem of whether to have heap memory shared
and global, or distributed, and local to threads. The
memory structure makes it particularly easy to reclaim,
without garbage collection, all intermediate list
memory used by an algorithm; under some additional
resstrictions, S-threads may alpso perform independent
garbage collections. The S-threads environment is being
used in the construction of the PARSAC system, a
parallel version of the SAC-2 Computer Algebnra System.
To dat, in Summer 1990, PARSAC-2.1 contains parallel
algorithms for integer multiplication and for isolating
the real roots of integer polynomials work on parallel
multivariate polynomial g.c.d. calculation and on
parallel root isolation of algebraic polynomials is
under way. S-threads and PARSAC-2 are implemented on an
Encore Multimax, based on the C Threads environment
emulated by Encore Parallel Threads.",
}
@InProceedings{DWH*90,
author = "Alan Demers and Mark Weiser and Barry Hayes and Hans
Boehm and Daniel Bobrow and Scott Shenker",
title = "{Combining Generational and Conservative Garbage
Collection: Framework and Implementations}",
booktitle = "{Seventeenth Annual ACM Symposium onn Principles of
Programming Languages}",
address = "San Francisco, California, January 17--19",
year = "1990",
publisher = "ACM Press, New York",
pages = "261--269",
owner = "pcl",
descr = "pagc",
}
@Article{Went90,
author = "E. P. Wentworth",
title = "{Pifalls of Conservative Garbage Collection}",
journal = "{Software --- Practice and Experience}",
year = "1990",
volume = "20",
number = "7",
pages = "719--727",
month = jul,
owner = "pcl",
descr = "pagc",
}
@TechReport{Ruda90b,
author = "Martin Rudalics",
title = "{Correctness of Distributed Garbage Collection
Algorithms}",
type = "Technical Report",
month = aug,
year = "1990",
institution = "RISC-Linz",
address = "Johannes Kepler University, Linz, Austria",
number = "90-40.0",
note = "Also: ACPC Technical Report ACPC/TR 91-5, Austrian
Center for Parallel Computation, January 1991",
owner = "pcl",
descr = "pagc",
}
@InProceedings{GCandMH,
author = "Paul R. Wilson",
title = "Some Issues and Strategies in Heap Management and
Memory Hierarchies",
booktitle = "{OOPSLA/ECOOP} '90 Workshop on Garbage Collection in
Object-Oriented Systems",
note = "Also in {\em SIGPLAN Notices 23}(1):45--52, January
1991.",
month = oct,
year = "1990",
}
@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",
}
@InProceedings{Zorn,
author = "Benjamin Zorn",
title = "Comparing Mark-and-sweep and Stop-and-copy Garbage
Collection",
booktitle = "Proceedings of the 1990 ACM Conference on Lisp and
functional rogramming",
abstract = "Stop-and-copy garbage collection has been preferred to
mark-and-sweep collection in the last decade because
its collection time is proportional to the size of
reachable data and not the memory size. This paper
compares the CPU overhead and the memory requirements
of the two collection algorithms extended with
generations, and finds that mark-and-sweep collection
requires at most a small amount of additional CPU
overhead (3-6%) but requires an average of 20% (and up
to 40%) less memory to achieve the same page fault
rate. The comparison is based on results obtained using
trace-driven simulation with large Common Lisp
programs",
month = jun,
year = "1990",
}
@TechReport{Detreville90,
author = "John D. Detreville",
title = "Heap Usage in the Topaz Environment",
institution = "Digital Equipment Corporation, Systems Research
Centre",
number = "63",
pages = "42 pages",
month = "20 " # aug,
year = "1990",
abstract = "Topaz, the experimental computing environment built
and used at SRC, is implemented in the Modula-2+
programming language, which provides garbage
collection. Garbage collection simplifies the
construction of complex systems, and is tied to a
number of other Topaz and Modula-2+ features, such as
runtime polymorphism, language safety,
information-hiding, object cleanup, persistent objects,
and network objects. Although there are costs to using
garbage collection, these are avoided or tolerated in
Topaz. For example, because Topaz must avoid noticeable
interruption of service due to garbage collection, it
uses a concurrent garbage collector. Measurements show
that the use of the REF heap in Topaz is similar in
many ways to the use of heaps in Lisp-like
environments, but different in others. For example, in
typical large programs, the REF heap contains millions
of bytes, with tens of thousands of objects from among
hundreds of statically-declared types; objects of only
a few types predominate. Although most objects are
small, most bytes are in relatively large objects.
Cycles are rare; most cycles are of size 2. Most
objects are short-lived, but not as short-lived as in
Lisp-like environments that allocate large amounts of
ephemeral data on the heap.",
}
@TechReport{Detreville90a,
author = "John Detreville",
title = "Experience with Concurrent Garbage Collectors for
Modula-2+",
institution = "Digital Equipment Corporation, Systems Research
Centre",
number = "64",
pages = "54 pages",
month = "22 " # nov,
year = "1990",
abstract = "Garbage collection is an integral component of
Modula-2+, the principal systems programming language
at SRC. The initial Modula-2+ collector was a
concurrent reference-counting collector; it did not
reclaim cyclic structures, and the cost of assigning
references was relatively high. I implemented three
experimental collectors for Modula-2+ and tested them
to explore alternatives to the initial collector: first
a simple concurrent mark-and-sweep collector; then a
modified concurrent mark-and-sweep collector that used
VM synchronization between the mutator and the
collector; and then a concurrent mostly-copying
collector that also used VM synchronization. These
collectors had advantages and disadvantages compared to
the initial Modula-2+ collector. They reclaimed cyclic
structures and tended to reduce the cost of
assignments, but they provoked VM thrashing far more
readily and sometimes produced noticeable interruptions
of service. For this reason, we adopted a combined
reference-counting and mark-and-sweep collector for
Modula-2+ at SRC, in which the reference-counting
collector reclaims most garbage and the mark-and-sweep
collector executes infrequently to reclaim cyclic
garbage.",
}
@TechReport{Pallas90,
author = "Joseph Ira Pallas",
title = "Multiprocessor smalltalk: implementation, performance,
and analysis",
institution = "Stanford University",
number = "CSL-TR-90-429",
pages = "140",
month = jun,
year = "1990",
abstract = "Multiprocessor Smalltalk demonstrates the value of
object-oriented programming on amultiprocessor. Its
implementation and analysis shed light on three areas:
concurrent programming in an object-oriented language
without special extensions, implementation techniques
for adapting to multiprocessors, and performance
factors in the resulting system. Multiprocessor
Smalltalk's performance shows that the combination of
multiprocessing and object-oriented programming can be
effective: speedups (relative to the original serial
version) exceed 2.0 for five processors on all the
benchmarks; the median efficiency is 48\%. Analysis
shows both where performance is lost and how to improve
and generalize the experimental results. Changes in the
interpreter to support concurrency add at most 12\%
overhead; better access to per-process variables could
eliminate much of that. Changes in the user code to
express concurrency add as much as 70\% overhead; this
overhead could be reduced to 54\% if blocks (lambda
expressions) were reentrant. Performance is also lost
when the program cannot keep all five processors busy.
Idle time in the interpreter (up to 51\% overhead,
excluding a pathological case) could be reduced with a
parallel garbage collector to 10\%. Idle time in user
code (up to 35\% overhead) remains the programmer's
responsibility. We can identify the key characteristics
that make Multiprocessor Smalltalk successful. The
Smalltalk language allows us to build concurrent
control structures using lambda expressions without
extending the language. Inexpensive processes and
efficient garbage collection are also crucial.
Hardware/operating-system support for shared memory,
per-process variables, and inexpensive synchronization
are essential to the implementation. Given these,
object-oriented languages and multiprocessors are a
good match.",
note = "prize ($\backslash$\$14.20)",
}
@TechReport{MIT/LCS/TM-422,
author = "N. A. Lynch",
title = "{MULTIVALUED} {POSSIBILITIES} {MAPPINGS}",
institution = "MIT Laboratory for Computer Science",
number = "MIT/LCS/TM-422",
pages = "32",
month = aug,
year = "1990",
price = "USD 7.00",
keywords = "abstraction mapping, mapping, possibilities mapping,
safety property, Alternating Bit Protocol, transaction
processing, garbage collection, distributed algorithms,
time bounds, history variables",
abstract = "Abstraction mappings are one of the major tools used
to construct correctness proofs for concurrent
algorithms. Several examples are given of situations in
which it is useful to allow the abstraction mappings to
be multivalued. The examples involve algorithm
optimization, algorithm distribution, and proofs of
time bounds.",
}
Found 62 references in 22 bibliographies.
You used 21 seconds of our CPU time.