Group-Solvability The Ultimate Wait-Freedom Eli Gafni UCLA DISC 2004 10/4/04.

Slides:



Advertisements
Similar presentations
Recognising Languages We will tackle the problem of defining languages by considering how we could recognise them. Problem: Is there a method of recognising.
Advertisements

College of Information Technology & Design
N-Consensus is the Second Strongest Object for N+1 Processes Eli Gafni UCLA Petr Kuznetsov Max Planck Institute for Software Systems.
Lecture 19. Reduction: More Undecidable problems
Linear Programming (LP) (Chap.29)
Bigamy Eli Gafni UCLA GETCO Outline Models, tasks, and solvability What is SM? r/w w.f. asynch computability Sperner Lemma as a consequence of the.
Mutual Exclusion By Shiran Mizrahi. Critical Section class Counter { private int value = 1; //counter starts at one public Counter(int c) { //constructor.
Is 1 different from 12? Eli Gafni UCLA Eli Gafni UCLA.
Lecture 12: Lower bounds By "lower bounds" here we mean a lower bound on the complexity of a problem, not an algorithm. Basically we need to prove that.
Approximation Algorithms Chapter 5: k-center. Overview n Main issue: Parametric pruning –Technique for approximation algorithms n 2-approx. algorithm.
R/W Reductions Eli Gafni UCLA Disc Godel Celebration 10/4/04.
R/W Reductions Eli Gafni UCLA ICDCN06 12/30. Outline Tasks and r/w impossible task: –2 cons –3 cons NP-completeness R/W reduction “Weakest Unsolvable.
CPSC 668Set 19: Asynchronous Solvability1 CPSC 668 Distributed Algorithms and Systems Fall 2006 Prof. Jennifer Welch.
Nathan Brunelle Department of Computer Science University of Virginia Theory of Computation CS3102 – Spring 2014 A tale.
4/5/05Tucker, Sec Applied Combinatorics, 4rth Ed. Alan Tucker Section 4.3 Graph Models Prepared by Jo Ellis-Monaghan.
Computability and Complexity 4-1 Existence of Undecidable Problems Computability and Complexity Andrei Bulatov.
1 State of the art for TSP TSP instances of thousand of cities can be consistently solved to optimality. Instances of up to cities have been solved:
1 Module 2: Fundamental Concepts Problems Programs –Programming languages.
Distributed Algorithms: Asynch R/W SM Computability Eli Gafni, UCLA Summer Course, CRI, Haifa U, Israel.
CSE115/ENGR160 Discrete Mathematics 02/24/11 Ming-Hsuan Yang UC Merced 1.
Lecture 2: Fundamental Concepts
1 Module 2: Fundamental Concepts Problems Programs –Programming languages.
CSE115/ENGR160 Discrete Mathematics 03/03/11 Ming-Hsuan Yang UC Merced 1.
Probably Approximately Correct Model (PAC)
1 Maximum matching Max Flow Shortest paths Min Cost Flow Linear Programming Mixed Integer Linear Programming Worst case polynomial time by Local Search.
Concurrency in Distributed Systems: Mutual exclusion.
Deriving an Algorithm for the Weak Symmetry Breaking Task Armando Castañeda Sergio Rajsbaum Universidad Nacional Autónoma de México.
1 Lecture 7 Topics –Problems about program behavior At least problem input is a program/algorithm –Halting Problem Fundamental problem about program behavior.
Branch and Bound Algorithm for Solving Integer Linear Programming
Programming Language Semantics Denotational Semantics Chapter 5 Part III Based on a lecture by Martin Abadi.
Induction and recursion
Primal-Dual Meets Local Search: Approximating MST’s with Non-uniform Degree Bounds Author: Jochen Könemann R. Ravi From CMU CS 3150 Presentation by Dan.
Lecture 8-1 Computer Science 425 Distributed Systems CS 425 / CSE 424 / ECE 428 Fall 2010 Indranil Gupta (Indy) September 16, 2010 Lecture 8 The Consensus.
DISCRETE MATHEMATICS I CHAPTER 11 Dr. Adam Anthony Spring 2011 Some material adapted from lecture notes provided by Dr. Chungsim Han and Dr. Sam Lomonaco.
Theory of Computing Lecture 15 MAS 714 Hartmut Klauck.
CSCE 668 DISTRIBUTED ALGORITHMS AND SYSTEMS Spring 2014 Prof. Jennifer Welch CSCE 668 Set 19: Asynchronous Solvability 1.
1 The Halting Problem and Decidability How powerful is a TM? Any program in a high level language can be simulated by a TM. Any algorithmic procedure carried.
MCA-2012Data Structure1 Algorithms Rizwan Rehman CCS, DU.
David Luebke 1 10/25/2015 CS 332: Algorithms Skip Lists Hash Tables.
MA/CSSE 474 Theory of Computation Enumerability Reduction.
CS4231 Parallel and Distributed Algorithms AY 2006/2007 Semester 2 Lecture 8 Instructor: Haifeng YU.
THIRD PART Algorithms for Concurrent Distributed Systems: The Mutual Exclusion problem.
Chapter Algorithms 3.2 The Growth of Functions 3.3 Complexity of Algorithms 3.4 The Integers and Division 3.5 Primes and Greatest Common Divisors.
Section 3.1. Section Summary Properties of Algorithms Algorithms for Searching and Sorting Greedy Algorithms Halting Problem.
1 Section 2.1 Algorithms. 2 Algorithm A finite set of precise instructions for performing a computation or for solving a problem.
Wait-Free Consensus CPSC 661 Fall 2003 Supervised by: Lisa Higham Presented by: Wei Wei Zheng Nuha Kamaluddeen.
CS294, Yelick Consensus revisited, p1 CS Consensus Revisited
Halting Problem and TSP Wednesday, Week 8. Background - Halting Problem Common error: Program goes into an infinite loop. Wouldn’t it be nice to have.
CS621 : Artificial Intelligence Pushpak Bhattacharyya CSE Dept., IIT Bombay Lecture 21: Perceptron training and convergence.
1 Suppose I construct a TM M f which: 1. Preserves its input u. 2. Simulates a machine M b on input ε. 3. If M b hangs on input ε, force an infinite loop.
Complexity & Computability. Limitations of computer science  Major reasons useful calculations cannot be done:  execution time of program is too long.
Spring 2003CS 4611 Replication Outline Failure Models Mirroring Quorums.
Donghyun (David) Kim Department of Mathematics and Computer Science North Carolina Central University 1 Chapter 7 Time Complexity Some slides are in courtesy.
Asynchronous Exclusive Selection Bogdan Chlebus, U. Colorado Darek Kowalski, U. Liverpool.
CSE 311 Foundations of Computing I Lecture 28 Computability: Other Undecidable Problems Autumn 2011 CSE 3111.
1 Fault tolerance in distributed systems n Motivation n robust and stabilizing algorithms n failure models n robust algorithms u decision problems u impossibility.
Fault tolerance and related issues in distributed computing Shmuel Zaks GSSI - Feb
Program Correctness. The designer of a distributed system has the responsibility of certifying the correctness of the system before users start using.
Ch03-Algorithms 1. Algorithms What is an algorithm? An algorithm is a finite set of precise instructions for performing a computation or for solving a.
Space Bounds for Reliable Storage: Fundamental Limits of Coding Alexander Spiegelman Yuval Cassuto Gregory Chockler Idit Keidar 1.
Discrete Mathematics Chapter 2 The Fundamentals : Algorithms, the Integers, and Matrices. 大葉大學 資訊工程系 黃鈴玲.
The Concurrency Hierarchy and Algorithms for Unbounded Concurrency Eli Gafni Michael Merritt Gadi Taubenfeld.
CSE15 Discrete Mathematics 03/06/17
Integer Programming An integer linear program (ILP) is defined exactly as a linear program except that values of variables in a feasible solution have.
CSE 311 Foundations of Computing I
Time Complexity Analysis Neil Tang 01/19/2010
James B. Orlin Presented by Tal Kaminker
Linear Programming Duality, Reductions, and Bipartite Matching
CSCE 668 DISTRIBUTED ALGORITHMS AND SYSTEMS
Output Variables {true} S {i = j} i := j; or j := i;
Presentation transcript:

Group-Solvability The Ultimate Wait-Freedom Eli Gafni UCLA DISC /4/04

Outline Motivation Group Solvability Solvability Non-Trivial Group-Solvable Task The Main Result Conclusion

Motivation a great solution in search of a fitting problem :) Clients-Servers Model –Clients announce input to server via SWMR-SM –Servers compute and deposit correct result for client p j in a MWMR register C j (initial ) –Server do not work on behalf of any particular client and the number of servers may be unbounded –If all but one server fail-stop all C j are eventually not Is there a non-trivial task r/w solvable in this model

