Simulating Few by Many: k-concurrency via k-set Consensus

Transcription

1 Simulating Few by Many: k-concurrency via k-set Consensus Eli Gafni May 29, 2007 Abstract We introduce a new novel emulation by which we show an equivalence between k-set Consensus and k-concurrency: Any number of processors when given k-set Consensus can solve wait-free (read-write), any task which can be solved wait-free read-write when concurrency is limited to k, and visa versa. As a result of showing the models equivalent we obtain a generalization of Herlihy s Universality result: Processors using k-set Consensus can implement k independent arbitrary object, with a progress guaranteed on at least one of the objects. Similarly, we obtain a new proof that n processors with k-set Consensus can rename into n + (k 1) slots. We obtain these results as they are easily derived for the model when concurrency is limited to k. 1 Introduction Set-Consensus is a generalization of Consensus. While in Consensus all n processors with distinct input values (a.k.a Election) decide on a single value and thus exclude n 1 input values from the decided set, in k-set Consensus (a.k.a k-election) they exclude at least n k. Chahudri initiated the investigation of Set Consensus [5], by raising the question whether there exists a read-write protocol that can exclude any input value at all. The question was raised by Chahudri in the context of a t-resilient model and resolved in [2,8,9]. As it turns out, this question is best dealt with in the wait-free model. Results for the t-resilient model may be exported algorithmically from the wait-free model via the BG simulation [2,4]. This supports the thesis that as computability goes, there is only one fundamental model - the read-write wait-free model [7]. All the rest of the models can be dealt with through the read-write wait-free model - the RAM of Distributed Computing. This paper lends additional support to this thesis by reducing the proliferation of apparently distinct models. It introduces an algorithmic technique by which k-set Consensus can be used to emulate a k-concurrent execution. Computability in k-concurrent model can be easily dealt with via the k processors read-write wait-free model. That the reverse is true, that a k concurrent model can implement k-set Consensus, is simple and explained later in this Introduction. Next, considering the centrality of k concurrency model to this paper we elaborate on it in the next paragraph (Limited concurrency was also defined in [6, 17]). Let T be a task. Let A(T ) be a straight-line (no wait statements) read write protocol intended to solve T, and E(A(T )) be a prefix of an execution of A(T ). Processor p i is said to be participating Computer Science Department, University of California, Los Angeles , USA. eli@ucla.edu 3731F Boelter Hall, UCLA, LA. CA. 1

2 in E(A(T )) if its first step in A(T ) appears in E(A(T )). Processor p i is said to have terminated in E(A(T )) if its last step in A(T ) appears in E(A(T )). Execution prefix E(A(T )) is said to be of limited-concurrency k if for all prefixes of E(A(T )), the number of participating processors in the prefix minus the number of of processors that terminated in the prefix is at most k. A task T is read-write wait-free solvable with limited-concurrency k (k-concurrent) if there is a protocol A(T ) as above such that for all k concurrency-limited executions of A(T ), there is a mapping from the final state of terminated processors to outputs that satisfy the task. In [6] it is shown that for any k there is a task which is solvable read-write wait-free k-concurrent but not k + 1 concurrent. Our result in the case k = 1 is a simple corollary of Herlihy s Universality [7]. All well defined tasks are read-write wait-free solvable 1-concurrent, and all tasks are solvable by Consensus. In this sense 1-concurrency and Consensus are the same. Clearly, any property of k-set Consensus by definition holds for Consensus. It is the other direction which is interesting: Given a property of Consensus does it have its counterpart in k-set Consensus realm via a change of parameter? This kind of question was raised in [12]. There, the question is whether the equivalence between Election and Binary-Consensus extends to Set-Consensus. For this question to make sense in the context of k-set Consensus a new equivalent definition of k-set Consensus was introduced. According to this new definition k-set Consensus consists of n processors submitting their inputs to k independent Consensus objects, and each processor gets a response from at least one of the k Consensus objects. With that definition k-election is equivalent to k-set Binary-Consensus. The technique in [12] is instrumental in this paper. While in [12] it is used to for a collection of k independent (unrelated) one-shot Consensus objects, here we extend the technique in a novel way to be used for k (related) read-write codes. Notice that we pay a price: While the unrelated objects are as strong as consensus, the related codes are read-write. (Thus there is a spectrum here which is not pursued further in this paper). That k Concurrency subsumes k-set Consensus follows from the fact that n processors operating at most k concurrently can solve k-set Consensus. Each processor writes its id. It then snapshots the memory and writes its snapshot. It reads the snapshots and elects an id from a snapshot of size smaller than k + 1. The reverse is the subject of this paper: We are given a read-write wait-free protocol A(T ) = (code 0,..., code n 1 ) on n > k processors, that solves task T if run k-concurrently. The problem is for the n processors, who may run n concurrently, to emulate a k concurrent execution of A(T ) to solve T. We of course will use the helping idea of processors executing on behalf of others, but notice that as the problem is to solve T, if processor p i does not participate in the emulation, its code, code i, should remain dormant. In this paper we show how the emulation can be done if the n processors are equipped with k-set Consensus. The emulation combines an extension of the technique of [3] with an extension of the recent technique of [12]. We show two applications of the equivalence of limited-concurrency and Set-Consensus. We first derive a generalization of Herlihy s Universality [7]: n processors with k-set Consensus can simulate k independent objects with a guaranteed progress on at least one. Universality (modulo wait-freeness) is this statement when k = 1. Consider 2 independent linearizable objects. We can easily see that any number of processors with concurrency limited to 2 can implement read-write nonblocking 2 independent linearizable objects with progress guaranteed on at least one of the objects: This can be achieved by the 2

