21 research outputs found

    Concurrent Compaction in JVM Garbage Collection

    Get PDF
    This paper provides a brief overview of both garbage collection (GC) of memory and parallel processing. We then cover how parallel processing applies to GC. Specifically, these concepts are focused within the context of the Java Virtual Machine (JVM). With that foundation, we look at various algorithms that perform compaction of fragmented memory during the GC process. These algorithms are designed to run concurrent to the application running. Such concurrently compacting GC behavior stems from a desire to reduce \stop-the-world pauses of an application

    Real-Time Wait-Free Queues using Micro-Transactions

    Get PDF

    A fast analysis for thread-local garbage collection with dynamic class loading

    Get PDF
    Long-running, heavily multi-threaded, Java server applications make stringent demands of garbage collector (GC) performance. Synchronisation of all application threads before garbage collection is a significant bottleneck for JVMs that use native threads. We present a new static analysis and a novel GC framework designed to address this issue by allowing independent collection of thread-local heaps. In contrast to previous work, our solution safely classifies objects even in the presence of dynamic class loading, requires neither write-barriers that may do unbounded work, nor synchronisation, nor locks during thread-local collections; our analysis is sufficiently fast to permit its integration into a high-performance, production-quality virtual machine

    Visualising the Logs of Shenandoah Garbage Collection Algorithm

    Get PDF
    Käesoleva lõputöö eesmärgiks on Red Hati uue mälukoristusalgoritmi Shenandoah logide parseri implementeerimine avatud lähtekoodiga projekti GCViewer raames. Lisaeesmärgiks on anda ülevaade Java mälukoristuse abstraktsioonist.Lõputöö koosneb kahest osast - esimeses osas uuritakse süvendatult prügikoristuse abstraktsiooni Javas ning selle erinevaid implementatsioone, logisüsteemi plaanitavaid muudatusi Java 9 ning teises osas kirjeldatakse parseri implementeerimist ja selle valideerimist.Töö käigus loodi eelmainitud Shenandoah parser, valideeriti see, ning tehti pull request selle GCVieweri projekti lisamiseks.The aim of the current thesis is to implement a Garbage Collection log parser for Red Hat’s Garbage Collection algorithm Shenandoah by extending an open-source project GCViewer. Additional aim is to take a further look into the Garbage Collection in Java. The thesis is split into two main parts. The first part describes the background of Garbage Collection in Java and upcoming changes to the logging system in Java 9. The second part covers the implementation and the validation of the parser.The intended Shenandoah parser was implemented, validated, and a pull request to add it to GCViewer project was created

    Retrofitting parallelism onto OCaml.

    Get PDF
    OCaml is an industrial-strength, multi-paradigm programming language, widely used in industry and academia. OCaml is also one of the few modern managed system programming languages to lack support for shared memory parallel programming. This paper describes the design, a full-fledged implementation and evaluation of a mostly-concurrent garbage collector (GC) for the multicore extension of the OCaml programming language. Given that we propose to add parallelism to a widely used programming language with millions of lines of existing code, we face the challenge of maintaining backwards compatibility--not just in terms of the language features but also the performance of single-threaded code running with the new GC. To this end, the paper presents a series of novel techniques and demonstrates that the new GC strikes a balance between performance and feature backwards compatibility for sequential programs and scales admirably on modern multicore processors

    Orca: GC and type system co-design for actor languages

    No full text
    ORCA is a concurrent and parallel garbage collector for actor programs, which does not require any stop-the-world steps, or synchronisation mechanisms, and which has been designed to support zero-copy message passing and sharing of mutable data. \ORCA is part of the runtime of the actor-based language Pony. Pony's runtime was co-designed with the Pony language. This co-design allowed us to exploit certain language properties in order to optimise performance of garbage collection. Namely, ORCA relies on the absence of race conditions in order to avoid read/write barriers, and it leverages actor message passing for synchronisation among actors. This paper describes Pony, its type system, and the ORCA garbage collection algorithm. An evaluation of the performance of ORCA suggests that it is fast and scalable for idiomatic workloads

    Transactional Sapphire: Lessons in High Performance, On-the-fly Garbage Collection

    Get PDF
    Constructing a high-performance garbage collector is hard. Constructing a fully concurrent 'on-the-fly', compacting collector is much more so. We describe our experience of implementing the Sapphire algorithm as the first on-the-fly, parallel, replication copying, garbage collector for the Jikes RVM Java virtual machine. In part, we explain our innovations such as copying with hardware and software transactions, on-the-fly management of Java's reference types and simple, yet correct, lock-free management of volatile fields in a replicating collector. We fully evaluate, for the first time, and using realistic benchmarks, Sapphire's performance and suitability as a low latency collector. An important contribution of this work is a detailed description of our experience of building an on-the-fly copying collector for a complete JVM with some assurance that it is correct. A key aspect of this is model checking of critical components of this complicated and highly concurrent system

    CSOM/PL: A Virtual Machine Product Line

    Get PDF
    CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance
    corecore