DOCSLIB.ORG

A Focus on Java Garbage Collectors and C++ Smart Pointers

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Université de Neuchâtel Faculté des Sciences Institut d’Informatique Efficient Memory Management with Hardware Transactional Memory: A Focus on Java Garbage Collectors and C++ Smart Pointers par Maria Carpen-Amarie Thèse présentée à la Faculté des Sciences pour l’obtention du grade de Docteur ès Sciences Acceptée sur proposition du jury: Prof. Pascal Felber, Directeur de thèse Université de Neuchâtel, Suisse Prof. Rachid Guerraoui École Polytechnique Fédérale de Lausanne, Suisse Dr. Jean-Pierre Lozi Université Nice Sophia Antipolis, France Prof. Nir Shavit Massachusetts Institute of Technology, États-Unis Dr. Valerio Schiavoni Université de Neuchâtel, Suisse Soutenue le 3 novembre 2017 Faculté des Sciences Secrétariat-décanat de Faculté Rue Emile-Argand 11 2000 Neuchâtel – Suisse Tél : + 41 (0)32 718 21 00 E-mail : [email protected] IMPRIMATUR POUR THESE DE DOCTORAT La Faculté des sciences de l'Université de Neuchâtel autorise l'impression de la présente thèse soutenue par Madame Maria CARPEN-AMARIE Titre: “Efficient Memory Management with Hardware Transactional Memory: A Focus on Java Garbage Collectors and C++ Smart Pointers” sur le rapport des membres du jury composé comme suit: Prof. Pascal Felber, directeur de thèse, Université de Neuchâtel, Suisse Dr Valerio Schiavoni, Université de Neuchâtel, Suisse Prof. Nir Shavit, MIT, USA Prof. Rachid Guerraoui, EPF Lausanne, Suisse Dr Jean-Pierre Lozi, Université Nice Sophia Antipolis, France Neuchâtel, le 7 novembre 2017 Le Doyen, Prof. R. Bshary Imprimatur pour thèse de doctorat www.unine.ch/sciences ACKNOWLEDGMENTS I would like to express my gratitude to my supervisor, Prof. Pascal Felber, for supporting and advising me throughout my work on the PhD thesis. Knowing he is always there to exchange thoughts or give quick feedback every time I needed made this experience so much more enjoyable and insightful. Likewise, I would like to thank the external members of my thesis jury, Prof. Nir Shavit, Prof. Rachid Guerraoui and Dr. Jean-Pierre Lozi for taking the time to review my work and for the exciting discussions on the topic. I’m equally grateful to Dr. Valerio Schiavoni, for being both a friend and a strict reviewer, helping me very much with a cocktail of detailed feedback and good advice. My thanks also go to Prof. Gaël Thomas and David Dice for their constant support and advice. I am deeply indebted to Dr. Patrick Marlier. Without him this project would have never been started and without his knowledge, patience and enthusiasm during the first year it would have never reached this stage. Thanks, Pat, for a priceless first year of PhD! During the last four years I had a wonderful time together with all my colleagues and friends at UniNE. I have not forgotten the wonderful moments spent with Anita, Mascha, Emi, Yarco, Heverson, Raziel, before they left the university. Likewise, I’d like to thank the current gang of friends for all the fun coffee breaks, crossword puzzles, boardgames nights and so many other exciting events and debates: Dorian, Rafael, Roberta, Sébastien and everybody else. Of course, special thanks to my terrific officemate Mirco. Last, but not least, I want to thank all my family. A big hug for my sister Alexandra, who has always been my best friend and a role model for me. Special thanks to my mother, Maria, for always giving me the best possible care. Finally, thank you, Călin, for creating so many moments of happiness and warmth in the last few years. ABSTRACT With multi-core systems becoming ubiquitous in the last few years, lightweight synchronization and efficient automatic memory management are more and more demanded in the design of applications and libraries. Memory management techniques try to take advantage of the growing parallelism as much as possible, but the increasingly complex synchronization introduces considerable performance issues. The goal of this thesis is to leverage hardware transactional memory (HTM) for improving automatic memory management. We address both managed environments (Java) and unmanaged languages (C++). We investigate to what extent a novel synchronization mechanism such as HTM is able to make well-known memory management systems more efficient. We further provide insight into what scenarios benefit most from HTM-based synchronization. Managed runtime environments generally have a memory reclamation and recycling mechanism integrated, called garbage collector (GC). Its goal is to manage memory automatically and transparently, without impacting the application execution. The Java HotSpot virtual machine features several types of GCs, all of which need to block all application threads, i.e., stop the world, during collection. We propose a novel algorithm for a fully-concurrent GC based on HTM. We implement and optimize transactional access barriers, the core part of the algorithm. Our evaluation suggests that a full implementation of the transactional GC would have comparable performance with Java’s low-pause concurrent GC, while also eliminating stop-the-world pauses. Unmanaged languages use specialized forms of automatic memory management. In this context, we focus on smart pointers in C++. Their logic is based on reference-counting. However, the extra synchronization required by smart pointers has a negative impact on the performance of applications. We propose an HTM-based implementation of smart pointers. We aim to improve their performance by replacing atomic operations on the reference counter with transactions. In case of conflict, the pointer falls back to being a classical smart pointer. We identify favorable scenarios for using transactional pointers and we subsequently specialize them for concurrent data structure traversal. After studying the downsides of automatic memory management in multiple contexts, we find that HTM is a good candidate for addressing their specific synchronization issues. We show that HTM can successfully support both a feasible pauseless Java GC implementation, as well as more efficient smart pointers in C++. Keywords: Transactional memory, garbage collection, Java virtual machine, C++, reference counting, data structures. RÉSUMÉ De nos jours les systèmes multi-cœurs sont omniprésents. La conception des applications demande de plus en plus un moyen de synchronisation plus léger, ainsi qu’une gestion automatique de la mémoire plus efficace. Les techniques de gestion de la mémoire tâchent de profiter au maximum du parallélisme qui augmente chaque jour. Néanmoins, la complexité de la synchronisation peut entraîner des problèmes de performance majeurs. Dans cette thèse, nous tirons parti du support matériel pour la mémoire transactionnelle afin d’améliorer la performance de la gestion automatique de la mémoire. Ce travail porte sur des environnements supervisés (Java), ainsi que non-supervisés (C++). Nous étudions la mesure dans laquelle ce nouveau moyen de synchronisation peut rendre des systèmes réputés de gestion de la mémoire plus efficaces. De plus, nous identifions les scénarios où l’on peut utiliser la mémoire transactionnelle matérielle pour maximiser ses bénéfices. En général, les environnements supervisés ont un mécanisme intégré de récupération et re- cyclage de la mémoire, appelé le ramasse-miettes. Le but d’un ramasse-miettes est de gérer automatiquement la mémoire sans affecter la performance de l’application. La machine virtuelle Java HotSpot comporte plusieurs types de ramasse-miettes, qui ont tous besoin d’arrêter (ou bloquer) l’application pendant le ramassage. Nous proposons un nouvel algorithme pour un ramasse-miettes entièrement concurrent, employant de la mémoire transactionnelle matérielle pour la synchronisation avec l’application. Nous développons et optimisons une partie fonda- mentale de notre algorithme, des barrières en écriture et en lecture transactionnelles. Notre évaluation indique qu’après la mise en œuvre complète de notre algorithme, le ramasse-miettes transactionnel aura une performance comparable aux ramasse-miettes existants, mais sans bloquer l’application. Les langages non-supervisés utilisent parfois des moyens spécialisés de gestion automatique de la mémoire. Dans ce contexte, nous étudions les pointeurs intelligents de C++. La gestion de la mémoire repose sur un algorithme à comptage des références. La performance des applications est parfois dégradée en raison de la synchronisation requise par cet algorithme. Nous proposons une variante des pointeurs intelligents synchronisés avec de la mémoire transactionnelle matérielle. L’idée est de remplacer les opérations atomiques au niveau du compteur des références par des transactions. En cas de conflit, le pointeur transactionnel se transforme en pointeur intelligent classique. Les pointeurs transactionnels se révèlent particulièrement avantageux dans le contexte des structures des données. Nous analysons les désavantages de la gestion automatique de la mémoire dans plusieurs contextes. Nous montrons que la mémoire transactionnelle matérielle représente une très bonne solution pour les problèmes spécifiques de synchronisation rencontrés par les systèmes de gestion de la mémoire, dans des environnements aussi bien supervisés que non-supervisés. Mots-clés: Mémoire transactionnelle, ramasse-miettes, machine virtuelle Java, C++, comptage de références, structures des données. xi Contents 1 Introduction 1 1.1 Context and motivation . .1 1.2 Contributions . .2 1.3 Organization of the manuscript . .4 Part I – Background 7 2 Context: Multi-core Architectures 9 2.1 Shared memory . 10 2.2 Concurrent programming . 10
Recommended publications
  • Smart Pointers Raw Pointers (1 of 3)

    Smart Pointers Raw Pointers (1 of 3)

    Data Abstraction & Problem Solving with C++: Walls and Mirrors Seventh Edition C++ Interlude 4 Safe Memory Management Using Smart Pointers Raw Pointers (1 of 3) • Allocate memory in free store by using new operator – Returns reference to newly created object in memory • Store reference to object in a pointer variable – Use pointer variable to access object • Copy reference to another pointer variable – Creates alias to same object Copyright © 2017, 2013, 2007 Pearson Education, Inc. All Rights Reserved Raw Pointers (2 of 3) • Use delete operator to deallocate object’s memory – Must also set to null p t r any pointer variables that referenced the object • Need to keep track number of aliases that reference an object … else results in – Dangling pointers – Memory leaks – Other errors (program crash, wasted memory, …) Copyright © 2017, 2013, 2007 Pearson Education, Inc. All Rights Reserved Raw Pointers (3 of 3) • Languages such as Java and Python disallow direct reference to objects – Use reference counting to track number of aliases that reference an object – Known as the “reference count” • Language can detect when object no longer has references – Can deallocate … known as “garbage collection” Copyright © 2017, 2013, 2007 Pearson Education, Inc. All Rights Reserved Smart Pointers (1 of 2) • C++ now supports “smart” pointers (or managed pointers) – Act like raw pointers – Also provide automatic memory management features • When you declare a smart pointer – Placed on application stack – Smart pointer references an object object is “managed” Copyright © 2017, 2013, 2007 Pearson Education, Inc. All Rights Reserved Smart Pointers (2 of 2) • Smart-pointer templates – shared_p t r – provides shared ownership of object – unique_p t r – no other pointer can reference same object – weak_p t r – reference to an object already managed by a shared pointer … does not have ownership of the object Copyright © 2017, 2013, 2007 Pearson Education, Inc.
  • FOCS 2005 Program SUNDAY October 23, 2005

    FOCS 2005 Program SUNDAY October 23, 2005

    FOCS 2005 Program SUNDAY October 23, 2005 Talks in Grand Ballroom, 17th floor Session 1: 8:50am – 10:10am Chair: Eva´ Tardos 8:50 Agnostically Learning Halfspaces Adam Kalai, Adam Klivans, Yishay Mansour and Rocco Servedio 9:10 Noise stability of functions with low influences: invari- ance and optimality The 46th Annual IEEE Symposium on Elchanan Mossel, Ryan O’Donnell and Krzysztof Foundations of Computer Science Oleszkiewicz October 22-25, 2005 Omni William Penn Hotel, 9:30 Every decision tree has an influential variable Pittsburgh, PA Ryan O’Donnell, Michael Saks, Oded Schramm and Rocco Servedio Sponsored by the IEEE Computer Society Technical Committee on Mathematical Foundations of Computing 9:50 Lower Bounds for the Noisy Broadcast Problem In cooperation with ACM SIGACT Navin Goyal, Guy Kindler and Michael Saks Break 10:10am – 10:30am FOCS ’05 gratefully acknowledges financial support from Microsoft Research, Yahoo! Research, and the CMU Aladdin center Session 2: 10:30am – 12:10pm Chair: Satish Rao SATURDAY October 22, 2005 10:30 The Unique Games Conjecture, Integrality Gap for Cut Problems and Embeddability of Negative Type Metrics Tutorials held at CMU University Center into `1 [Best paper award] Reception at Omni William Penn Hotel, Monongahela Room, Subhash Khot and Nisheeth Vishnoi 17th floor 10:50 The Closest Substring problem with small distances Tutorial 1: 1:30pm – 3:30pm Daniel Marx (McConomy Auditorium) Chair: Irit Dinur 11:10 Fitting tree metrics: Hierarchical clustering and Phy- logeny Subhash Khot Nir Ailon and Moses Charikar On the Unique Games Conjecture 11:30 Metric Embeddings with Relaxed Guarantees Break 3:30pm – 4:00pm Ittai Abraham, Yair Bartal, T-H.
  • Metaclasses: Generative C++

    Metaclasses: Generative C++

    Metaclasses: Generative C++ Document Number: P0707 R3 Date: 2018-02-11 Reply-to: Herb Sutter ([email protected]) Audience: SG7, EWG Contents 1 Overview .............................................................................................................................................................2 2 Language: Metaclasses .......................................................................................................................................7 3 Library: Example metaclasses .......................................................................................................................... 18 4 Applying metaclasses: Qt moc and C++/WinRT .............................................................................................. 35 5 Alternatives for sourcedefinition transform syntax .................................................................................... 41 6 Alternatives for applying the transform .......................................................................................................... 43 7 FAQs ................................................................................................................................................................. 46 8 Revision history ............................................................................................................................................... 51 Major changes in R3: Switched to function-style declaration syntax per SG7 direction in Albuquerque (old: $class M new: constexpr void M(meta::type target,
  • Transparent Garbage Collection for C++

    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.
  • Smart Pointer Demo Goals Time

    Smart Pointer Demo Goals Time

    Outline Smart Pointer Demo Goals Time CPSC 427: Object-Oriented Programming Michael J. Fischer Lecture 13 March 3, 2016 CPSC 427, Lecture 13 1/17 Outline Smart Pointer Demo Goals Time Smart Pointer Demo More on Course Goals Clocks and Time Measurement CPSC 427, Lecture 13 2/17 Outline Smart Pointer Demo Goals Time Smart Pointer Demo CPSC 427, Lecture 13 3/17 Outline Smart Pointer Demo Goals Time Dangling pointers Pointers can be used to permit object sharing from different contexts. One can have a single object of some type T with many pointers in different contexts that all point to that object. CPSC 427, Lecture 13 4/17 Outline Smart Pointer Demo Goals Time Problems with shared objects If the different contexts have different lifetimes, the problem is to know when it is safe to delete the object. It can be difficult to know when an object should be deleted. Failure to delete an object will cause memory leaks. If the object is deleted while there are still points pointing to it, then those pointers become invalid. We call these dangling pointers. Failure to delete or premature deletion of objects are common sources of errors in C++. CPSC 427, Lecture 13 5/17 Outline Smart Pointer Demo Goals Time Avoiding dangling pointers There are several ways to avoid dangling pointers. 1. Have a top-level manager whose lifetime exceeds that of all of the pointers take responsibility for deleting the objects. 2. Use a garbage collection. (This is java's approach.) 3. Use reference counts. That is, keep track somehow of the number of outstanding pointers to an object.
  • C++/CLI Tutorial

    C++/CLI Tutorial

    CC++++//CCLLII TTuuttoorriiaall Author: Adam Sawicki, [email protected], www.asawicki.info Version 1.0, December 2011 Table of Contents Table of Contents .............................................................................................................................................................. 1 Introduction ...................................................................................................................................................................... 2 What is C++/CLI? ............................................................................................................................................................... 2 Why Use C++/CLI? ......................................................................................................................................................... 2 What C++/CLI is Not? .................................................................................................................................................... 2 Hello World Example ........................................................................................................................................................ 3 Project Properties ............................................................................................................................................................. 3 Namespaces .....................................................................................................................................................................
  • These Aren't the COM Objects You're Looking For

    These Aren't the COM Objects You're Looking For

    These Aren't the COM Objects You're Looking For November, 2018 Victor Ciura Technical Lead, Advanced Installer www.advancedinstaller.com Abstract Windows COM is 25 years old. Yet it is relevant today more than ever, because Microsoft has bet its entire modern WinRT API on it (starting with Windows 8/10). But, if you’re familiar with the “old” COM with its idioms and SDK helper classes, you’re in for a treat. With the advent of modern C++ 17, using COM objects and new Windows APIs in your applications feels like a completely new experience. In this session, we’ll explore how using modern C++ features can radically transform the shape of your COM code. By eliminating a lot of boilerplate, your code will be much more readable and maintainable. Classic COM idioms around activation and QueryInterface() can feel totally different with modern C++ helpers. A beautiful example of modern COM usage is C++/WinRT (now part of Windows SDK). This is a standard C++ language projection for the new Windows Runtime API. COM memory management, data marshalling, string handling can all feel quite mechanical in nature and very error prone, so a little help from modern C++ facilities would be more than welcomed. Error handling and debugging can be cumbersome for COM like APIs; we’ll explore some tricks to improve this experience, as well. 2018 Victor Ciura | @ciura_victor !X These Aren't the COM Objects You're Looking For ⚙ Part 1 of N 2018 Victor Ciura | @ciura_victor !2 Why COM ? Why are we talking about this ? Have we really exhausted all the cool C++ template<> topics � ? 2018 Victor Ciura | @ciura_victor !3 Who Am I ? Advanced Installer Clang Power Tools @ciura_victor 2018 Victor Ciura | @ciura_victor !4 How many of you have done any COM programming in the last 20 years ? �$ 2018 Victor Ciura | @ciura_victor !5 How many of you are doing COM programming currently (this year) ? #$ 2018 Victor Ciura | @ciura_victor !6 Let's start using COM..
  • Basics Smart Pointer Basics……………………………………………………………………………...1 Which Smart Pointer to Use?

    Basics Smart Pointer Basics……………………………………………………………………………...1 Which Smart Pointer to Use?

    Basics Smart pointer basics……………………………………………………………………………...1 Which smart pointer to use?.......…………………………………………………………….6 Medium How to implement the pimpl idiom by using unique_ptr………………………12 ​ ​ How to Transfer unique_ptrs From a Set to Another Set……………………….18 ​ ​ Advanced Custom deleters……………………….………………….………………….…………………...25 Changes of deleter during the life of a unique_ptr………………….………………..35 How to return a smart pointer and use covariance………………….………………..38 Smart pointer basics One thing that can rapidly clutter your C++ code and hinder its readability is memory management. Done badly, this can turn a simple logic into an inexpressive slalom of mess management, and make the code lose control over memory safety. The programming task of ensuring that all objects are correctly deleted is very low in terms of levels of abstraction, and since writing good code essentially comes down to respecting levels of abstraction, you want to keep those tasks away from your business logic (or any sort of logic for that matter). Smart pointers are made to deal with this effectively and relieve your code from the dirty work. This series of posts will show you how to take advantage of them to make your code both more ​ expressive and more correct. ​ We're going to go deep into the subject and since I want everyone to be able to follow all of ​ this series, there is no prerequisite and we start off here with the basics of smart pointers. The stack and the heap Like many other languages, C++ has several types of memories, that correspond to different parts of the physical memory. They are: the static, the stack, and the heap.
  • Application Development Guide (CLI)

    Application Development Guide (CLI)

    Ascend 310 Application Development Guide (CLI) Issue 01 Date 2020-05-30 HUAWEI TECHNOLOGIES CO., LTD. Copyright © Huawei Technologies Co., Ltd. 2020. All rights reserved. No part of this document may be reproduced or transmitted in any form or by any means without prior written consent of Huawei Technologies Co., Ltd. Trademarks and Permissions and other Huawei trademarks are trademarks of Huawei Technologies Co., Ltd. All other trademarks and trade names mentioned in this document are the property of their respective holders. Notice The purchased products, services and features are stipulated by the contract made between Huawei and the customer. All or part of the products, services and features described in this document may not be within the purchase scope or the usage scope. Unless otherwise specified in the contract, all statements, information, and recommendations in this document are provided "AS IS" without warranties, guarantees or representations of any kind, either express or implied. The information in this document is subject to change without notice. Every effort has been made in the preparation of this document to ensure accuracy of the contents, but all statements, information, and recommendations in this document do not constitute a warranty of any kind, express or implied. Issue 01 (2020-05-30) Copyright © Huawei Technologies Co., Ltd. i Ascend 310 Application Development Guide (CLI) Contents Contents 1 Introduction.............................................................................................................................
  • Copyrighted Material 23 Chapter 2: Data, Variables, and Calculations 25

    Copyrighted Material 23 Chapter 2: Data, Variables, and Calculations 25

    CONTENTS INTRODUCTION xxxv CHAPTER 1: PROGRAMMING WITH VISUAL C++ 1 Learning with Visual C++ 1 Writing C++ Applications 2 Learning Desktop Applications Programming 3 Learning C++ 3 Console Applications 4 Windows Programming Concepts 4 What Is the Integrated Development Environment? 5 The Editor 6 The Compiler 6 The Linker 6 The Libraries 6 Using the IDE 7 Toolbar Options 8 Dockable Toolbars 9 Documentation 10 Projects and Solutions 10 Defi ning a Project 10 Debug and Release Versions of Your Program 15 Executing the Program 16 Dealing with Errors 18 Setting Options in Visual C++ 19 Creating and Executing Windows Applications 20 Creating an MFC Application 20 Building and Executing the MFC Application 22 Summary COPYRIGHTED MATERIAL 23 CHAPTER 2: DATA, VARIABLES, AND CALCULATIONS 25 The Structure of a C++ Program 26 Program Comments 31 The #include Directive — Header Files 32 Namespaces and the Using Declaration 33 The main() Function 34 Program Statements 34 fftoc.inddtoc.indd xxviivii 224/08/124/08/12 88:01:01 AAMM CONTENTS Whitespace 37 Statement Blocks 37 Automatically Generated Console Programs 37 Precompiled Header Files 38 Main Function Names 39 Defi ning Variables 39 Naming Variables 39 Keywords in C++ 40 Declaring Variables 41 Initial Values for Variables 41 Fundamental Data Types 42 Integer Variables 42 Character Data Types 44 Integer Type Modifi ers 45 The Boolean Type 46 Floating-Point Types 47 Fundamental Types in C++ 47 Literals 48 Defi ning Synonyms for Data Types 49 Basic Input/Output Operations 50 Input from the Keyboard 50
  • Self-Sorting SSD: Producing Sorted Data Inside Active Ssds

    Self-Sorting SSD: Producing Sorted Data Inside Active Ssds

    Foreword This volume contains the papers presentedat the Third Israel Symposium on the Theory of Computing and Systems (ISTCS), held in Tel Aviv, Israel, on January 4-6, 1995. Fifty five papers were submitted in response to the Call for Papers, and twenty seven of them were selected for presentation. The selection was based on originality, quality and relevance to the field. The program committee is pleased with the overall quality of the acceptedpapers and, furthermore, feels that many of the papers not used were also of fine quality. The papers included in this proceedings are preliminary reports on recent research and it is expected that most of these papers will appear in a more complete and polished form in scientific journals. The proceedings also contains one invited paper by Pave1Pevzner and Michael Waterman. The program committee thanks our invited speakers,Robert J. Aumann, Wolfgang Paul, Abe Peled, and Avi Wigderson, for contributing their time and knowledge. We also wish to thank all who submitted papers for consideration, as well as the many colleagues who contributed to the evaluation of the submitted papers. The latter include: Noga Alon Alon Itai Eric Schenk Hagit Attiya Roni Kay Baruch Schieber Yossi Azar Evsey Kosman Assaf Schuster Ayal Bar-David Ami Litman Nir Shavit Reuven Bar-Yehuda Johan Makowsky Richard Statman Shai Ben-David Yishay Mansour Ray Strong Allan Borodin Alain Mayer Eli Upfal Dorit Dor Mike Molloy Moshe Vardi Alon Efrat Yoram Moses Orli Waarts Jack Feldman Dalit Naor Ed Wimmers Nissim Francez Seffl Naor Shmuel Zaks Nita Goyal Noam Nisan Uri Zwick Vassos Hadzilacos Yuri Rabinovich Johan Hastad Giinter Rote The work of the program committee has been facilitated thanks to software developed by Rob Schapire and FOCS/STOC program chairs.
  • Combinatorial Topology and Distributed Computing Copyright 2010 Herlihy, Kozlov, and Rajsbaum All Rights Reserved

    Combinatorial Topology and Distributed Computing Copyright 2010 Herlihy, Kozlov, and Rajsbaum All Rights Reserved

    Combinatorial Topology and Distributed Computing Copyright 2010 Herlihy, Kozlov, and Rajsbaum All rights reserved Maurice Herlihy Dmitry Kozlov Sergio Rajsbaum February 22, 2011 DRAFT 2 DRAFT Contents 1 Introduction 9 1.1 DecisionTasks .......................... 10 1.2 Communication.......................... 11 1.3 Failures .............................. 11 1.4 Timing............................... 12 1.4.1 ProcessesandProtocols . 12 1.5 ChapterNotes .......................... 14 2 Elements of Combinatorial Topology 15 2.1 Theobjectsandthemaps . 15 2.1.1 The Combinatorial View . 15 2.1.2 The Geometric View . 17 2.1.3 The Topological View . 18 2.2 Standardconstructions. 18 2.3 Chromaticcomplexes. 21 2.4 Simplicial models in Distributed Computing . 22 2.5 ChapterNotes .......................... 23 2.6 Exercises ............................. 23 3 Manifolds, Impossibility,DRAFT and Separation 25 3.1 ManifoldComplexes ....................... 25 3.2 ImmediateSnapshots. 28 3.3 ManifoldProtocols .. .. .. .. .. .. .. 34 3.4 SetAgreement .......................... 34 3.5 AnonymousProtocols . .. .. .. .. .. .. 38 3.6 WeakSymmetry-Breaking . 39 3.7 Anonymous Set Agreement versus Weak Symmetry Breaking 40 3.8 ChapterNotes .......................... 44 3.9 Exercises ............................. 44 3 4 CONTENTS 4 Connectivity 47 4.1 Consensus and Path-Connectivity . 47 4.2 Consensus in Asynchronous Read-Write Memory . 49 4.3 Set Agreement and Connectivity in Higher Dimensions . 53 4.4 Set Agreement and Read-Write memory . 59 4.4.1 Critical States . 63 4.5 ChapterNotes .......................... 64 4.6 Exercises ............................. 64 5 Colorless Tasks 67 5.1 Pseudospheres .......................... 68 5.2 ColorlessTasks .......................... 72 5.3 Wait-Free Read-Write Memory . 73 5.3.1 Read-Write Protocols and Pseudospheres . 73 5.3.2 Necessary and Sufficient Conditions . 75 5.4 Read-Write Memory with k-Set Agreement .