DOCSLIB.ORG

Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems G. Salagnac, C. Rippert, S. Yovine Verimag Lab. Université Joseph Fourier Grenoble, France http://www-verimag.imag.fr/~salagnac [email protected] G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 1 / 16 Motivation The Java programming language I Attractive language I Automatic memory management Implementation pitfalls I Garbage Collection ⇒ pause times and fragmentation =⇒ Difficult to use in a real-time embedded context G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 2 / 16 Our approach Non-determinism of Garbage Collector pause times: the problem is in the JVM, not in the language! Proposition: I Keep the language I no manual memory management I Change the implementation I replace the GC by a predictable allocator I use region-based memory management I automatically compute object lifetimes at compilation I undecidable problem I find a reasonable over-approximation G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 3 / 16 Our approach Non-determinism of Garbage Collector pause times: the problem is in the JVM, not in the language! Proposition: I Keep the language I no manual memory management I Change the implementation I replace the GC by a predictable allocator I use region-based memory management I automatically compute object lifetimes at compilation I undecidable problem I find a reasonable over-approximation G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 3 / 16 Outline Introduction Region-Based Memory management Pointer Interference Analysis Experimental results Conclusion G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 4 / 16 Memory management using regions a java heap... ...organised in regions region 1 region 2 program variables Objects in a region will share the same (physical) lifetime I Benefits: a more real-time-compatible behaviour I objects allocated side by side I no fragmentation, constant time I region destroyed as a whole: predictable times I Drawbacks: more difficult bookkeeping I object placement issue: who decides? I region destroyed as a whole: space overhead, risk of faults G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 5 / 16 Memory management using regions a java heap... ...organised in regions region 1 region 2 program variables Objects in a region will share the same (physical) lifetime I Benefits: a more real-time-compatible behaviour I objects allocated side by side I no fragmentation, constant time I region destroyed as a whole: predictable times I Drawbacks: more difficult bookkeeping I object placement issue: who decides? I region destroyed as a whole: space overhead, risk of faults G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 5 / 16 Memory management using regions a java heap... ...organised in regions region 1 region 2 program variables Objects in a region will share the same (physical) lifetime I Benefits: a more real-time-compatible behaviour I objects allocated side by side I no fragmentation, constant time I region destroyed as a whole: predictable times I Drawbacks: more difficult bookkeeping I object placement issue: who decides? I region destroyed as a whole: space overhead, risk of faults G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 5 / 16 Outline Introduction Region-Based Memory management Pointer Interference Analysis Experimental results Conclusion G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 6 / 16 Region analysis and allocation policy Hypothesis: Objects within the same data structure (i.e. connected together) will often have similar (logical) lifetimes =⇒ one region for each data structure I no inter-region pointer Static analysis: I identify variables that may point to connected objects Allocation Policy: I place objects so that each structure is grouped in a region G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 7 / 16 Region analysis and allocation policy Hypothesis: Objects within the same data structure (i.e. connected together) will often have similar (logical) lifetimes =⇒ one region for each data structure I no inter-region pointer Static analysis: I identify variables that may point to connected objects Allocation Policy: I place objects so that each structure is grouped in a region G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 7 / 16 ∼ ∼ ∼ ∼ list o1 o2 this tmp this o main() <init>() add() Example: pointer interference analysis class ArrayList { Object[] data; int index; main() { <init>(int capacity) ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } Object o2=new Object; void add(Object o) list.add(o1); { } this.data[this.index] = o; this.index ++; } } G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ ∼ ∼ list o1 o2 this tmp this o Example: pointer interference analysis for all methods, class ArrayList { Object[] data; int index; main() main() { <init>(int capacity) ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ ∼ ∼ this tmp this o Example: pointer interference analysis identify local variables class ArrayList { Object[] data; int index; main() main() { <init>(int capacity) list o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ ∼ ∼ this o Example: pointer interference analysis identify local variables class ArrayList { Object[] data; int index; main() main() { <init>(int capacity) list o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this tmp list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ ∼ ∼ Example: pointer interference analysis identify local variables class ArrayList { Object[] data; int index; main() main() { <init>(int capacity) list o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this tmp list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() this o G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ ∼ Example: pointer interference analysis local interference: class ArrayList v1.f=v2 =⇒ v1∼v2 { Object[] data; int index; main() main() { <init>(int capacity) list o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this ∼ tmp list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() this o G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ ∼ Example: pointer interference analysis local interference: class ArrayList v1.f=v2 =⇒ v1∼v2 { Object[] data; int index; main() main() { <init>(int capacity) list o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this ∼ tmp list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() this ∼ o G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ Example: pointer interference analysis interproc. interference: class ArrayList p1∼p2 =⇒ a1∼a2 { Object[] data; int index; main() main() { <init>(int capacity) list ∼ o1 o2 ArrayList list = { new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this ∼ tmp list.add(o1); { } this.data[this.index] = o; this.index ++; } } add() this ∼ o G. Salagnac (Verimag) Semi-Automatic Region-Based Memory Management for Real-Time Java Embedded Systems 8 / 16 ∼ Example: pointer interference analysis results: class ArrayList { Object[] data; int index; main() main() {//list∼o1 o2 <init>(int capacity) list ∼ o1 o2 ArrayList list = {//this∼tmp new ArrayList; this.index = 0; list.<init>(3); tmp = new Object[capacity]; this.data = tmp; Object o1=new Object; } <init>() Object o2=new Object; void add(Object o) this ∼ tmp
Load more