3 Borowsky-Gafni simulation [2, 4]. The 2 active processors conduct 2 separate agreement protocols to agree on the next move of each object. The failure of one of them may block the progress only on a single object, since the failed processor counts against the concurrency, from there on effectively concurrency is 1. Since the agreement protocols are read-write, then by invoking the equivalence in this paper, we obtain the result. Our general emulation is nonblocking, i.e. it can leave some processors to starve. We did not investigate the question if for the less general application of implementing objects, the simulation can be made wait-free. It also makes [13] a simple corollary. There, it was shown that n processors with k-set Consensus can rename into n + (k 1) slots. It is easy to see that the original renaming algorithm [14] implies that if it is executed under concurrency limited to k, then the number of slots needed is n + (k 1). Invoking the equivalence with k-set Consensus, the result of [13] is a simple corollary. The paper is organized as follows: In the next section we review and extend the results of [12]. In the first part of the section that follows, we present a compiler from an non-phased SM to a phased one, and in the next subsection we incorporate the technique of [12] into it, to get our final emulation. The last section is concluding remarks. 2 Review of Set-Consensus as Collection of Consensus Objects Our emulation is partially based on the simple technique from [12] which we call the k-set objects technique. We review and generalize it here. The question there is to show that any number of processors with k-set Consensus can implement k independent 1-Election (Consensus) Objects Cons 1,..., Cons k to which they input their ids with the guarantee that each processor gets a response from at least one Consensus Object. To do this, using k-set Consensus, processors select at most k participating ids. Let p i select d i. From here on we just use read-write. All processors first try to simulate a return of a value from Cons 1 as follows: Each processor p i posts its selected value d i in Shared-Memory (SM). It then snapshots the posted values to obtain a set S i of posted values. Since these sets are generated by snapshots there are a most k distinct sets and if S i = S j then S i = S j. Processor p i then writes S i to SM and reads all posted snapshots. It it reads a snapshot of size one, it returns that single element in the singleton set for Cons 1 and terminates. Else, if p i does not read a singleton set snapshot, it adopts as a new selection the largest element in the largest snapshot it reads as a (possibly) new value d i. Observe that processors that do not return from Cons 1, will adopt at most k 1 distinct values, and now we repeat the above process for Cons 2, etc.. Since with each new phase we lose a value and we have k phases, as we start with at most k values at some phase we must observe a singleton snapshot. The moral we carry is that it is all about narrowing down the number of choices rather than the number of processors. Once the number of different choices are less or equal to k, there is a way for any number of processors to allocate the k choices to k bins with each processor determining a bin and a choice, and all processors determining the same bin, also determine the same choice. In our application here, a processor wants apriori to apply different values to different objects. In this case the selection d i is a vector with entries (d i1,..., d ik ) signaling that processors who adopt d i when at Cons j propose the value d ij (assume now a lexicographic order on vectors). If the vector d i is the singleton in the proposals to Cons j then the actual value that simulated Cons j returns is 3

