DOCSLIB.ORG

(12) Patent Application Publication (10) Pub. No.: US 2004/0107227 A1 Michael (43) Pub

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

US 2004O107227A1 (19) United States (12) Patent Application Publication (10) Pub. No.: US 2004/0107227 A1 Michael (43) Pub. Date: Jun. 3, 2004 (54) METHOD FOR EFFICIENT Publication Classification IMPLEMENTATION OF DYNAMIC LOCK-FREE DATASTRUCTURES WITH (51) Int. Cl." ............................ G06F 17/30; G06F 12/00 SAFE MEMORY RECLAMATION (52) U.S. Cl. .............................................................. 707/206 (57) ABSTRACT Inventor: (75) Maged M. Michael, Danbury, CT (US) A method for Safe memory reclamation for dynamic lock free data structures employs a plurality of Shared pointers, Correspondence Address: called hazard pointers, that are associated with each partici F. CHAU & ASSOCIATES, LLP pating thread. Hazard pointers either have null values or Suite 501 point to nodes that may potentially be accessed by a thread 1900 Hempstead Turnpike without further verification of the validity of the local East Meadow, NY 11554 (US) references used in their access. Each hazard pointer can be written only by its associated thread, but can be read by all (73) Assignee: International Business Machines Cor threads. The method requires target lock-free algorithms to poration, Armonk, NY (US) guarantee that no thread can access a dynamic node at a time when it is possibly unsafe (i.e., removed from the data (21) Appl. No.: 10/308,449 Structure), unless one or more of its associated hazard pointerS has been pointing to the node continuously, from a (22) Filed: Dec. 3, 2002 time when it was not removed. 2 3 4. Hash table With 7 buckets and hash function h(k) F k mod 7 Patent Application Publication Jun. 3, 2004 Sheet 1 of 8 US 2004/0107227A1 PRIMARY STORAGE OPERATING SECONDARY I/O SYSTEM STORAGE SERVICES Application Programs FIG. Patent Application Publication Jun. 3, 2004 Sheet 2 of 8 US 2004/0107227 A1 // Node structure structure NodeType {Data:DataType; Next:*NodeType;} // Shared variables Top:*NodeType; // Initially Top = null // hp is a private pointer to a hazard pointer of the current thread Pop(): DataType { While true { 1. t = Top; 2 ift = null return EMPTY; 3 *hp = ti 4 if Top = t continue; // try again; 5 next = t.Next; 6 if CAS(&Top, t, next) break; } data = t Data; RetireNode(t); return data; } Exemplary lock-free Pop operation from a shared stack with hazard pointers FIG. 2 Patent Application Publication Jun. 3, 2004 Sheet 3 of 8 US 2004/0107227 A1 // Per-thread hazard pointer record structure HPRecType (HPIK) : *NodeType; Next: *HPRecType;} // The header of the HPRec list FirstHPRec: *HPRecType; // Static private variables rlist : *NodeType; // initially null rcount : integer; // initially 0 FIG. 3(A) RetireNode(node:*NodeType) { node'.rlink= rlist; rlist = node, rcount----, ifrcount >= R ScanG); FIG. 3(B) Patent Application Publication Jun. 3, 2004 Sheet 4 of 8 US 2004/0107227 A1 Scan() { i, p: integer, hptr, node, next, plist K*P) : *NodeType; // Stage 1 - scan HP list p = 0; hprec= FirstHPRec; while hprec = null { for i = 0 to K-1 if (hptr = hprec.HPi)) = null plist p-t = hptr; hprec = hprec/.Next; } // Stage 2 - sort plist Sort(p.plist); // Stage 3 - search sorted list next = rlist; rlist = null; rcount = 0; while next = null { node F next; next = node'.rlink; if search(node.p.plist) { node'.rlink = rlist; rlist = node, rcount++; } else PrepareForReuse(node); FIG. 3(C) Patent Application Publication Jun. 3, 2004 Sheet 5 of 8 US 2004/0107227 A1 Hash table with 7 buckets and hash function h(k) FK mod 7 FIG. 4 Patent Application Publication Jun. 3, 2004 Sheet 6 of 8 US 2004/0107227 A1 // Types and structures Structure NodeType {Key: KeyType; Next: *NodeType} // T is the hash table - // M is the number of hash buckets TMI: *NodeType; // Initially null Types and structures FIG. 5 // Hash function h(key: KeyType): 0.M-1 {...} // Hash table operations Hashinsert(key: KeyType): boolean { // Assuming new node allocation always succeeds node = NewNode(); node. Key = key; if Insert(&Th(key), node) return true; FreeNode(node); return false; HashDelete(key: KeyType): boolean { Return Delete(&Th(key)),key); } - HashSearch(key: KeyType): boolean { Return Search(&Th(key)),key); } Hash table operations FIG. 6 Patent Application Publication Jun. 3, 2004 Sheet 7 of 8 US 2004/0107227 A1 // hp0 and hp1 are private pointers to the hazard pointers of the current thread // *hp0 has a lower index than *hp1 in the thread's HPRec // Static private variables prev:**NodeType; cur, next : *NodeType; Find(head:**NodeType;key:KeyType) : boolean { try again: 1 prev = head; 2 cur = *head; 3 while curl= null { 5 if *prev = cur goto try again; 6 next = cur.Next; 7 if next & 1 { 8 if CAS(prev,cur, next-1) goto try again; 9 RetireNode(cur); 10 cur = next-l; 1 } else { 12 ckey - cur.Key; 13 if prev - curgoto try again; 14 ifckey >= key returnckey - key; 15 prev = &cur.Next; 16 hp1 = cur; 17 cur = next; 18 } - 19 } 20 return false; List-base set algorithm with hazard pointers FIG. 7(A) Patent Application Publication Jun. 3, 2004 Sheet 8 of 8 US 2004/0107227 A1 Insert (head:**NodeType, node:*NodeType):boolean { key - node?. Key; while true { 21 if Find(head,key) { result = false; break;} 22 node^.Next = cur; 23 if CAS(prev,cur.node) { result = true; break;} } return result, } Delete(head:**NodeType,key:KeyType):boolean { while true { 24 if Find (head,key) (result = false; break;} 25 if CAS(&cur.Next{\tuple{Mark,Next, next, next{-1) continue; 26 if CAS(prev,cur, next) RetireNode(cur); else Find(head,key); result = true, break; } return result, }. Search(head:**NodeType, key:KeyType):boolean { result = Find(head,key), return result, List-base set algorithm with hazard pointers FIG. 7 (B) US 2004/0107227 A1 Jun. 3, 2004 METHOD FOR EFFICIENT IMPLEMENTATION an old reference to the node with the intent to use that OF DYNAMIC LOCK-FREE DATASTRUCTURES reference as an expected value of an atomic operation on the WITH SAFE MEMORY RECLAMATION object. This can happen even if nodes are only reused but never reclaimed. For these objects, the ABA problem can be BACKGROUND OF THE INVENTION prevented if it is guaranteed that no thread can use the address of a node as an expected value of an atomic 0001) 1. Field of the Invention operation, while the node is free or ready for reuse. 0002 The present invention relates generally to memory 0010 Another significant problem associated with some management, and more particularly, to techniques for man important lock-free data Structures based on linked-lists is aging shared access among multiple threads. that they require garbage collection (GC) for memory man 0003 2. Background of the Invention agement, which is not always available, and hence limit the portability of Such data Structures acroSS programming envi 0004. A shared object is lock-free (also called non blocking) if it guarantees that in a System with multiple rOnmentS. threads attempting to perform operations on the object, Some SUMMARY OF THE INVENTION thread will complete an operation Successfully in a finite 0011. According to various embodiments of the present number of system steps even with the possibility of arbitrary invention, a computer-implemented method for managing a thread delays, provided that not all threads are delayed shared dynamic data Structure in a multithreaded operating indefinitely. By definition, lock-free objects are immune to environment includes Setting a hazard pointer to an address deadlock even with thread failures and provide robust per of a portion of the data Structure to be removed, removing formance even when faced with inopportune thread delayS. the portion of the data structure, and ensuring that memory Dynamic lock-free objects have the added advantage of asSociated with the removed portion of the data structure is arbitrary size. freed only when the hazard pointer no longer points to the 0005. However, there are various problems associated removed portion of the data Structure. with lock-free objects. For instance, it may be difficult to 0012 Each thread sharing the dynamic data structure will ensure Safe reclamation of memory occupied by removed preferably have at least one hazard pointer which may be Set nodes. In a lock-based object, when a thread removes a node to a null value or to portions of the data Structure that are from the object, it can be guaranteed that no other thread will accessed by the thread without verification of references Subsequently access the contents of the removed node while used in their access. The thread Setting the hazard pointer Still assuming its retention of type and content Semantics. ensures that it accesses a portion of the data structure to be Consequently, it is Safe for the removing thread to free the removed, only if the hazard pointer continuously points to memory occupied by the removed node into the general the portion of the data Structure from a time it was not memory pool for arbitrary future reuse. removed. Another thread can then free the removed portion 0006. This is not the case for a lock-free object. When a of the data Structure for arbitrary reuse. Operations on the thread removes a node, it is possible that one or more data Structure are guaranteed to proceed concurrently with contending threads, in the course of their lock-free opera out any one of the operations preventing other operations tions, have earlier read a pointer to the Subsequently from completing indefinitely. removed node, and are about to access its contents. A 0013 The data structure used can be a linked list and, in contending thread might corrupt the shared object or another this case, the removed portion of the data structure will be object, if the thread performing the removal were to free the a node. The linked-list data Structure may be used to removed node for arbitrary reuse.
Recommended publications
  • Practical Parallel Data Structures

    Practical Parallel Data Structures

    Practical Parallel Data Structures Shahar Timnat Technion - Computer Science Department - Ph.D. Thesis PHD-2015-06 - 2015 Technion - Computer Science Department - Ph.D. Thesis PHD-2015-06 - 2015 Practical Parallel Data Structures Research Thesis Submitted in partial fulfillment of the requirements for the degree of Doctor of Philosophy Shahar Timnat Submitted to the Senate of the Technion | Israel Institute of Technology Sivan 5775 Haifa June 2015 Technion - Computer Science Department - Ph.D. Thesis PHD-2015-06 - 2015 Technion - Computer Science Department - Ph.D. Thesis PHD-2015-06 - 2015 This research was carried out under the supervision of Prof. Erez Petrank, in the Faculty of Computer Science. Some results in this thesis have been published as articles by the author and research collaborators in conferences during the course of the author's doctoral research period, the most up-to-date versions of which being: Keren Censor-Hillel, Erez Petrank, and Shahar Timnat. Help! In Proceedings of the 34th Annual ACM Symposium on Principles of Distributed Computing, PODC 2015, Donostia-San Sebastian, Spain, July 21-23, 2015. Erez Petrank and Shahar Timnat. Lock-free data-structure iterators. In Distributed Computing - 27th International Symposium, DISC 2013, Jerusalem, Israel, October 14-18, 2013. Proceedings, pages 224{238, 2013. Shahar Timnat, Anastasia Braginsky, Alex Kogan, and Erez Petrank. Wait-free linked-lists. In Principles of Distributed Systems, 16th International Conference, OPODIS 2012, Rome, Italy, December 18-20, 2012. Proceedings, pages 330{344, 2012. Shahar Timnat, Maurice Herlihy, and Erez Petrank. A practical transactional memory interface. In Euro-Par 2015 Parallel Processing - 21st International Conference, Vienna, Austria, August 24-28, 2015.
  • Contention Resistant Non-Blocking Priority Queues

    Contention Resistant Non-Blocking Priority Queues

    Contention resistant non-blocking priority queues Lars Frydendal Bonnichsen Kongens Lyngby 2012 IMM-MSC-2012-21 Technical University of Denmark Informatics and Mathematical Modelling Building 321, DK-2800 Kongens Lyngby, Denmark Phone +45 45253351, Fax +45 45882673 [email protected] www.imm.dtu.dk 3 Table of contents 1 Abstract...........................................................................................................................4 2 Acknowledgments..........................................................................................................5 3 Introduction....................................................................................................................6 3.1 Contributions...........................................................................................................6 3.2 Outline.....................................................................................................................7 4 Background.....................................................................................................................8 4.1 Terminology............................................................................................................8 4.2 Prior work.............................................................................................................13 4.3 Summary...............................................................................................................20 5 Concurrent building blocks..........................................................................................21
  • Efficient and Practical Non-Blocking Data Structures

    Efficient and Practical Non-Blocking Data Structures

    Thesis for the degree of Doctor of Philosophy Efficient and Practical Non-Blocking Data Structures HAKAN˚ SUNDELL Department of Computing Science Chalmers University of Technology and G¨oteborg University SE-412 96 G¨oteborg, Sweden G¨oteborg, 2004 Efficient and Practical Non-Blocking Data Structures HAKAN˚ SUNDELL ISBN 91-7291-514-5 c HAKAN˚ SUNDELL, 2004. Doktorsavhandlingar vid Chalmers tekniska h¨ogskola Ny serie nr 2196 ISSN 0346-718X Technical report 30D ISSN 1651-4971 School of Computer Science and Engineering Department of Computing Science Chalmers University of Technology and G¨oteborg University SE-412 96 G¨oteborg Sweden Telephone + 46 (0)31-772 1000 Cover: A skip list data structure with concurrent inserts and deletes. Chalmers Reproservice G¨oteborg, Sweden, 2004 Abstract This thesis deals with how to design and implement efficient, practical and reliable concurrent data structures. The design method using mutual ex- clusion incurs serious drawbacks, whereas the alternative non-blocking tech- niques avoid those problems and also admit improved parallelism. However, designing non-blocking algorithms is a very complex task, and a majority of the algorithms in the literature are either inefficient, impractical or both. We have studied how information available in real-time systems can im- prove and simplify non-blocking algorithms. We have designed new methods for recycling of buffers as well as time-stamps, and have applied them on known non-blocking algorithms for registers, snapshots and priority queues. We have designed, to the best of our knowledge, the first practical lock- free algorithm of a skip list data structure. Using our skip list construction we have designed a lock-free algorithm of the priority queue abstract data type, as well as a lock-free algorithm of the dictionary abstract data type.
  • On the Design and Implementation of an Efficient Lock-Free Scheduler

    On the Design and Implementation of an Efficient Lock-Free Scheduler

    On the Design and Implementation of an Efficient Lock-Free Scheduler B Florian Negele1, Felix Friedrich1,SuwonOh2, and Bernhard Egger2( ) 1 Department of Computer Science, ETH Z¨urich, Z¨urich, Switzerland {negelef,felix.friedrich}@inf.ethz.ch 2 Department of Computer Science and Engineering, Seoul National University, Seoul, Korea {suwon,bernhard}@csap.snu.ac.kr Abstract. Schedulers for symmetric multiprocessing (SMP) machines use sophisticated algorithms to schedule processes onto the available processor cores. Hardware-dependent code and the use of locks to protect shared data structures from simultaneous access lead to poor portability, the difficulty to prove correctness, and a myriad of problems associated with locking such as limiting the available parallelism, deadlocks, starva- tion, interrupt handling, and so on. In this work we explore what can be achieved in terms of portability and simplicity in an SMP scheduler that achieves similar performance to state-of-the-art schedulers. By strictly limiting ourselves to only lock-free data structures in the scheduler, the problems associated with locking vanish altogether. We show that by employing implicit cooperative scheduling, additional guarantees can be made that allow novel and very efficient implementations of memory- efficient unbounded lock-free queues. Cooperative multitasking has the additional benefit that it provides an extensive hardware independence. It even allows the scheduler to be used as a runtime library for appli- cations running on top of standard operating systems. In a comparison against Windows Server and Linux running on up to 64 cores we analyze the performance of the lock-free scheduler and show that it matches or even outperforms the performance of these two state-of-the-art sched- ulers in a variety of benchmarks.
  • High Performance Dynamic Lock-Free Hash Tables and List-Based Sets

    High Performance Dynamic Lock-Free Hash Tables and List-Based Sets

    High Performance Dynamic Lock-Free Hash Tables and List-Based Sets Maged M. Michael IBM Thomas J. Watson Research Center P.O. Box 218 Yorktown Heights NY 10598 USA [email protected] ABSTRACT based shared objects suffer significant performance degrada- tion when faced with the inopportune delay of a thread while Lock-free (non-blocking) shared data structures promise more holding a lock, for instance due to preemption. While the robust performance and reliability than conventional lock- lock holder is delayed, other active threads that need ac- based implementations. However, all prior lock-free algo- cess to the locked shared object are prevented from making rithms for sets and hash tables suffer from serious drawbacks progress until the lock is released by the delayed thread. that prevent or limit their use in practice. These drawbacks A lock-free (also called non-blocking) implementation of include size inflexibility, dependence on atomic primitives not a shared object guarantees that if there is an active thread supported on any current processor architecture, and depen- trying to perform an operation on the object, some operation, dence on highly-inefficient or blocking memory management by the same or another thread, will complete within a finite techniques. number of steps regardless of other threads’ actions [8]. Lock- Building on the results of prior researchers, this paper free objects are inherently immune to priority inversion and presents the first CAS-based lock-free list-based set algorithm deadlock, and offer robust performance, even with indefinite thread delays and failures. that is compatible with all lock-free memory management Shared sets (also called dictionaries) are the building blocks methods.
  • Verifying Concurrent Memory Reclamation Algorithms with Grace

    Verifying Concurrent Memory Reclamation Algorithms with Grace

    Verifying Concurrent Memory Reclamation Algorithms with Grace Alexey Gotsman, Noam Rinetzky, and Hongseok Yang 1 IMDEA Software Institute 2 Tel-Aviv University 3 University of Oxford Abstract. Memory management is one of the most complex aspects of mod- ern concurrent algorithms, and various techniques proposed for it—such as haz- ard pointers, read-copy-update and epoch-based reclamation—have proved very challenging for formal reasoning. In this paper, we show that different memory reclamation techniques actually rely on the same implicit synchronisation pat- tern, not clearly reflected in the code, but only in the form of assertions used to argue its correctness. The pattern is based on the key concept of a grace period, during which a thread can access certain shared memory cells without fear that they get deallocated. We propose a modular reasoning method, motivated by the pattern, that handles all three of the above memory reclamation techniques in a uniform way. By explicating their fundamental core, our method achieves clean and simple proofs, scaling even to realistic implementations of the algorithms without a significant increase in proof complexity. We formalise the method us- ing a combination of separation logic and temporal logic and use it to verify example instantiations of the three approaches to memory reclamation. 1 Introduction Non-blocking synchronisation is a style of concurrent programming that avoids the blocking inherent to lock-based mutual exclusion. Instead, it uses low-level synchro- nisation techniques, such as compare-and-swap operations, that lead to more complex algorithms, but provide a better performance in the presence of high contention among threads.
  • Verifying Concurrent Memory Reclamation Algorithms with Grace

    Verifying Concurrent Memory Reclamation Algorithms with Grace

    Verifying Concurrent Memory Reclamation Algorithms with Grace Alexey Gotsman, Noam Rinetzky, and Hongseok Yang 1 IMDEA Software Institute 2 Tel-Aviv University 3 University of Oxford Abstract. Memory management is one of the most complex aspects of mod- ern concurrent algorithms, and various techniques proposed for it—such as haz- ard pointers, read-copy-update and epoch-based reclamation—have proved very challenging for formal reasoning. In this paper, we show that different memory reclamation techniques actually rely on the same implicit synchronisation pat- tern, not clearly reflected in the code, but only in the form of assertions used to argue its correctness. The pattern is based on the key concept of a grace period, during which a thread can access certain shared memory cells without fear that they get deallocated. We propose a modular reasoning method, motivated by the pattern, that handles all three of the above memory reclamation techniques in a uniform way. By explicating their fundamental core, our method achieves clean and simple proofs, scaling even to realistic implementations of the algorithms without a significant increase in proof complexity. We formalise the method us- ing a combination of separation logic and temporal logic and use it to verify example instantiations of the three approaches to memory reclamation. 1 Introduction Non-blocking synchronisation is a style of concurrent programming that avoids the blocking inherent to lock-based mutual exclusion. Instead, it uses low-level synchro- nisation techniques, such as compare-and-swap operations, that lead to more complex algorithms, but provide a better performance in the presence of high contention among threads.
  • Non-Blocking Data Structures Handling Multiple Changes Atomically Niloufar Shafiei a Dissertation Submitted to the Faculty of Gr

    Non-Blocking Data Structures Handling Multiple Changes Atomically Niloufar Shafiei a Dissertation Submitted to the Faculty of Gr

    NON-BLOCKING DATA STRUCTURES HANDLING MULTIPLE CHANGES ATOMICALLY NILOUFAR SHAFIEI A DISSERTATION SUBMITTED TO THE FACULTY OF GRADUATE STUDIES IN PARTIAL FULFILMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY GRADUATE PROGRAM IN DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING YORK UNIVERSITY TORONTO, ONTARIO JULY 2015 c NILOUFAR SHAFIEI, 2015 Abstract Here, we propose a new approach to design non-blocking algorithms that can apply multiple changes to a shared data structure atomically using Compare&Swap (CAS) instructions. We applied our approach to two data structures, doubly-linked lists and Patricia tries. In our implementations, only update operations perform CAS instructions; operations other than updates perform only reads of shared memory. Our doubly-linked list implements a novel specification that is designed to make it easy to use as a black box in a concurrent setting. In our doubly-linked list implementation, each process accesses the list via a cursor, which is an object in the process's local memory that is located at an item in the list. Our specification describes how updates affect cursors and how a process gets feedback about other processes' updates at the location of its cursor. We provide a detailed proof of correctness for our list implementation. We also give an amortized analysis for our list implementation, which is the first upper bound on amortized time complexity that has been proved for a concurrent doubly-linked list. In addition, we evaluate ii our list algorithms on a multi-core system empirically to show that they are scalable in practice. Our non-blocking Patricia trie implementation stores a set of keys, represented as bit strings, and allows processes to concurrently insert, delete and find keys.
  • Memory Reclamation Strategies for Lock-Free and Concurrently-Readable Data Structures

    Memory Reclamation Strategies for Lock-Free and Concurrently-Readable Data Structures

    Comparative Performance of Memory Reclamation Strategies for Lock-free and Concurrently-readable Data Structures by Thomas Edward Hart A thesis submitted in conformity with the requirements for the degree of Master of Science Graduate Department of Computer Science University of Toronto Copyright c 2005 by Thomas Edward Hart Abstract Comparative Performance of Memory Reclamation Strategies for Lock-free and Concurrently-readable Data Structures Thomas Edward Hart Master of Science Graduate Department of Computer Science University of Toronto 2005 Despite their advantages, lock-free algorithms are often not adopted in practice, partly due to the perception that they perform poorly relative to lock-based alternatives in common situations when there is little contention for objects or the CPUs. We show that memory reclamation can be a dominant performance cost for lock-free algorithms; therefore, choosing the most efficient memory reclamation method is essential to having lock-free algorithms perform well. We compare the costs of three memory reclamation strategies: quiescent-state-based reclamation, epoch-based reclamation, and safe memory reclamation. Our experiments show that changing the workload or execution environment can change which of these schemes is the most efficient. We therefore demonstrate that there is, to date, no panacea for memory reclamation for lock-free algorithms. Using a common reclamation scheme, we fairly compare lock-free and concurrently- readable hash tables. Our evaluation shows that programmers can choose memory recla- mation schemes mostly independently of the target algorithm. ii Acknowledgements First, I'd like to thank my supervisor, Angela Demke-Brown, for helping me shape my vague ideas into coherent research, and helping me to take a step back and see which questions are important and which are not.
  • Distributed Computing with Modern Shared Memory

    Distributed Computing with Modern Shared Memory

    Thèse n° 7141 Distributed Computing with Modern Shared Memory Présentée le 20 novembre 2020 à la Faculté informatique et communications Laboratoire de calcul distribué Programme doctoral en informatique et communications pour l’obtention du grade de Docteur ès Sciences par Mihail Igor ZABLOTCHI Acceptée sur proposition du jury Prof. R. Urbanke, président du jury Prof. R. Guerraoui, directeur de thèse Prof. H. Attiya, rapporteuse Prof. N. Shavit, rapporteur Prof. J.-Y. Le Boudec, rapporteur 2020 “Where we going man?” “I don’t know but we gotta go.” — Jack Kerouac, On the Road To my grandmother Momo, who got me started on my academic adventure and taught me that learning can be fun. Acknowledgements I am first and foremost grateful to my advisor, Rachid Guerraoui. Thank you for believing in me, for encouraging me to trust my own instincts, and for opening so many doors for me. Looking back, it seems like you always made sure I had the perfect conditions to do my best possible work. Thank you also for all the things you taught me: how to get at the heart of a problem, how to stay optimistic despite all signs to the contrary, how to be pragmatic while also chasing beautiful problems. I am grateful to my other supervisors and mentors: Yvonne Anne Pignolet and Ettore Ferranti for my internship at ABB Research, Maurice Herlihy for the time at Brown University and at Oracle Labs, Dahlia Malkhi and Ittai Abraham for my internship at VMware, Virendra Marathe and Alex Kogan for my internship at Oracle Labs and the subsequent collaboration, Marcos Aguilera for the collaboration on the RDMA work, and Aleksandar Dragojevic for the internship at Microsoft Research.