Recommended publications
  • Memory Management and Garbage Collection
    Overview Memory Management Stack: Data on stack (local variables on activation records) have lifetime that coincides with the life of a procedure call. Memory for stack data is allocated on entry to procedures ::: ::: and de-allocated on return. Heap: Data on heap have lifetimes that may differ from the life of a procedure call. Memory for heap data is allocated on demand (e.g. malloc, new, etc.) ::: ::: and released Manually: e.g. using free Automatically: e.g. using a garbage collector Compilers Memory Management CSE 304/504 1 / 16 Overview Memory Allocation Heap memory is divided into free and used. Free memory is kept in a data structure, usually a free list. When a new chunk of memory is needed, a chunk from the free list is returned (after marking it as used). When a chunk of memory is freed, it is added to the free list (after marking it as free) Compilers Memory Management CSE 304/504 2 / 16 Overview Fragmentation Free space is said to be fragmented when free chunks are not contiguous. Fragmentation is reduced by: Maintaining different-sized free lists (e.g. free 8-byte cells, free 16-byte cells etc.) and allocating out of the appropriate list. If a small chunk is not available (e.g. no free 8-byte cells), grab a larger chunk (say, a 32-byte chunk), subdivide it (into 4 smaller chunks) and allocate. When a small chunk is freed, check if it can be merged with adjacent areas to make a larger chunk. Compilers Memory Management CSE 304/504 3 / 16 Overview Manual Memory Management Programmer has full control over memory ::: with the responsibility to manage it well Premature free's lead to dangling references Overly conservative free's lead to memory leaks With manual free's it is virtually impossible to ensure that a program is correct and secure.
    [Show full text]
  • Project Snowflake: Non-Blocking Safe Manual Memory Management in .NET
    Project Snowflake: Non-blocking Safe Manual Memory Management in .NET Matthew Parkinson Dimitrios Vytiniotis Kapil Vaswani Manuel Costa Pantazis Deligiannis Microsoft Research Dylan McDermott Aaron Blankstein Jonathan Balkind University of Cambridge Princeton University July 26, 2017 Abstract Garbage collection greatly improves programmer productivity and ensures memory safety. Manual memory management on the other hand often delivers better performance but is typically unsafe and can lead to system crashes or security vulnerabilities. We propose integrating safe manual memory management with garbage collection in the .NET runtime to get the best of both worlds. In our design, programmers can choose between allocating objects in the garbage collected heap or the manual heap. All existing applications run unmodified, and without any performance degradation, using the garbage collected heap. Our programming model for manual memory management is flexible: although objects in the manual heap can have a single owning pointer, we allow deallocation at any program point and concurrent sharing of these objects amongst all the threads in the program. Experimental results from our .NET CoreCLR implementation on real-world applications show substantial performance gains especially in multithreaded scenarios: up to 3x savings in peak working sets and 2x improvements in runtime. 1 Introduction The importance of garbage collection (GC) in modern software cannot be overstated. GC greatly improves programmer productivity because it frees programmers from the burden of thinking about object lifetimes and freeing memory. Even more importantly, GC prevents temporal memory safety errors, i.e., uses of memory after it has been freed, which often lead to security breaches. Modern generational collectors, such as the .NET GC, deliver great throughput through a combination of fast thread-local bump allocation and cheap collection of young objects [63, 18, 61].
    [Show full text]
  • Transparent Garbage Collection for C++
    Document Number: WG21/N1833=05-0093 Date: 2005-06-24 Reply to: Hans-J. Boehm [email protected] 1501 Page Mill Rd., MS 1138 Palo Alto CA 94304 USA Transparent Garbage Collection for C++ Hans Boehm Michael Spertus Abstract A number of possible approaches to automatic memory management in C++ have been considered over the years. Here we propose the re- consideration of an approach that relies on partially conservative garbage collection. Its principal advantage is that objects referenced by ordinary pointers may be garbage-collected. Unlike other approaches, this makes it possible to garbage-collect ob- jects allocated and manipulated by most legacy libraries. This makes it much easier to convert existing code to a garbage-collected environment. It also means that it can be used, for example, to “repair” legacy code with deficient memory management. The approach taken here is similar to that taken by Bjarne Strous- trup’s much earlier proposal (N0932=96-0114). Based on prior discussion on the core reflector, this version does insist that implementations make an attempt at garbage collection if so requested by the application. How- ever, since there is no real notion of space usage in the standard, there is no way to make this a substantive requirement. An implementation that “garbage collects” by deallocating all collectable memory at process exit will remain conforming, though it is likely to be unsatisfactory for some uses. 1 Introduction A number of different mechanisms for adding automatic memory reclamation (garbage collection) to C++ have been considered: 1. Smart-pointer-based approaches which recycle objects no longer ref- erenced via special library-defined replacement pointer types.
    [Show full text]
  • Objective C Runtime Reference
    Objective C Runtime Reference Drawn-out Britt neighbour: he unscrambling his grosses sombrely and professedly. Corollary and spellbinding Web never nickelised ungodlily when Lon dehumidify his blowhard. Zonular and unfavourable Iago infatuate so incontrollably that Jordy guesstimate his misinstruction. Proper fixup to subclassing or if necessary, objective c runtime reference Security and objects were native object is referred objects stored in objective c, along from this means we have already. Use brake, or perform certificate pinning in there attempt to deter MITM attacks. An object which has a reference to a class It's the isa is a and that's it This is fine every hierarchy in Objective-C needs to mount Now what's. Use direct access control the man page. This function allows us to voluntary a reference on every self object. The exception handling code uses a header file implementing the generic parts of the Itanium EH ABI. If the method is almost in the cache, thanks to Medium Members. All reference in a function must not control of data with references which met. Understanding the Objective-C Runtime Logo Table Of Contents. Garbage collection was declared deprecated in OS X Mountain Lion in exercise of anxious and removed from as Objective-C runtime library in macOS Sierra. Objective-C Runtime Reference. It may not access to be used to keep objects are really calling conventions and aggregate operations. Thank has for putting so in effort than your posts. This will cut down on the alien of Objective C runtime information. Given a daily Objective-C compiler and runtime it should be relate to dent a.
    [Show full text]
  • Programming Language Concepts Memory Management in Different
    Programming Language Concepts Memory management in different languages Janyl Jumadinova 13 April, 2017 I Use external software, such as the Boehm-Demers-Weiser collector (a.k.a. Boehm GC), to do garbage collection in C/C++: { use Boehm instead of traditional malloc and free in C http://hboehm.info/gc/ C I Memory management is typically manual: { the standard library functions for memory management in C, malloc and free, have become almost synonymous with manual memory management. 2/16 C I Memory management is typically manual: { the standard library functions for memory management in C, malloc and free, have become almost synonymous with manual memory management. I Use external software, such as the Boehm-Demers-Weiser collector (a.k.a. Boehm GC), to do garbage collection in C/C++: { use Boehm instead of traditional malloc and free in C http://hboehm.info/gc/ 2/16 I In addition to Boehm, we can use smart pointers as a memory management solution. C++ I The standard library functions for memory management in C++ are new and delete. I The higher abstraction level of C++ makes the bookkeeping required for manual memory management even harder than C. 3/16 C++ I The standard library functions for memory management in C++ are new and delete. I The higher abstraction level of C++ makes the bookkeeping required for manual memory management even harder than C. I In addition to Boehm, we can use smart pointers as a memory management solution. 3/16 Smart pointer: // declare a smart pointer on stack // and pass it the raw pointer SomeSmartPtr<MyObject> ptr(new MyObject()); ptr->DoSomething(); // use the object in some way // destruction of the object happens automatically C++ Raw pointer: MyClass *ptr = new MyClass(); ptr->doSomething(); delete ptr; // destroy the object.
    [Show full text]
  • Memory Management Algorithms and Implementation in C/C++
    Memory Management Algorithms and Implementation in C/C++ by Bill Blunden Wordware Publishing, Inc. Library of Congress Cataloging-in-Publication Data Blunden, Bill, 1969- Memory management: algorithms and implementation in C/C++ / by Bill Blunden. p. cm. Includes bibliographical references and index. ISBN 1-55622-347-1 1. Memory management (Computer science) 2. Computer algorithms. 3. C (Computer program language) 4. C++ (Computer program language) I. Title. QA76.9.M45 .B558 2002 005.4'35--dc21 2002012447 CIP © 2003, Wordware Publishing, Inc. All Rights Reserved 2320 Los Rios Boulevard Plano, Texas 75074 No part of this book may be reproduced in any form or by any means without permission in writing from Wordware Publishing, Inc. Printed in the United States of America ISBN 1-55622-347-1 10987654321 0208 Product names mentioned are used for identification purposes only and may be trademarks of their respective companies. All inquiries for volume purchases of this book should be addressed to Wordware Publishing, Inc., at the above address. Telephone inquiries may be made by calling: (972) 423-0090 This book is dedicated to Rob, Julie, and Theo. And also to David M. Lee “I came to learn physics, and I got Jimmy Stewart” iii Table of Contents Acknowledgments......................xi Introduction.........................xiii Chapter 1 Memory Management Mechanisms. 1 MechanismVersusPolicy..................1 MemoryHierarchy......................3 AddressLinesandBuses...................9 Intel Pentium Architecture . 11 RealModeOperation...................14 Protected Mode Operation. 18 Protected Mode Segmentation . 19 ProtectedModePaging................26 PagingasProtection..................31 Addresses: Logical, Linear, and Physical . 33 PageFramesandPages................34 Case Study: Switching to Protected Mode . 35 ClosingThoughts......................42 References..........................43 Chapter 2 Memory Management Policies.
    [Show full text]
  • Object Oriented Programming in Objective-C 2501ICT/7421ICT Nathan
    Subclasses, Access Control, and Class Methods Advanced Topics Object Oriented Programming in Objective-C 2501ICT/7421ICT Nathan René Hexel School of Information and Communication Technology Griffith University Semester 1, 2012 René Hexel Object Oriented Programming in Objective-C Subclasses, Access Control, and Class Methods Advanced Topics Outline 1 Subclasses, Access Control, and Class Methods Subclasses and Access Control Class Methods 2 Advanced Topics Memory Management Strings René Hexel Object Oriented Programming in Objective-C Subclasses, Access Control, and Class Methods Subclasses and Access Control Advanced Topics Class Methods Objective-C Subclasses Objective-C Subclasses René Hexel Object Oriented Programming in Objective-C Subclasses, Access Control, and Class Methods Subclasses and Access Control Advanced Topics Class Methods Subclasses in Objective-C Classes can extend other classes @interface AClass: NSObject every class should extend at least NSObject, the root class to subclass a different class, replace NSObject with the class you want to extend self references the current object super references the parent class for method invocations René Hexel Object Oriented Programming in Objective-C Subclasses, Access Control, and Class Methods Subclasses and Access Control Advanced Topics Class Methods Creating Subclasses: Point3D Parent Class: Point.h Child Class: Point3D.h #import <Foundation/Foundation.h> #import "Point.h" @interface Point: NSObject @interface Point3D: Point { { int x; // member variables int z; // add z dimension
    [Show full text]
  • Basic Garbage Collection Garbage Collection (GC) Is the Automatic
    Basic Garbage Collection Garbage Collection (GC) is the automatic reclamation of heap records that will never again be accessed by the program. GC is universally used for languages with closures and complex data structures that are implicitly heap-allocated. GC may be useful for any language that supports heap allocation, because it obviates the need for explicit deallocation, which is tedious, error-prone, and often non- modular. GC technology is increasingly interesting for “conventional” language implementation, especially as users discover that free isn’t free. i.e., explicit memory management can be costly too. We view GC as part of an allocation service provided by the runtime environment to the user program, usually called the mutator( user program). When the mutator needs heap space, it calls an allocation routine, which in turn performs garbage collection activities if needed. Many high-level programming languages remove the burden of manual memory management from the programmer by offering automatic garbage collection, which deallocates unreachable data. Garbage collection dates back to the initial implementation of Lisp in 1958. Other significant languages that offer garbage collection include Java, Perl, ML, Modula-3, Prolog, and Smalltalk. Principles The basic principles of garbage collection are: 1. Find data objects in a program that cannot be accessed in the future 2. Reclaim the resources used by those objects Many computer languages require garbage collection, either as part of the language specification (e.g., Java, C#, and most scripting languages) or effectively for practical implementation (e.g., formal languages like lambda calculus); these are said to be garbage collected languages.
    [Show full text]
  • Simple, Fast and Safe Manual Memory Management
    Simple, Fast and Safe Manual Memory Management Piyus Kedia Manuel Costa Matthew Aaron Blankstein ∗ Microsoft Research, India Parkinson Kapil Vaswani Princeton University, USA [email protected] Dimitrios Vytiniotis [email protected] Microsoft Research, UK manuelc,mattpark,kapilv,[email protected] Abstract cause the latter are more efficient. As a consequence, many Safe programming languages are readily available, but many applications continue to have exploitable memory safety applications continue to be written in unsafe languages be- bugs. One of the main reasons behind the higher efficiency cause of efficiency. As a consequence, many applications of unsafe languages is that they typically use manual mem- continue to have exploitable memory safety bugs. Since ory management, which has been shown to be more efficient garbage collection is a major source of inefficiency in the than garbage collection [19, 21, 24, 33, 34, 45]. Thus, replac- implementation of safe languages, replacing it with safe ing garbage collection with manual memory management in manual memory management would be an important step safe languages would be an important step towards solv- towards solving this problem. ing this problem. The challenge is how to implement man- Previous approaches to safe manual memory manage- ual memory management efficiently, without compromising ment use programming models based on regions, unique safety. pointers, borrowing of references, and ownership types. We Previous approaches to safe manual memory manage- propose a much simpler programming model that does not ment use programming models based on regions [20, 40], require any of these concepts. Starting from the design of an unique pointers [22, 38], borrowing of references [11, 12, imperative type safe language (like Java or C#), we just add 42], and ownership types [10, 12, 13].
    [Show full text]
  • Memscope: Analyzing Memory Duplication on Android Systems
    MemScope: Analyzing Memory Duplication on Android Systems Byeoksan Lee, Seong Min Kim, Eru Park, Dongsu Han KAIST Abstract tion (e.g., log-in) when the app is reloaded. Additionally, it leads to longer reload time [15]. Main memory is one of the most important and valuable As users run an increasing number of applications and resources in mobile devices. While resource efficiency, in each application becomes more complex, the memory pres- general, is important in mobile computing where programs sure on mobile devices is increasing. This coupled with the run on limited battery power and resources, managing main rise of low memory devices [5] makes the problem even memory is especially critical because it has a significant more important. Android itself tried to reduce system mem- impact on user experience. However, there is mounting ory footprint and produced a way to tune the system for low evidence that Android systems do not utilize main memory memory devices [6]. However, there is mounting evidence efficiently, and actually cause page-level duplications in the that Android systems do not utilize main memory efficiently, physical memory. This paper takes the first step in accurately and actually cause page-level duplications in the physical measuring the level of memory duplication and diagnosing memory [5, 13]. the root cause of the problem. To this end, we develop a To mitigate the problem, Android has introduced several system called MemScope that automatically identifies and mechanisms to optimize the system for low memory de- measures memory duplication levels for Android systems. It vices, such as Kernel Same-page Merging (KSM) [8] and identifies which memory segment contains duplicate memory zRAM [12].
    [Show full text]
  • Optimization Techniques for Memory Virtualization-Based Resource Management
    SSStttooonnnyyy BBBrrrooooookkk UUUnnniiivvveeerrrsssiiitttyyy The official electronic file of this thesis or dissertation is maintained by the University Libraries on behalf of The Graduate School at Stony Brook University. ©©© AAAllllll RRRiiiggghhhtttsss RRReeessseeerrrvvveeeddd bbbyyy AAAuuuttthhhooorrr... Optimization Techniques for Memory Virtualization-based Resource Management A Dissertation Presented by Jui-Hao Chiang to The Graduate School in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy in Computer Science Stony Brook University December 2012 Stony Brook University The Graduate School Jui-Hao Chiang We, the dissertation committee for the above candidate for the Doctor of Philosophy degree, hereby recommend acceptance of this dissertation. Tzi-cker Chiueh { Dissertation Advisor Professor, Department of Computer Science Jie Gao { Chairperson of Defense Associate Professor, Department of Computer Science Rob Johnson Assistant Professor, Department of Computer Science Ted Teng Professor, Department of Technology and Society This dissertation is accepted by the Graduate School. Charles Taber Interim Dean of the Graduate School ii Abstract of the Dissertation Optimization Techniques for Memory Virtualization-based Resource Management by Jui-Hao Chiang Doctor of Philosophy in Computer Science Stony Brook University 2012 Memory virtualization abstracts the physical memory resources in a virtualized server in such a way that offers many resource man- agement advantages, such as consolidation, sharing,
    [Show full text]
  • Mostly Concurrent Garbage Collection
    Mostly Concurrent Garbage Collection Marco Ammon [email protected] Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Erlangen, Germany ABSTRACT For performing an accurate reachability analysis, program execu- Automated Garbage Collection (GC) is desired for many applications tion is usually halted during garbage collection, which is called a due to difficulties with manual memory management. Conventional stop-the-world (STW) approach. tracing garbage collectors require a complete halt of the program Consequently, as this process requires to scan large portions of while unreachable objects are detected and reclaimed. However, the the heap, application latency can significantly increase due to long resulting increased latency is not always tolerable. This paper gives pauses. In particular for interactive applications, web services, or an introduction into GC fundamentals before thoroughly explaining real-time constrained programs, this may not be tolerable [8, 13, 27]. and discussing the mostly concurrent mark-and-sweep algorithm Hence, alternatives to the STW method are often desired. presented in [8]. The approach is based on the principle of combin- In Section 2, different approaches to tracing garbage collectors ing a concurrent marking phase with a short stop-the-world pause are presented. Section 3 explains and discusses a particular algo- to process modifications which occurred simultaneously. Addition- rithm for mostly concurrent GC [8] proposed by Boehm et al., which ally, the influence of this concept on modern garbage collectors on combines a short stop-the-world phase with longer, concurrently the Java Virtual Machine is reviewed. executed marking operations. Given the historic significance, its in- fluence on some contemporary GC algorithms for the popular Java Virtual Machine (JVM) is reviewed in Section 4.
    [Show full text]