Motivation Cont’ed Suppose we restrict the requirement and a server just works on behalf of a single client –The set of server working on behalf of the same client is a group –Servers of the same group step on each other writing an output No matter what output is chosen it is ok –Conclusion: the tuple of outputs created by a chice of any single rep for a each group constitutes a valid output tuple!

Motivation Cont’ed Example- 3 processor renaming (3,5) –Input/output: a client p i appears i=0,1,2 output unique slot in {1,…,5} –Servers: q i,1,q i,2 working for p i i=0,1,2 –Can be viewed as the following task over servers: 6 processors task A processor outputs a slot in {1,…,5} q i,*, q j,* i j output different slots

Motivation Cont’ed Since no apriori bound on the number of servers - of particular interest each group size is infinite (unbounded). A Task T n is r/w group-solvable if the task with each group infinite is solvable Motivation in the paper for group-renaming –Each member of the group in possession of the same info to be posted –As long as the whole group does not fail at least one posting will happen –Minimal number of MWMR posting boards needed?

Group Solvability Solvability 3-proc convergence task 3-proc in each group: simulators each simulating In order: P123 A simulator determines a simplex and outputs the color-tower By compatibilty of outputs only two adjacent simplexes possible 3 simulators solve 2-set election!

Is there Anything Interesting which is Group-Solvable? Yes: Renaming R(n,(n+1)n/2) n MWMR registers C 0,…,C n-1 initialized to p i,* : Ci :=1 k := |S i := snap{j|C j =1}| r := rank i in S i return k(k-1)/2 + r Each snap of size k has k consecutive dedicated registers that come after all the dedecated registers fo j<k and before all the registers for j>k.

Same Result via “Splitters” Splitter: C i i=0,…,n-1 MWMR registers initially p i,* Ci:=1 Si:=Scan{j| Cj=1} if |S i |=1 then return “stay” else if i<max(S i ) then return “left” else return “right” Max does not go “left” min not “right” Donot try X,Y Group-splitter - by AEG03 does not exits

Same Result via “Splitters” Cont’ed AR

Contemplation: Renaming with n infinite groups can be done in finite number of slots. If we grow up the size of the groups 1,2,… at what integer the growth of the number of slots stops?

The Main Result: Theorem: A task T n-1 on n processors p 0,…,p n-1 is group-solvable iff T n-1 is solvable for groups of size n-1. Proof proceed by infinite number of processors simulating the n-1 group size algorithm. The simulation uses about bn^3 MWMR registers and simulator make take a step on behalf of any processor. Corollary: 3-proc convergence is not solvable even for groups of size 2.

Conclusions New Clients-Servers Model –Eg BG simulationcan be thought of as client server with guarantee of receiving c-(s-1) results Lower bound on Group-Solvable renaming and seamless algorithm as groups grow Imm Snaps is not Group Solvable but “there exists” Group-Solvable