Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Lecture

Garbage Collection in Object-Oriented Languages

In course

CS-420: Advanced compiler construction

Students learn several implementation techniques for modern functional and object-oriented programming languages. They put some of them into practice by developing key parts of a compiler and run time system for a simple functional programming language. ...

Description

This lecture covers various garbage collection (GC) techniques in object-oriented languages. It starts with mostly-copying GC, which partitions objects into pinned and copied classes. Then, it delves into generational GC, which collects young and old generations separately to optimize memory usage. The lecture also discusses heap organization, hybrid heap management, promotion policies, and handling inter-generational pointers. Additionally, it explores finalizers, weak references, and challenges related to subtyping, polymorphism, object layout, and method dispatch in different inheritance scenarios.

This video is available exclusively on Mediaspace for a restricted audience. Please log in to MediaSpace to access it if you have the necessary permissions.

Watch on Mediaspace

Instructor

Michel Schinz

Official source

Ontological neighbourhood

Theoretical computer science

Programming language theory: High-level programming languages

Related concepts (32)

Polymorphism (computer science)

In programming language theory and type theory, polymorphism is the provision of a single interface to entities of different types or the use of a single symbol to represent multiple different types. The concept is borrowed from a principle in biology where an organism or species can have many different forms or stages. The most commonly recognized major classes of polymorphism are: Ad hoc polymorphism: defines a common interface for an arbitrary set of individually specified types.

Garbage collection (computer science)

In computer science, garbage collection (GC) is a form of automatic memory management. The garbage collector attempts to reclaim memory which was allocated by the program, but is no longer referenced; such memory is called garbage. Garbage collection was invented by American computer scientist John McCarthy around 1959 to simplify manual memory management in Lisp. Garbage collection relieves the programmer from doing manual memory management, where the programmer specifies what objects to de-allocate and return to the memory system and when to do so.

Subtyping

In programming language theory, subtyping (also subtype polymorphism or inclusion polymorphism) is a form of type polymorphism in which a subtype is a datatype that is related to another datatype (the supertype) by some notion of substitutability, meaning that program elements, typically subroutines or functions, written to operate on elements of the supertype can also operate on elements of the subtype. If S is a subtype of T, the subtyping relation (written as S

Tracing garbage collection

In computer programming, tracing garbage collection is a form of automatic memory management that consists of determining which objects should be deallocated ("garbage collected") by tracing which objects are reachable by a chain of references from certain "root" objects, and considering the rest as "garbage" and collecting them. Tracing garbage collection is the most common type of garbage collection – so much so that "garbage collection" often refers to tracing garbage collection, rather than other methods such as reference counting – and there are a large number of algorithms used in implementation.

Multiple dispatch

Multiple dispatch or multimethods is a feature of some programming languages in which a function or method can be dynamically dispatched based on the run-time (dynamic) type or, in the more general case, some other attribute of more than one of its arguments. This is a generalization of single-dispatch polymorphism where a function or method call is dynamically dispatched based on the derived type of the object on which the method has been called.

Related lectures (32)

Heterogeneous Collections in C++

Explores the implementation of heterogeneous collections in C++, emphasizing clean design choices for users.

Polymorphism in Object-Oriented Programming: Inclusion Mechanism

Covers polymorphism in object-oriented programming, focusing on inclusion polymorphism and its implementation through class hierarchies and virtual methods.

Dynamic Memory Management and Dynamic Dispatch

Explores memory management, safety, automated techniques, garbage collection, dynamic dispatch, and first-class functions.

Advanced Heterogeneous Collections in C++

Explores advanced C++ programming concepts, focusing on heterogeneous collections, polymorphic behavior, memory management, and data sharing.

Object Lifecycle in Java