for "garbage" and "collection" and "1993"
Search term: garbage;collection;1993
No spelling errors allowed, case-insensitive, partial words match.
Information on how to form queries.
@Article{GuptaFuchs93,
key = "Gupta \&{} Fuchs",
author = "A. Gupta and W. K. Fuchs",
title = "Garbage Collection in a Distributed Object-Oriented
System",
journal = "IEEE Transactions on Knowledge and Data Engineering",
pages = "257--265",
volume = "5",
number = "2",
month = apr,
year = "1993",
location = "CMU Engineering \&{} Science Library",
}
@TechReport{total93,
author = "Mads Tofte and Jean-Pierre Talpin",
semno = "D-182",
title = "A Theory of Stack Allocation in Polymorphically Typed
Languages",
institution = "Department of Computer Science, University of
Copenhagen",
year = "1993",
number = "DIKU-report 93/15",
summary = "We present a translation scheme for the
polymorphically typed call-by-value $\lambda$-calculus.
All runtime values, including function closures, are
put into {\sl regions}. The store consists of a stack
of regions. Region inference and effect inference are
used to infer where regions can be allocated and
deallocated. Recursive functions are handled using a
limited form of polymorphic recursion. The translation
is proved correct with respect to a store semantics,
which models a region-based run-time system.
Experimental results suggest that regions tend to be
small, that region allocation is frequent and that
overall memory demands are usually modest, even without
garbage collection.",
}
@InProceedings{PMSSLPJfpca93,
crossref = "FPCA1993",
author = "${}^{\clubsuit}$Patrick M. Sansom and Simon L. Peyton
Jones",
title = "Generation Garbage Collection for Haskell",
year = "1993",
pages = "{FIND OUT}",
}
@TechReport{CMU-CS-93-210,
title = "Memory Sybsystem Performance of Programs Using Copying
Garbage Collection",
author = "Amer ${}^{\clubsuit}$Diwan and David Tarditi and Eliot
Moss",
number = "CMU-CS-93-210",
institution = "Computer science Department, Carnegie-Mellon
University",
month = dec,
year = "1993",
}
@Unpublished{Wi:GC,
author = "Paul R. Wilson",
title = "Garbage Collection",
note = "Expanded version of \cite{Wi:UGCT}, now covering
parallel, distributed, and conservative collection. In
preparation.",
year = "1993",
}
@TechReport{JREDLDDEC,
author = "John R. ${}^{\clubsuit}$Ellis and David L. Detlefs",
title = "Safe, Efficient Garbage Collection for {C}++",
institution = "DEC and Xerox Corporation",
year = "1993",
}
@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",
}
@Misc{PRWBHWs:OOPSLAGC91,
author = "${}^{\clubsuit}$Paul R. Wilson and Barry Hayes",
title = "The 1991 Workshop on Garbage Collection in
Object-Oriented Systems",
month = oct,
year = "1993",
howpublished = "Addendum to the Proceedings of OOPSLA '91, Phoenix,
AZ, 1991",
}
@Misc{EUK:OOPSLAGC93,
author = "E. Ulrich ${}^{\clubsuit}$Kriegel",
title = "A Conservative Garbage Collector for an EuLisp to
{ASM}/{C} Compiler",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{ALHRLH:OOPSLAGC93,
author = "Antony L. ${}^{\clubsuit}$Hosking and Richard L.
Hudson",
title = "Remembered Sets can also play cards",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{JRE:OOPSLAGC93,
author = "John R. ${}^{\clubsuit}$Ellis",
title = "Put Up of Shut Up",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{EFGJMC:OOPSLAGC93,
author = "${}^{\clubsuit}$Edward F. Gehringer and J. Morris
Chang",
title = "Hardware-Assisted Memory Management",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{DD:OOPSLAGC93,
author = "Dave ${}^{\clubsuit}$Detlefs",
title = "Empirical Evidence for using Garbage Collection in {C}
and {C}++ Programs",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{DS:OOPSLAGC93,
author = "Darko ${}^{\clubsuit}$Stefanovi\'{c}",
title = "The Garbage Collection Toolkit as an Experimentation
Tool",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{MWIW:OOPSLAGC93,
author = "Mario ${}^{\clubsuit}$Wolczko and Ifor Williams",
title = "An Alternative Architecture for Objects: Lessons from
the {MUSHROOM} project",
month = sep,
year = "1993",
howpublished = "{OOPSLA} 1993 Workshop on Memory Management and
Garbage Collection",
}
@Misc{HGBoopslaws1493,
author = "Henry G. {${}^{\clubsuit}$Baker, Jr.}",
title = "The Thermodynamics of Garbage Collection---{A}
Tutorial",
month = sep,
year = "1993",
howpublished = "{OOPSLA} '91 Workshop on Garbage Collection in
Object-Oriented Systems. Preliminary Version",
}
%L Asse93a
%K olit ecoop93
%A Holger Assenmacher
%A Thomas Breitbach
%A Peter Buhler
%A Volker H\:ubsch
%A Reinhard Schwarz
%T PANDA -- Supporting Distributed Programming in C++
%B Proceedings ECOOP '93
%E O. Nierstrasz
%S LNCS 707
%I Springer-Verlag
%C Kaiserslautern, Germany
%D July 1993
%P 361-383
%X PANDA is a run-time package based
on a very small operating system kernel which supports distributed
applications written in C++. It provides powerful abstractions such
as very efficient user-level threads, a uniform global address
space, object and thread mobility, garbage collection, and
persistent objects. The paper discusses the design rationales
underlying the PANDA system. The fundamental features of PANDA are
surveyed, and their implementation in the current prototype
environment is outlined.
ID:: UCB//CSD-88-443
ENTRY:: July 28, 1993
TITLE:: A Prolog Garbage Collector for Aquarius
DATE:: August 15, 1988
AUTHOR:: Touati, Herve
PAGES:: 54
ABSTRACT::
Our design is the result of an attempt to incorporate into
Prolog implementations the ideas which made generation scavenging
successful for Lisp and Smalltalk. The main challenge was to take
Prolog technique of memory recovery upon backtracking based on
stack deallocation. We were able to do so with little extra overhead
top of the global stack. This strategy has several advantages: it
improves the locality of the executing program by keeping the data
structures compacted and by allocating new objects in a fixed part
of the address space; it improves the locality and the
predictability
of the garbage collection, which can concentrate its efforts on the
fixed size area where new objects are allocated; and it allows us to
use simpler, time-efficient garbage collection algorithms. The
performance of the algorithm is further enhanced by the use of
copying algorithms whenever made possible by the deterministic
nature of the executing program.
@TechReport{CMU-CS-93-138,
title = "Concurrent Replication Garbage Collection: An
Implementation Report",
author = "${}^{\clubsuit}$James {O'Toole} and Scott Nettles",
number = "CMU-CS-93-138",
institution = "Computer science Department, Carnegie-Mellon
University",
month = apr,
year = "1993",
note = "Also appears as MIT-LCS-TR-570",
}
@TechReport{ABDEGNSOEWsrc116,
author = "${}^{\clubsuit}$Andrew Birrell and David Evers and
Greg Nelson and Susan Owicki and Edward Wobber",
title = "Distributed Garbage Collection for Network Objects",
year = "1993",
month = dec,
institution = "Digital Equipment Corporation ({SRC})",
number = "116",
}
@Article{tel:93,
author = "${}^{\clubsuit}$Gerard Tel and Friedmann Mattern",
title = "The Derivation of Distributed Termination Detection
Algorithms from Garbage Collection Schemes",
pages = "1--35",
journal = "ACM Transactions on Programming Languages and
Systems",
year = "1993",
month = jan,
volume = "15",
number = "1",
}
@Article{KNWJSJPLDI,
author = "${}^{\clubsuit}$Kelvin Nilsen and William J. Schmidt",
title = "A High-Performance Hardware Assisted Real-Time Garbage
Collection",
journal = "Journal of Programming Language Design and
Implementation",
year = "1993",
note = "To Appear",
}
@Proceedings{OOPSLA-GC93,
title = "Workshop on Garbage Collection",
booktitle = "Workshop on Garbage Collection in Object-Oriented
Systems",
key = "{OOPSLA}",
month = sep,
year = "1993",
publisher = "{ACM} Press",
}
@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.",
}
@Article{boehm:93a,
author = "Hans-Juergen Boehm",
title = "Space Efficient Conservative Garbage Collection",
pages = "197--206",
journal = "SIGPLAN Notices",
year = "1993",
month = jun,
volume = "28",
number = "6",
note = "{\em Proceedings of the ACM SIGPLAN '93 Conference on
Programming Language Design and Implementation}",
}
@Article{nettles:93,
author = "Scott Nettles and James O'Toole",
title = "Real-Time Replication Garbage Collection",
pages = "217--226",
journal = "SIGPLAN Notices",
year = "1993",
month = jun,
volume = "28",
number = "6",
note = "{\em Proceedings of the ACM SIGPLAN '93 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{Kolodner93,
author = "E. K. Kolodner and W. E. Weihl",
title = "Atomic Increment Garbage Collection and Recovery for a
Large Stable Heap",
booktitle = "Proc. ACM SIGMOD Conf.",
pages = "177",
address = "Washington, DC",
month = may,
year = "1993",
}
@InProceedings{HoelzleUrs1993a,
author = "Urs Hoelzle",
booktitle = "OOPSLA'93 Workshop on Garbage Collection",
title = "{A} {F}ast {W}rite {B}arrier for {G}enerational
{G}arbage {C}ollectors",
year = "1993",
abstract-url = "http://self.stanford.edu/papers/write-barrier.html",
address = "Washington, D.C.",
url = "ftp://self.stanford.edu/pub/papers/write-barrier.ps.Z",
month = oct,
scope = "gc",
}
@InProceedings{TarditiDav1993a,
author = "David Tarditi and Amer Diwan",
booktitle = "OOPSLA Workshop on Memory Management and Garbage
Collection",
title = "{T}he full cost of a generational copying garbage
collection implementation",
year = "1993",
url = "ftp://ftp.cs.umass.edu/pub/osl/papers/gc-workshop93a.ps.Z",
scope = "gc",
}
@InProceedings{WilsonPaul1993a,
author = "Paul R. Wilson and Mark S. Johnstone",
booktitle = "ACM OOPSLA Workshop on Memory Management and Garbage
Collection",
title = "{R}eal-{T}ime {N}on-{C}opying {G}arbage {C}ollection",
year = "1993",
abstract-url = "http://www.cs.utexas.edu/oops/papers.html#real-time-gc",
address = "Washington D.C.",
url = "file://ftp.cs.utexas.edu/pub/garbage/GC93/wilson.ps",
month = sep,
scope = "gc",
}
@TechReport{DiwanAmera1993b,
author = "Amer Diwan and David Tarditi and Eliot Moss",
institution = "Carnegie Mellon University",
title = "{M}emory {S}ubsystem {P}erformance of {P}rograms with
{I}ntensive {H}eap {A}llocation",
year = "1993",
abstract-url = "ftp://reports.adm.cs.cmu.edu/afs/cs.cmu.edu/user/dtarditi/dist/CMU-CS-93-227.abstract",
url = "ftp://reports.adm.cs.cmu.edu/usr/anon/1993/CMU-CS-93-227.ps",
keywords = "copying garbage collection heap allocation cache
memories dynamic storage management applicative
(functional) programming Standard ML simulation write
miss policy write policy",
month = dec,
number = "93-227",
type = "CS",
}
@InProceedings{BoehmHansa1993a,
author = "Hans Boehm and Zhong Shao",
title = "{I}nferring {T}ype {M}aps during {G}arbage
{C}ollection",
year = "1993",
address = "Washington, DC",
url = "ftp://daffy.cs.yale.edu/pub/papers/shao/gc.ps",
month = sep,
scope = "gc",
booktitle = "OOPSLA'93 Workshop on Memory Management and Garbage
Collection",
}
@Article{Baker:1993:LQ,
author = "Henry G. {Baker, Jr.}",
title = "A ``Linear Logic'' Quicksort",
journal = "ACM SIGPLAN Notices",
volume = "??",
number = "??",
pages = "??--??",
month = oct,
year = "1993",
bibsource = "ftp://ftp.ira.uka.de/pub/bibliography/Compiler/garbage.collection.bib",
bibdate = "Sun Sep 18 20:00:03 1994",
}
@Article{Baker:1993:SLR,
author = "Henry G. {Baker, Jr.}",
title = "Safe and Leakproof Resource Management Using Ada83
Limited Types",
journal = "ACM SIGADA Ada Letters",
volume = "13",
number = "5",
pages = "32--42",
month = sep,
year = "1993",
bibsource = "ftp://ftp.ira.uka.de/pub/bibliography/Compiler/garbage.collection.bib",
bibdate = "Sat Sep 17 20:46:11 1994",
}
@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",
}
@InCollection{Huelsbergen93,
author = "L. Huelsbergen and J. R. Larus",
title = "A Concurrent Copying Garbage Collector for Languages
that Distinguish (Im)mutable Data",
booktitle = "Fourth ACM SIGPLAN Symposium on Principles and
Practice of Parallel Programming",
pages = "73--82",
year = "1993",
keywords = "functional immutable",
abstract = "A description is given of the the design and
implementation of a concurrent compacting garbage
collector for languages that distinguish mutable data
from immutable data (e.g. ML) as well for languages
that manipulate only immutable data (e.g. pure
functional languages such as Haskell). The collector
runs on shared-memory parallel computers and requires
minimal mutator/collector synchronization. Measurements
of this collector in a Standard ML compiler on a
shared-memory computer indicate that it eliminates
perceptible garbage-collection pauses by reclaiming
storage in parallel with the computation proper. All
observed pause times are less than 20 milliseconds. The
authors describe extensions for the concurrent
collection of multiple mutator threads and refinements
to the design that can improve its efficiency.",
note = "89791 589.Published as SIGPLAN Notices, volume 28,
number 7",
}
@Article{Iwasaki93,
author = "H. Iwasaki and M. Takeuchi",
title = "Design and Implementation of a Kernel with
User-Definable Objects for Parallel Symbolic Processing
Languages",
journal = "Transactions of the Information Processing Society of
Japan",
volume = "34",
number = "8",
pages = "1752--1761",
year = "1993",
keywords = "functional transputer",
abstract = "This paper proposes a small 'kernel' named 'TK800' on
the transputer network for implementing parallel
symbolic processing languages. The TK800 kernel
provides rather high level features such as
asynchronous inter-thread communication and dynamic
thread creation. One of the most significant features
is its heap management with garbage collection, which
is designed for symbolic processing languages. TK800
kernel predefines the formats of some commonly used
object types. In addition, it provides object types
which can be defined by the user program. To define an
original object type, in most cases, the programmer has
only to decide its kind and define some macros for the
defined types mechanically. TK800 kernel has the
responsibility to collect garbage in the heap area
filled by predefined and user-defined objects. The
internal configuration of the kernel and an
implementation of a parallel functional language are
also discussed.",
}
@Article{Majeed93,
author = "A. C. Majeed and C. R. Muthukrishnan",
title = "Usage Analysis: a Compile-Time Analysis to Improve
Reference Counting",
journal = "Journal of Programming Languages",
volume = "1",
number = "2",
pages = "93--102",
year = "1993",
keywords = "functional reference counting garbage collection
G-machine",
abstract = "Garbage collection is an integral part of any
functional language implementation. Reference counting
garbage collection has attracted much attention because
of its simplicity. A simple compile-time analysis is
proposed which serves to improve the run-time
performance of a functional language implementation
that uses reference counting as a means of garbage
collection.",
}
@TechReport{Sansom93,
author = "P. M. Sansom and S. L. {Peyton Jones}",
title = "Generational Garbage Collection for Haskell",
institution = "Department of Computer Science, University of
Glasgow",
type = "Research Report",
number = "FP-1993-2",
address = "Glasgow, UK",
year = "1993",
keywords = "functional jones",
abstract = "This paper examines the use of generational garbage
collection techniques for a lazy implementation of a
non-strict functional language. Detailed measurements
which demonstrate that a generational garbage collector
can substantially out-perform non-generational
collectors, despite the frequency of write operations
in the underlying implementation, are presented. Our
measurements are taken from a state-of-the-art compiled
implementation for Haskell, running substantial
benchmark programs. We make measurements of dynamic
properties (such as object lifetimes) which affect
generational collectors, study their interaction with a
simple generational scheme, make direct performance
comparisons with simpler collectors, and quantify the
interaction with a paging system. The generational
collector is demonstrably superior. At least for our
benchmarks, it reduces the net storage management
overhead, and it allows larger programs to be run on a
given machine before thrashing ensues.",
}
@InProceedings{Asse93a,
author = "Holger Assenmacher and Thomas Breitbach and Peter
Buhler and Volker H{\"u}bsch and Reinhard Schwarz",
editor = "O. Nierstrasz",
title = "{PANDA} -- Supporting Distributed Programming in
{C}++",
booktitle = "Proceedings ECOOP '93",
series = "LNCS 707",
pages = "361--383",
publisher = "Springer-Verlag",
address = "Kaiserslautern, Germany",
month = jul,
year = "1993",
keywords = "olit ecoop93",
abstract = "$\backslash$n$\backslash$nPANDA is a run-time package
based on a very small operating system kernel which
supports distributed applications written in C++. It
provides powerful abstractions such as very efficient
user-level threads, a uniform global address space,
object and thread mobility, garbage collection, and
persistent objects. The paper discusses the design
rationales underlying the PANDA system. The fundamental
features of PANDA are surveyed, and their
implementation in the current prototype environment is
outlined.",
}
@InProceedings{gc:rep:1198,
author = "James O'Toole and Scott Nettles and David Gifford",
title = "Concurrent Compacting Garbage Collection of a
Persistent Heap",
pages = "161--174",
booktitle = "Proceedings of the 14th {ACM} Symposium on Operating
Systems Principles",
year = "1993",
address = "Asheville, NC {(USA)}",
month = dec,
}
@TechReport{gc:rep:1214,
author = "Umesh Maheshwari",
title = "Distributed Garbage Collection in a Client-Server,
Transactional, Persistent Object System",
institution = "Mass.\ Inst.\ of Technology, Lab.\ for Comp.\ Sc.",
year = "1993",
number = "MIT/LCS/TM-574",
address = "Cambridge, MA {(USA)}",
month = oct,
}
@InProceedings{ferreira:heterogeneous,
author = "Paulo Ferreira and Marc Shapiro",
title = "Distribution and Persistence in Multiple and
Heterogeneous Address Spaces",
booktitle = "Proceedings of the Third International Workshop on
Object Orientation in Operating Systems",
year = "1993",
pages = "83--93",
abstract = "We present the design of a flexible architectural
model that supports clustering, storing, naming, and
accessing objects in a large scale distributed system.
The system is logically divided in zones, i.e., groups
of machines with an homogeneous address space
organization. Both uniform (64-bit) zone-wide and
partitioned (32 or 64-bit) address space organizations
are supported. For Clustering purpos objects are
allocated within segments. Segments are logically
grouped into bunches. Each bunch has a usser-level
bunch manager implementing the policies related to
persistence and distribution specific to the bunch's
data: allocation, garbage collection, mapping and
un-mapping, function shipping or data shipping, shared
data consistency, migration, etc. Objects are
referenced by maillons and {SSP} (stub-scion pair)
chains. THese mechanisms are scalable and are well
adapted to support distributed garbage collection,
migration and compaction.",
}
%
% (Compiled by) 1993
%
% Wolfgang Schreiner <Wolfgang.Schreiner at risc.uni-linz.ac.at>
% Research Institute for Symbolic Computation (RISC-Linz)
% Johannes Kepler University, A-4040 Linz, Austria
%
% PLEASE DO NOT REMOVE THIS NOTICE.
%
% This bibliography cites and comments more than 350 publications on the
% parallel functional programming research of the last 15 years. It focuses on
% the software aspect of this area i.e. on languages, compile-time analysis
% techniques (in particular for strictness and weight analysis), code
% generation, and runtime systems. Excluded from this bibliography are
% publications on special architectures and on garbage collection unless they
% contain aspects interesting for above areas. Most bibliographic items are
% listed inclusive their full abstracts.
%
@TechReport{Schr93x,
author = "Wolfgang Schreiner",
title = "{Parallel Functional Programming --- An Annotated
Bibliography}",
institution = "RISC-Linz",
address = "Johannes Kepler University, Linz, Austria",
month = mar,
year = "1993",
abstract = "This bibliography cites and comments more than 350
publications on the parallel functional programming
research of the last 15 years. It focuses on the
software aspect of this area i.e.\ on languages,
compile-time analysis techniques (in particular for
strictness and weight analysis), code generation, and
runtime systems. Excluded from this bibliography are
publications on special architectures and on garbage
collection unless they contain aspects interesting for
above areas. Most bibliographic items are listed
inclusive their full abstracts.",
keywords = "Bibliography",
}
@Article{ImaiTick93,
key = "Imai \&{} Tick",
author = "A. Imai and E. Tick",
title = "Evaluation of Parallel Copying Garbage Collection on a
Shared-Memory Multiprocessor",
journal = "IEEE Transactions on Parallel and Distributed
Systems",
pages = "1030--1040",
volume = "4",
number = "9",
month = sep,
year = "1993",
location = "CMU E\&{}S Library",
}
@TechReport{Strikwerda93a,
author = "John C. Strikwerda and John M. Considine and Lorenz F.
Huelsbergen",
title = "Deformation of a Membrane Under Uniform Static
Pressure Dynamic Language Parallelization",
institution = "COMPUTER SCIENCES DEPARTMENT, UNIVERSITY OF WISCONSIN
COMPUTER SCIENCES DEPARTMENT, UNIVERSITY OF WISCONSIN",
number = "TR 1177 TR 1178",
address = "MADISON, WI MADISON, WI",
month = jun # " 1993 " # sep,
year = "1993",
abstract = "We analyze the deformation of an isotropic,
homogeneous circular membrane due to a uniform static
pressure applied to one side. The solution is obtained
as a perturbation expansion in terms of the pressure.
In our analysis the stress is approximated by taking
only terms linear in the Euler strain, and thus the
analysis applies only to deformations that have small
strain. It does include nonlinear geometric effects
since the strain is a nonlinear function of the
deformation gradient. This theory does not include
bending effects, which is reasonable in most paper and
film applications.\par Keywords: membrane, burst test,
perturbation expansion\par Dynamic language
parallelization is a new method, for the automatic
parallelization of imperative programs, that finds
parallelism during program execution. Dynamic
parallelization uncovers more parallelism---and better
selects useful parallelism---than is statically
possible at compile time. It requires only inexpensive
compile-time analyses, allows separate compilation, and
admits interactive programming environments.\par This
thesis describes the design and implementation of the
first dynamic parallelization techniques for imperative
higher-order languages such as ML, Scheme, and Lisp.
Prototype implementations, in an optimizing ML compiler
on a shared-memory parallel computer, confirm the
thesis that dynamic language parallelization is
feasible, inexpensive, and often effective. The dynamic
techniques address parallelization in the presence of
four language attributes that inhibit static
parallelization: imperative higher-order functions,
side effects to dynamic structures, expressions with
variable amounts of computation, and automatic storage
reclamation.\par Lambda-tagging dynamically propagates
information about a function's side effects with the
function's physical run-time representation. A
lambda-tagging compiler can insert checks to lambda
tags that select parallel evaluation only when
lambda-tag side-effect information indicates that
parallel evaluation is safe.\par Dynamic resolution
determines at run time when updates to a dynamic data
structure may safely occur in parallel. It dynamically
detects shared data, and correctly coordinates access
to this data at run time. Dynamic resolution can
automatically parallelize some non-trivial functions
that elude static parallelization (e.g, a destructive
list-based sort).\par Dynamic granularity estimation
maintains size approximations on dynamic data
structures (e.g., lists) at run time. Dynamically, the
program consults these approximations to decide when
parallel evaluation of an expression will always speed
the program's execution. A compiler can statically
identify expressions whose evaluation cost always
depends on structure sizes, and can insert checks to
data sizes that select parallel evaluation when
beneficial.\par A concurrent garbage collector reclaims
a program's spent storage in parallel with the
program's computation proper. The thesis describes the
design and implementation of the first concurrent
copying collector that does not require special
hardware or operating systems support. The collector
relies on the language or compiler to identify all
program accesses to mutable data. Measurements of the
collector's implementation indicate that it removes all
perceptible garbage-collection pauses from a program's
execution.",
}
@TechReport{Appel93,
author = "Andrew W. Appel and Marcelo J. R. Goncalves",
title = "Hash-Consing Garbage Collection",
institution = "Department of Computer Science, Princeton University",
number = "TR-412-93",
pages = "18",
month = feb,
year = "1993",
abstract = "We describe an implementation of hash-consing for the
Standard ML of New Jersey compiler. Hash-consing can
eliminate replication among heap-allocated data, which
may allow the use of fast equality checking and may
also improve the locality of reference of a program.
The cost of a hash table lookup for each record
allocated may, however, offset any gains from the
elimination of replication.\par Our hash-consing scheme
is integrated with a generational garbage collector.
Only records that survive a garbage collection are
``hash-consed,'' thus avoiding the cost of a table
lookup for short-lived records. We discuss some issues
related with the implementation of this scheme and
present a performance evaluation.",
}
@TechReport{MIT/LCS/TR-569,
author = "S. Nettles and J. O'Toole and D. Gifford",
title = "Concurrent Garbage Collection of Persistent Heaps",
institution = "MIT Laboratory for Computer Science",
number = "MIT/LCS/TR-569",
pages = "22",
month = jun,
year = "1993",
price = "USD 12.00",
keywords = "persistent, transaction processing, garbage
collection, copying garbage collection, concurrent
collection, replication copying garbage collection",
abstract = "We describe the first concurrent compacting garbage
collector for a persistent heap. Client threads read
and write the heap in primary memory, and can
independently commit or about their write operations.
When write operations are committed they are preserved
in stab,.e storage and thus survive system failures.
Clients can freely access the heap during a garbage
collection because a replica of the heap is created by
the stable replica collector. A log is maintained to
capture client write operations. This log is used to
support both the transaction system and the
replication-based garbage collection algorithm.
Experimental data from our implementations was obtained
from a transactional version of the SML/.NJ compiler
and modified versions of the TPC-B and OO1 database
benchmarks. The pause time latency results show that
the prototype implementation provides significantly
better latencies than stop-and-copy collection. For
small transactions, throughput is limited by the
logging bandwidth of the underlying log manager. The
results provide strong evidence that the replication
copying algorithm imposes less overhead on transaction
commit operations than other algorithms.",
}
@TechReport{MIT/LCS/TR-574,
author = "U. Maheshwari",
title = "{DISTRIBUTED} {GARBAGE} {COLLECTION} {IN} {A}
{CLIENT}-{SERVER}, {TRANSACTION}, {PERSISTENT} {OBJECT}
{SYSTEM}",
institution = "MIT Laboratory for Computer Science",
number = "MIT/LCS/TR-574",
pages = "94",
month = aug,
year = "1993",
price = "USD 16.00",
keywords = "garbage collection, reference counting, distributed
systems, object-oriented databases, scalability, fault
tolerance",
}
@PhdThesis{MIT/LCS/TR-581,
author = "M. Reinhold",
title = "{CACHE} {PERFORMANCE} {OF} {GARBAGE}-{COLLECTED}
{PROGRAMMING} {LANGUAGES}",
school = "MIT Laboratory for Computer Science",
type = "Ph.{D}. Thesis",
number = "MIT/LCS/TR-581",
pages = "78",
month = sep,
year = "1993",
price = "USD 16.00",
keywords = "cache memories, dynamic storage management, garbage
collection, programming-language implementation,
Scheme",
}
Found 52 references in 19 bibliographies.
You used 21 seconds of our CPU time.