R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch

Slides:



Advertisements
Similar presentations
1 © R. Guerraoui Universal constructions R. Guerraoui Distributed Programming Laboratory.
Advertisements

Mutual Exclusion – SW & HW By Oded Regev. Outline: Short review on the Bakery algorithm Short review on the Bakery algorithm Black & White Algorithm Black.
1 © R. Guerraoui The Limitations of Registers R. Guerraoui Distributed Programming Laboratory.
Transactions - Concurrent access & System failures - Properties of Transactions - Isolation Levels 4/13/2015Databases21.
© 2005 P. Kouznetsov Computing with Reads and Writes in the Absence of Step Contention Hagit Attiya Rachid Guerraoui Petr Kouznetsov School of Computer.
Relaxed Consistency Models. Outline Lazy Release Consistency TreadMarks DSM system.
A General Characterization of Indulgence R. Guerraoui EPFL joint work with N. Lynch (MIT)
1 © R. Guerraoui The Power of Registers Prof R. Guerraoui Distributed Programming Laboratory.
1 CSIS 7102 Spring 2004 Lecture 8: Recovery (overview) Dr. King-Ip Lin.
1 Algorithms and protocols for distributed systems We have defined process groups as having peer or hierarchical structure and have seen that a coordinator.
1 © R. Guerraoui Implementing the Consensus Object with Timing Assumptions R. Guerraoui Distributed Programming Laboratory.
What is ’’hard’’ in distributed computing? R. Guerraoui EPFL/MIT joint work with. Delporte and H. Fauconnier (Univ of Paris)
Distributed Systems Fall 2010 Replication Fall 20105DV0203 Outline Group communication Fault-tolerant services –Passive and active replication Highly.
Termination and Recovery MESSAGES RECEIVED SITE 1SITE 2SITE 3SITE 4 initial state committablenon Round 1(1)CNNN-NNNN Round 2FAILED(1)-CNNN--NNN Round 3FAILED.
Eddie Bortnikov & Aran Bergman, Principles of Reliable Distributed Systems, Technion EE, Spring Principles of Reliable Distributed Systems Recitation.
1 © R. Guerraoui - Shared Memory - R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch.
Distributed systems Module 2 -Distributed algorithms Teaching unit 1 – Basic techniques Ernesto Damiani University of Bozen Lesson 3 – Distributed Systems.
2. Multiprocessors Main Structures 2.1 Shared Memory x Distributed Memory Shared-Memory (Global-Memory) Multiprocessor:  All processors can access all.
EEC 688/788 Secure and Dependable Computing Lecture 12 Wenbing Zhao Department of Electrical and Computer Engineering Cleveland State University
What Can Be Implemented Anonymously ? Paper by Rachid Guerraui and Eric Ruppert Presentation by Amir Anter 1.
Distributed Systems Fall 2009 Replication Fall 20095DV0203 Outline Group communication Fault-tolerant services –Passive and active replication Highly.
4. Multiprocessors Main Structures 4.1 Shared Memory x Distributed Memory Shared-Memory (Global-Memory) Multiprocessor:  All processors can access all.
CHAPTER 10 Recursion. 2 Recursive Thinking Recursion is a programming technique in which a method can call itself to solve a problem A recursive definition.
Midterm Exam 06: Exercise 2 Atomic Shared Memory.
Election Algorithms and Distributed Processing Section 6.5.
1 © R. Guerraoui Seth Gilbert Professor: Rachid Guerraoui Assistants: M. Kapalka and A. Dragojevic Distributed Programming Laboratory.
28/08/2015SJF L31 F21SF Software Engineering Foundations ASSUMPTIONS AND TESTING Monica Farrow EM G30 Material available on Vision.
CS4231 Parallel and Distributed Algorithms AY 2006/2007 Semester 2 Lecture 3 (26/01/2006) Instructor: Haifeng YU.
Byzantine fault-tolerance COMP 413 Fall Overview Models –Synchronous vs. asynchronous systems –Byzantine failure model Secure storage with self-certifying.
Synchronization CSCI 4780/6780. Mutual Exclusion Concurrency and collaboration are fundamental to distributed systems Simultaneous access to resources.
1 Chapter 9 Synchronization Algorithms and Concurrent Programming Gadi Taubenfeld © 2014 Synchronization Algorithms and Concurrent Programming Synchronization.
1 © R. Guerraoui Regular register algorithms R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch.
Replication (1). Topics r Why Replication? r System Model r Consistency Models – How do we reason about the consistency of the “global state”? m Data-centric.
Copyright © George Coulouris, Jean Dollimore, Tim Kindberg This material is made available for private study and for direct.
Distributed systems Consensus Prof R. Guerraoui Distributed Programming Laboratory.
1 © R. Guerraoui Registers Prof R. Guerraoui Distributed Programming Laboratory.
1 © R. Guerraoui Distributed algorithms Prof R. Guerraoui Assistant Marko Vukolic Exam: Written, Feb 5th Reference: Book - Springer.
Asynchronous Exclusive Selection Bogdan Chlebus, U. Colorado Darek Kowalski, U. Liverpool.
Distributed Storage Systems: Data Replication using Quorums.
“Towards Self Stabilizing Wait Free Shared Memory Objects” By:  Hopeman  Tsigas  Paptriantafilou Presented By: Sumit Sukhramani Kent State University.
“Distributed Algorithms” by Nancy A. Lynch SHARED MEMORY vs NETWORKS Presented By: Sumit Sukhramani Kent State University.
ISA 95 Working Group (Business) Process Centric Exchanges Dennis Brandl A Modest Proposal July 22, 2015.
1 © R. Guerraoui Set-Agreement (Generalizing Consensus) R. Guerraoui.
Space Bounds for Reliable Storage: Fundamental Limits of Coding Alexander Spiegelman Yuval Cassuto Gregory Chockler Idit Keidar 1.
Chapter 5 Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee.
Lecture 3 – MapReduce: Implementation CSE 490h – Introduction to Distributed Computing, Spring 2009 Except as otherwise noted, the content of this presentation.
DURABILITY OF TRANSACTIONS AND CRASH RECOVERY
Atomic register algorithms
Computational Models Database Lab Minji Jo.
Computing with anonymous processes
Implementing Consistency -- Paxos
Alternating Bit Protocol
Parallel and Distributed Algorithms
Outline Announcements Fault Tolerance.
EEC 688/788 Secure and Dependable Computing
EEC 688/788 Secure and Dependable Computing
Kernel Synchronization II
Recursion Chapter 11.
UNIVERSITAS GUNADARMA
Constructing Reliable Registers From Unreliable Byzantine Components
- Atomic register specification -
EEC 688/788 Secure and Dependable Computing
R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch
Consistency and Replication
Computing with anonymous processes
CSE 542: Operating Systems
Implementing Consistency -- Paxos
Distributed systems Consensus
CIS 720 Concurrency Control.
Fault-Tolerant SemiFast Implementations of Atomic Read/Write Registers
Presentation transcript:

R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch - Shared Memory - R. Guerraoui Distributed Programming Laboratory lpdwww.epfl.ch © R. Guerraoui

The application model P2 Registers P3 P1

Register (assumptions) For presentation simplicity, we assume registers of integers We also assume that the initial value of a register is 0 and this value is initialized (written()) by some process before the register is used We assume that every value written is uniquely identified (this can be ensured by associating a process id and a timestamp with the value)

Register: specification Assume a register that is local to a process, i.e., accessed only by one process: In this case, the value returned by a Read() is the last value written

Sequential execution P2 P1 W(5) W(6) R()

Sequential execution R() -> 5 R() -> 6 P1 W(5) W(6) P2

Concurrent execution R1() -> ? R2() -> ? R3() -> ? P1 W(5)

Execution with failures P1 W(6) crash W(5) P2

Regular register It assumes only one writer; multiple processes might however write in the register It provides strong guarantees when there is no concurrent or failed operations (invoked by processes that fail in the middle) When some operations are concurrent, or some operation fails, the register provides minimal guarantees

Regular register Read() returns: the last value written if there is no concurrent or failed operations and otherwise the last value written or any value concurrently written, i.e., the input parameter of some Write()

Execution R1() R2() R3() P1 W(5) W(6) P2

Results 1 R1() -> 5 R2() -> 0 R3() -> 25 P1 W(6) W(5) P2

Results 2 P2 P1 W(5) W(6) R1() -> 5 R2() -> 6 R3() -> 5

Results 3 R() -> 5 P1 W(6) crash W(5) P2

Results 4 R() -> 6 P1 W(6) crash W(5) P2

Correctness Results 1: non-regular register (safe) Results 2; 3; 4: regular register