8 research outputs found
Beltway: Getting Around Garbage Collection Gridlock
We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware. The increasing reliance on garbage collected languages such as Java requires that the collector perform well. We show that the generality of Beltway enables us to design and implement new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which we are aware by up to 40%, and on average by 5 to 10%, for small to moderate heap sizes. New garbage collection algorithms are rare, and yet we define not just one, but a new family of collectors that subsumes previous work. This generality enables us to explore a larger design space and build better collectors
Muistin siivous
Tutkielmassa esitellÀÀn roskan kĂ€site tietojenkĂ€sittelytieteessĂ€, roskienkeruun keskeiset kĂ€sitteet ja perusmenetelmĂ€t muunnelmineen sekĂ€ nykyaikaiset tehokkaat algoritmit. KeskipisteenĂ€ ovat kuitenkin muistinhallintatutkimuksen 2000-luvun saavutukset, tutkimusaiheet ja tutkimusvĂ€lineet. NĂ€itĂ€ hyödyntÀÀ tutkielmassa esiteltĂ€vĂ€ uusi CBRC-roskienkeruualgoritmi. LisĂ€ksi katsastetaan ohjelmoijan vastuu automaattisessa muistinhallinnassa sekĂ€ ohjelmoinnissa kĂ€ytettĂ€vissĂ€ olevat roskienkeruutietoiset vĂ€lineet erĂ€issĂ€ ohjelmointikielissĂ€ ja âympĂ€ristöissĂ€ (Java, .Net, C++).
Avainsanat ja -sanonnat: roskienkeruu, muistinsiivous, muistinhallinta, algoritmit, ohjelmointikielet
CR-luokat: D 3.4, D.4.2, D.3.
High Performance Reference Counting and Conservative Garbage Collection
Garbage collection is an integral part of modern programming languages. It automatically
reclaims memory occupied by objects that are no longer in use. Garbage
collection began in 1960 with two algorithmic branches â tracing and reference counting.
Tracing identifies live objects by performing a transitive closure over the object
graph starting with the stacks, registers, and global variables as roots. Objects not
reached by the trace are implicitly dead, so the collector reclaims them. In contrast,
reference counting explicitly identifies dead objects by counting the number of incoming
references to each object. When an objectâs count goes to zero, it is unreachable
and the collector may reclaim it.
Garbage collectors require knowledge of every reference to each object, whether
the reference is from another object or from within the runtime. The runtime provides
this knowledge either by continuously keeping track of every change to each reference
or by periodically enumerating all references. The collector implementation faces two
broad choices â exact and conservative. In exact garbage collection, the compiler and
runtime system precisely identify all references held within the runtime including
those held within stacks, registers, and objects. To exactly identify references, the
runtime must introspect these references during execution, which requires support
from the compiler and significant engineering effort. On the contrary, conservative
garbage collection does not require introspection of these references, but instead
treats each value ambiguously as a potential reference.
Highly engineered, high performance systems conventionally use tracing and
exact garbage collection. However, other well-established but less performant systems
use either reference counting or conservative garbage collection. Reference counting has
some advantages over tracing such as: a) it is easier implement, b) it reclaims memory
immediately, and c) it has a local scope of operation. Conservative garbage collection
is easier to implement compared to exact garbage collection because it does not
require compiler cooperation. Because of these advantages, both reference counting
and conservative garbage collection are widely used in practice. Because both suffer
significant performance overheads, they are generally not used in performance critical
settings. This dissertation carefully examines reference counting and conservative
garbage collection to understand their behavior and improve their performance.
My thesis is that reference counting and conservative garbage collection can perform
as well or better than the best performing garbage collectors.
The key contributions of my thesis are: 1) An in-depth analysis of the key design
choices for reference counting. 2) Novel optimizations guided by that analysis that
significantly improve reference counting performance and make it competitive with
a well tuned tracing garbage collector. 3) A new collector, RCImmix, that replaces
the traditional free-list heap organization of reference counting with a line and block heap structure, which improves locality, and adds copying to mitigate fragmentation.
The result is a collector that outperforms a highly tuned production generational
collector. 4) A conservative garbage collector based on RCImmix that matches the
performance of a highly tuned production generational collector.
Reference counting and conservative garbage collection have lived under the
shadow of tracing and exact garbage collection for a long time. My thesis focuses
on bringing these somewhat neglected branches of garbage collection back to life
in a high performance setting and leads to two very surprising results: 1) a new
garbage collector based on reference counting that outperforms a highly tuned production
generational tracing collector, and 2) a variant that delivers high performance
conservative garbage collection
Programming constraint services
This thesis presents design, application, implementation, and evaluation of computation spaces as abstractions for programming constraint services at a high level. Spaces are seamlessly integrated into a concurrent programming language and make constraintbased computations compatible with concurrency through encapsulation. Spaces are applied to search and combinators as essential constraint services. State-of-the-art and new search engines such as visual interactive search and parallel search are covered. Search is expressive and concurrency-compatible by using copying rather than trailing. Search is space and time efficient by using recomputation. Composable combinators, also known as deep-guard combinators, stress the control facilities and
concurrency integration of spaces. The implementation of spaces comes as an orthogonal extension to the implementation of the underlying programming language. The resulting implementation is shown to be competitive with existing constraint programming systems.Diese Dissertation beschreibt Entwurf, Verwendung, Implementierung und Evaluierung von Computation Spaces fĂŒr die Programmierung von Constraintdiensten. Spaces werden in eine nebenlĂ€ufige Programmiersprache integriert. Sie fungieren als Kapseln fĂŒr Berechnungen mit Constraints. Dadurch wird die KompatibilitĂ€t zu nebenlĂ€ufigen Berechnungen gewĂ€hrleistet. Suche und Kombinatoren sind zentrale Constraintdienste, die mit Spaces programmiert werden. Es werden sowohl ĂŒbliche, als auch vollkommen neue Suchmaschinen, wie zum Beispiel interaktive Suche und parallele Suche, vorgestellt. Durch Kopieren wird Suche ausdrucksstark und kompatibel mit NebenlĂ€ufigkeit. Durch Wiederberechnung wird Suche effizient hinsichtlich Speicherbedarf und Laufzeit. Kombinatoren, die ineinander geschachtelt werden können (so genannte deep-guard Kombinatoren), verdeutlichen die Kontrollmöglichkeiten von Spaces. Die Implementierung von Spaces erfolgt als orthogonale Erweiterung einer Implementierung fĂŒr die zugrundeliegende Programmiersprache. Das Ergebnis ist konkurrenzfĂ€hig zu existierenden Constraintprogrammiersystemen
Computer-Assisted Lighting Design and Control
This dissertation shows that computer-based lighting control
systems can support the lighting design process considerably better
than traditional consoles. It describes the Lula Project, a new
software package for lighting design and control, that implements this
level of support. Lula's focus is on the conceptual ideas behind a
lighting design rather than the concrete lighting fixtures used to put
it on stage. Among the innovative aspects of the system are its model
for designing static lighting looks and its subsystem for programmable
continuous animated lighting. Lula's application design is centered
around the idea of componential lighting design that allows the
user to express a lighting design as a hierarchy of components. Lula
is a result of the rigorous application of high-level software
engineering techniques and implementation technology from the general
realm of functional programming. The high-level structure of the
application rests upon stratified design, algebraic modelling, and
domain-specific languages. Among the implementation techniques
instrumental to Lula are automatic memory management, higher-order
programming, functional data structures, data-directed programming,
parametric inheritance, and concurrent programming.Computer-basierte Systeme fĂŒr Beleuchtungssteuerung sind in
der Lage, den Lichtdesigner weitaus besser zu unterstĂŒtzen als es
derzeit marktĂŒbliche Steuerkonsolen tun. Das Thema dieser
Dissertation ist ein solches System, das Projekt Lula. Lula ist eine
neue Software fĂŒr Lichtregie und Beleuchtungssteuerung, welche die
Modellierung der konzeptuellen Elemente eines Lichtdesigns ermöglicht,
unabhĂ€ngig von der konkreten Realisierung auf der BĂŒhne. Unter den
innovativen Aspekten des Systems ist das Modell fĂŒr den Entwurf
statischer Beleuchtungsszenen sowie das Subsystem fĂŒr programmierbare,
stetig animierte Beleuchtung. Das ĂŒbergeordnete Prinzip bei Lula ist
komponentenbasierte Lichtregie, die es dem Benutzer erlaubt,
ein Lichtdesign als eine Hierarchie von Komponenten auszudrĂŒcken.
Lula ist das Resultat konsequenter Anwendung von Entwurfs- und
Implementierungs-Techniken aus dem Bereich der funktionalen
Programmierung. Die High-Level-Struktur des Systems baut auf
stratifiziertes Design, algebraische Modellierung und
anwendungsspezifische Programmiersprachen. Unter den
Implementationstechniken, die entscheidend bei der Entwicklung von
Lula waren, befinden sich automatische Speicherverwaltung,
Higher-Order-Programmierung, funktionale Datenstrukturen,
datengesteuerte Programmierung, parametrische Vererbung und
nebenlÀufige Programmierung