4 d ij. If in simulating Cons j there is no singleton snapshot but a snapshot of vectors in which all the vector agree on the jth position, then this value jth value can also be safely returned for Cons j. We now generalize the notion of a decision vector: Not only it proposes different values to different objects, but it also specifies to which object the value is to be applied. The number of Consensus objects is infinite Cons 1, Cons 2,... A vector specifies not only a sequence of values to Consensus objects, but also that the first entry has to be proposed to some Cons m, the second to a different object Cons l etc.. A processor p i who selected the vector d i = ((d i1, i m1 ),..., (d ik, i mk )) applies first to Cons im1. If it fails to return a value from Cons im1 it adopts a possibly new vector d j and if i m1 = j mr it continues with d j to Cons jmr+1. We claim that each processor will return from some Cons m and the number of Consensus objects to which input was really applied is bounded by k. We see this by induction on k: It obviously holds for k = 1. Assume the claim holds for k 1. If the first entry in each of the k vectors is to be applied to different Consensus object, then the claim trivially holds. Everybody returns from one of these first objects, since each sees a singleton snapshot. Thus, at least two vectors collide in their first entry at some Cons z. Consequently, the least ranked vector to be proposed to Cons z is not carried on, and thus we have at most k 1 vectors each with at least k 1 entries left. The induction hypothesis applies. 3 The Emulation How are we going to use a static, one-shot technique in a dynamic repeatable way? The standard way to do this is by proceeding in phases making obsolete any modifications that occurred too late in the phase [18]. For this, we will consider the code as written to run on a system with phases. Since it is not, we will present an algorithm that translates a general SM code to be run on such a system. Finally, we will embed the static technique that uses the k-set Consensus inside the phased system, to obtain our emulation. 3.1 Emulation of read-write wait-free Protocol in an Iterated SM Our emulation lives in the Iterated SM model (ISM), as this model is easy to analyze. In the ISM model we are given an infinite sequence of Atomic-Snapshot Single-Writer memories M 1, M 2,... Processors advance in order from memory to memory. In each memory a processor executes constant (not a function of n) number of steps. The advantage of ISM is that we can concentrate on executions in which a processor that finished executing in M j 1 does not proceed to M j until all the n processors finished executing M j 1. We can think of all processors moving in lock-step from memory to memory, where in each memory a relatively simple asynchronous task may be executed. Not to be confused with the lock-step of synchronous system which is internal, here it is external - events can be permuted so that all events in M j 1 precede all those in M j. This is a result of the fact that ISM is Communication-Closed-Layers structure [10]. Thus, we have a simple normal-form execution to argue with. Unlike the BG simulation [2, 4] which lives in the same type of SM the emulated protocol is given, we do not know how to do this here. It will be mildly interesting to fashion our emulation in the BG style, as we consider ISM as the more structured environment for protocol design. Thus, since the given code is for SM, and we are going to run in ISM, we first devise in this 4

5 subsection an algorithm in ISM for processors p 0,..., p n 1 to emulate their execution of SM wait-free code A(T ) to solve task T. That is we devise a compiler for protocol A(T ) = (code 0,..., code n 1 ) written for SM, to run on an ISM machine. Such an ad-hoc compiler was presented in [3]. Here we devise it in a more systematic motivated way. In the next subsection we insert the k-set object technique as a subroutine in each memory of the ISM to obtain our final algorithm. The protocol A(T ) is, w.l.o.g for each code i, an alteration of read followed write. We will assume that each read is an atomic-snapshot [1] in a SW memory. The return of a read will be a set of reads i.e. {read i1 (1),..., read i1 (m), read i2 (1),...}. If we know what prior reads a read returned, we can recursively find the value in A(T ) that that read returns. Thus our emulation is full information [15]. Assume all processors are at the end of M j 1. If one processor at the end of M j 1 then implies a write by having some read return read that precede the write, then it must be the case that all reads returned in M j and onward contain read. Thus, it is about committing a read in a manner such that all the other read s it read are already, or about to be, commited. It is no surprise then that the algorithm below, which is fashioned after the convergence algorithm in [3], can be thought of as a generalization of the commit-adopt technique in [16]. Inductively, out of M j 1 processor p i comes out with two sets of reads. One set converge i and the other adopt i. If a set contains the mth read of code q, read q (m), then it contains all code q s preceding reads. The reads in converge i are to be interpreted as the committed reads. For each read in converge i, p i keeps a local record of which reads that read returned. Inductively, for all read q (m), when it enters converge i or adopt i, then processor p i have a value for it. These values at different processor agree. The set adopt q is a superset of converge i for all q and i (i.e. every read committed at a processor is either committed or adopted by all), and the reads which are in adopt i and not in converge i are the reads that p i tries to commit. If read q (m + 1) is in adopt i then read + q(m) is in converge i The converge sets are related by containment. And finally we have a phase invariant that the sets converge i are nondecreasing and at least one of them is strictly larger than its predecessor. Here we summarize the inductive hypothesis: 1. All values for read r (m) at different processors agree, 2. converge r adopt q, for all r, q, 3. (read i (m + 1) adopt r ) then there exists p q such that (read i (m) converge q ) for all i, r, 4. converge r converge q or converge q converge r, for all r, q. Simulator p i tries to enlarge converge i by getting reads in adopt i converge i to move to the set converge i. Whenever converge i and adopt i agree on the reads of code i it inserts the next read for code i. The value of the read will be converge i. It then continues the process of enlarging converge i, until the last read of code i converges. Then simulator p i quits with an output value for process code i. Thus, until simulator p i quits w.l.o.g. adopt i is a strict superset of converge i. At M j, to enlarge converge i p i writes adopt i in C i. Then p i snapshots all the adopts written, i.e. it returns a set of sets - a set for each cell C q. It then takes the union of these sets and writes it into D i. The values of D i is a set of reads and the sets in D q and D r are related by containment. (This is the result of the fact that A B implies ( A) ( B).) processor p i the snapshots the variables D q and sets adopt i to the largest set returned (the union of the sets read), and converge i to the smallest one (the intersection of the sets read). 5

6 Notation remark: Let A q be a variable written by p q that contains a set. Let op be an operation on a collection of set. By the notation snapshot(op{a q }) we mean that a processor takes a snapshot of all these A q variable that are not, and then it returns the op of all these sets in its snapshot. To summarize the algorithm: 1. C i := adopt i, 2. D i := snapshot( {C q, q = 0,..., n 1}), 3. adopt i := snapshot( {D q, q = 0,..., n 1}), converge i := snapshot( {D q, q = 0,..., n 1}). Property 1 of the induction is maintained as a value of read is introduced by a unique processor. Property 2 is maintained as converge r is derived by intersection and the adopt q by union of sets of a nondecreasing collection of sets. Property 3 follows from the way a new read is introduced. It is then true for q = i, Property 4 follows from the fact that the sets D q are related by containment and thus the intersections are related by containment. Finally, the phase invariant that converge i is non-decreasing follows since all the elements in converge i are in all adopt q sets and thus in the intersection. To see progress, let p q be the first processor to write C q. Thus all D r will contain C q and in particular converge q at line 3 will contain C q. Thus, as before line 3 converge q is a strict subset of adopt q, at line 3 converge q grows. Why is the emulation valid? When does p i attach a new value to a read? It attaches it exclusively to reads of code i, and it does it at the end of M j 1 when adopt i and converge i agree on the reads of code i. But then, by the invariant, for all q converge i adopt q. If at the end of M j 1 p q has some read of converge i that is strictly in adopt q but not in converge q then at the end of M j all processors will have it in their converge set and thus return it if they insert a new read at the end of M j. Finally, if two processor p i and p q add a new read at the end of M j 1 then since the converge set relate by containment we can arrange on after the other. 3.2 k-concurrent Emulation Via k-set Consensus We now embed the k-set object technique in each phase prior to the commit-adopt. We first, informally, present the difficulty that arises, and why combination of the two techniques will solve it. Using k-set Consensus we can limit the number of the initial codes that are started to k. But as an active code terminates we might need to introduce new codes while keeping the number of active codes below k + 1. Similarly we need to allow any processor to introduce a read for code i, rather than limiting it exclusively to p i, since the emulation has to proceed n-concurrent. It cannot stop progress because k simulators fail-stopped. So we have two complications: First, the number of selected codes should not exceed k, and second, processors have to work on behalf of others. The former is a problem since once some of the initial codes will terminate we will encounter difficulty in introducing just enough new codes so that the concurrency will not exceed k. The latter is also a problem since simulators may disagree on a value a read should return. Both problems will be solved by introducing the k-set objects technique into the emulation. The introduction of new codes will only happen after processors conflict on reads for currently active codes. Each conflict like this removes a proposal from consideration and thus the number of new codes that may be introduced together with the number of active codes will not exceed k. Similarly, 6

7 by going through the k-set objects technique before getting to adopt-commit processors do not conflict on the value of a read that they do introduce. In more detail. To avoid cluttering the presentation with the last steps of the whole emulation - when the number of codes left unterminated or the number of processors which have not departed is less than k - we assume that these numbers (code and participating simulators) are infinite. These last phases when the numbers become small are handled automatically as the number of proposals submitted get below k. We avoid qualifying all we say by repeatedly referring to the actual number of simulators when it is below k, by making this assumption.. As above, processors come out of M j 1 with converge-sets and adopt-sets. We still maintain the property that a read in one converge set is either committed or adopted by all, as well as the rest of the properties.yet unlike the emulation of the last section having a read value in an adopt set, does not guarantee that this is the value that will be eventually committed. Some processors may later propose different value for that read and they may win, or the read may be purged from the adopt set. Define the set active i of codes. The code q is in active i if the first read q (1) converge i and the last read of code q is not yet in converge i. W.l.o.g we assume the active i sets are related by containment by taking snapshots. The idea: Processors will proceed to the commit-adopt through two distinct tracks: The regular track, and the k-set Track. New reads are added only through the k-set track. Conflicting read proposals are submitted to the track and resolved by it. This track will be used by processors which do not observe reads that might have converged. Others will proceed as in the previous subsection. To identify reads that might have converged p i examines the intersection of adopt sets it observes. Converged reads will be in this intersection and it can identify these it missed and proceed regularly. Yet, it may also proceed on account of a read that is currently in the intersection but has not converged. Processors that do not see a read that is not accounted for in their converge set propose new reads through the k-set path, where conflicting read proposals will be reconciled. But on this latter track they must account for all reads that will be proposed through the regular track. For this in the k-set track we suspect any read in the union of the adopt set to have been potentially submitted through the regular track. To account for this processors propose these read values for the corresponding codes. Since they all agree on this code no new code will be activated by the k-set path when a potential dangling activation through an adopt set is carried from previous phases. Finally notice that all processors p q which take the k-set path have an identical converge set. If not, since converge set are related by containment assume w.l.o.g that converge r is a strict subset of converge r. Then there is a read converge r converge r. By the invariant read adopt r and thus p r will follow the regular track. Since we insert new reads only through the k-set path, the invariant we will maintain is that the number of new codes that may be newly activated at the end of a round plus the number of the active set of the processors that go to the k-set path is at most k. 1. A i := adopt i 2. (b i, e i ) := (snapshot( q A q ) converge i, snapshot( q A q ) converge i ) 3. if b i = then (a) for all code q active i 7

8 i. if there exists m such that read q (m) e i then proposal q := read q (m), else let m 1 be the last read of code q in converge i then proposal q := read q (m) := converge i, (if m 1 is the last read of code q then proposal q := read q (m 1), (b) for read q (1) e i active i, proposal q := read q (1) (c) if active i e i < k then for k active i e i participating p q set proposal q := read q (1) := converge i (d) (proposal vector) i := (submit proposal vector with active i in front to k-set consensus) (e) b i := {k Set objects technique } 4. C i := converge i {b i } 5. D i := snapshot( C q ) 6. (converge i, adopt i ) := (snapshot( q D q ), snapshot( q D q )) 4 Conclusion We have unified formerly apparently different models of computation - one of wait-free with Set Consensus and one where executions are guaranteed to be of limited concurrency. We have provided a tangible benefit of this unification by showing that certain results which were or are hard to see in one model, are easily seen in the other. In general, the more facets we understand the same subject, the deeper is our understanding. Finally, we speculate that the derivation of the weakest Failure Detector for Set-Consensus announced recently [11], can be significantly simplified by deriving the weakest Failure Detector for eventually limited concurrency executions. Independent of the main result, the techniques we devised on the way, have a contribution in enriching our bag of tools. The paper generalizes the technique of [12], but more importantly, we feel that the view of the convergence algorithm in [3] as a generalization and unification of commit-adopt will come handy in dealing with future questions. The main contribution of this paper is the realization of the equivalence between the models. Once spelled out even without proof, it sounds obvious. An obvious result is obvious because there is a simple principle hidden behind it, for which we have the feel but it has not been spelled out yet. We hope that in addition to the realization of the equivalence, the paper spelled out the simple principle (whose details may be involved) behind it. Acknowledgment Yehuda Afek helpled with many useful ideas and benevolent criticism. Petr Kouznetsov is the Unaware Muse behind this paper, as well as behind [12]. The two papers are the result of considering the implication of the idea of Two-Front Agreement - an idea on which I worked with Petr - to the question of Committee-Coordination, on which I worked with Afek, Rajsbaum, Raynal, and Travers. Nils Homer proposed the simple induction in section 2. References [1] Afek Y., H. Attiya, Dolev D., Gafni E., Merrit M. and Shavit N., Atomic Snapshots of Shared Memory. Proc. 9th ACM Symposium on Principles of Distributed Computing (PODC 90), ACM Press, pp. 1 13,

9 [2] Borowsky E. and Gafni E., Generalized FLP Impossibility Results for t-resilient Asynchronous Computations Proc. 25th ACM Symposium on the Theory of Computing (STOC 93), ACM Press, pp , [3] Borowsky E. and Gafni E., A Simple Algorithmically Reasoned Characterization of Wait-Free Computations (Extended Abstract). Proc. 16th ACM Symposium on Principles of Distributed Computing (PODC 97), ACM Press, pp , August [4] Borowsky E., Gafni E., Lynch N. and Rajsbaum S., The BG Distributed Simulation Algorithm. Distributed Computing, 14(3): , [5] Chaudhuri S., More Choices Allow More Faults: Set Consensus Problems in Totally Asynchronous Systems. Information and Computation, 105: , [6] Gafni E., Merritt M. and Taubenfeld G., The Concurrency Hierarchy, and Algorithms for Unbounded Concurrency. Proc. 21st ACM Symposium on Principles of Distributed Computing (PODC 01), ACM Press, pp , [7] Herlihy M.P., Wait-Free Synchronization. ACM Transactions on programming Languages and Systems, 11(1): , [8] Herlihy M.P. and Shavit N., The Topological Structure of Asynchronous Computability. Journal of the ACM, 46(6): , [9] Saks, M. and Zaharoglou, F., Wait-Free k-set Agreement is Impossible: The Topology of Public Knowledge. SIAM Journal on Computing, 29(5): , [10] Tzilla Elrad, Nissim Francez, Decomposition of Distributed Programs into Communication- Closed Layers. Sci. Comput. Program. 2(3): (1982). [11] Rachid Guerraoui, Maurice Herlihy, Petr Kouznetsov, Nancy Lynch, Calvin Newport, On the weakest failure detector ever. To appear in PODC07. [12] Yehuda Afek, Eli Gafni, Sergio Rajsbaum, Michel Raynal, Corentin Travers, Simultaneous Consensus Tasks: A Tighter Characterization of Set-Consensus In ICDCN06 pp , 2006 [13] Eli Gafni, Renaming with k-set-consensus: An Optimal Algorithm into n + k - 1 Slots. OPODIS 2006: [14] Hagit Attiya, Amotz Bar-Noy, Danny Dolev, David Peleg, Rdiger Reischuk: Renaming in an Asynchronous Environment J. ACM 37(3): (1990) [15] Frederickson, G. N. and Lynch, N. A., Electing a leader in a synchronous ring. J. ACM 34, 1 (Jan. 1987), [16] Eli Gafni, Round-by-Round Fault Detectors: Unifying Synchrony and Asynchrony (Extended Abstract). PODC 1998: [17] Y. Afek, H. Attiya, A. Fouren, G. Stupp, and D. Touitou., Long-lived renaming made adaptive. In Proc. 18th Annual ACM Symp. on Principles of Distributed Computing, pages , May

10 [18] Eli Gafni, A Simple Algorithmic Characterization of Uniform Solvability. FOCS 2002: