A Polylog Time Wait-Free Construction for Closed Objects

Transcription

1 A Polylog Tme Wat-Free Constructon for Closed Obects Tusar Deepak Candra Prasad Jayant Kng Tan IBM T.J.Watson Researc Center Dartmout College Dartmout College Abstract A (wat-free) unversal constructon s attractve because, no matter wat types of wat-free obects are needed by applcatons, tey can be mplemented smply by nstantatng te unversal constructon wt te approprate types. However, te worst-case tme complexty of every exstng n-process unversal constructon s Ω(n): tat s, n any mplementaton obtaned by nstantatng a unversal constructon, n te worst-case a process performs Ω(n) computaton n order to complete a sngle operaton on te mplemented obect. In fact, a lower bound of Ω(n) as been proved for te worst-case local tme complexty of any oblvous unversal constructon []. Snce unversal constructons wt sublnear tme complexty do not seem possble, t s natural to explore semunversal constructons tat can effcently mplement large classes of obects (as opposed to all obects). We present suc a constructon n ts paper. Our constructon mplements a large class of obects, tat we call closed obects. Ts class ncludes several common syncronzaton obects, suc as swap, fetc&add, fetc&multply, and fetc&φ (were Φ s any of te boolean operatons and, or, or complement). Our constructon aceves worst-case saredaccess tme and local tme complexty of O(log n). Furter, at low contenton, te tme complexty s even lower. Te constructon assumes tat te underlyng sared-memory supports LL and SC operatons. To te best of our knowledge, f we consder constructons tat can mplement a class of obects (as opposed to a specfc obect), ts s te frst tme tat te polynomal barrer as been broken for te worst-case tme complexty. Fnally, Jayant proves a Ω(log n) lower bound on te worst-case sared-access tme complexty of any mplementaton of certan closed obects []. Tus, te O(log n) worst-case sared-access tme complexty aceved n ts paper s wtn a logartmc factor of te optmum. Ts work s partally supported by NSF RIA grant CCR- 90. Introducton A wat-free mplementaton of a sared obect guarantees tat f a process repeatedly takes steps, ten ts operaton on te mplemented sared obect wll eventually complete, regardless of weter oter processes are slow, fast, or ave crased. Wat-free mplementatons are free of te ptfalls, suc as convoyng, prorty nverson, and deadlocks, tat afflct lock-based mplementatons. However, wat-free mplementatons are notorously ard to desgn and prove correct. To overcome ts dffculty, recent researc as focussed on unversal constructons [,,,, 6,, 8, 9, 0,,, 9, 0,, ] A unversal constructon for n processes s an algortm tat, wen nstantated wt te sequental mplementaton of any type T, becomes a wat-free mplementaton of a type T obect tat can be accessed concurrently by n processes [9]. Tus, once we ave an effcent unversal constructon U, any sared obect can be mplemented smply by nstantatng U approprately. Unfortunately, te worst-case tme complexty of every exstng unversal constructon s Ω(n). In fact, t appears tat Ω(n) s an nerent lmtaton of any unversal constructon: To complete one operaton on any sared obect mplemented from any oblvous unversal constructon, n te worst-case a process must perform Ω(n) local computaton []. (A unversal constructon s oblvous f t does not explot te semantcs of te type tat t s nstantated wt.) Snce unversal constructons wt sublnear tme complexty do not seem possble, t s natural to explore semunversal constructons tat can effcently mplement large classes of obects (as opposed to all obects). We present suc a constructon n ts paper. Our constructon can mplement a large class of obects, tat we call closed obects. Ts class ncludes several common syncronzaton obects, suc as swap, fetc&add, and fetc&φ (were Φ s any of te boolean operatons and, or, or complement). Our constructon aceves a worst-case tme complexty of O(log n). Furter, f an operaton op experences low contenton (.e., te actual number of processes tat ave operatons concurrent wt op s small), ts runnng tme s even smaller. In te rest of te ntroducton, we gve a precse statement of our result after ntroducng te relevant termnology. A sequental mplementaton requres tat operatons be appled one after anoter, wtout overlap.

2 . Closed type: Defnton and examples An obect type T s a tuple (OP,RES, Q, δ state, δ resp), were OP s a set of operatons, RES s a set of responses, Q s a set of states, δ state : Q OP Q s a state transton functon, and δ resp : Q OP RES s a response functon. Informally, f δ state(s, op) = s and δ resp(s, op) = res, applyng operaton op to an obect n state s causes te obect to move to state s and return te response res. T s closed f, for all ordered pars (op, op ) OP OP, tere exsts op OP suc tat for all s Q we ave δ state(s, op) = δ state(δ state(s, op ), op ). Tat s, from any state s, applyng op results n te same state as frst applyng op and ten applyng op. We assume tat combneoperatons(op, op ) returns op. We restrct our focus to closed types for wc te functons δ state, δ resp, and combne-operatons can be computed n O() tme, and a state or an operaton can be stored n a small constant number of macne words. Type T = (OP, RES, Q, δ state, δ resp) s a super type of T = (OP, RES, Q, δ state, δ resp) f OP OP, RES RES, Q Q and, for all (s, op) Q OP, δ state(s, op) = δ state(s, op) and δ response(s, op) = δ response(s, op). A type T = (OP, RES, Q, δ state, δ resp) s closable f t as a closed super type T = (OP, RES, Q, δ state, δ resp); operatons n OP OP are closng operatons of T. Notce tat wenever a sared obect of a closable type T s desred, one can nstead mplement (usng te constructon presented n ts paper) a sared obect of a closed super type of T. Te followng are many examples of closed or closable types []:. Obect supportng fetc&add (F&A), read, and wrte: F&A(a) and F&A(b) combne to F&A(a + b); F&A(a) and wrte(b) combne to wrte(b); wrte(a) and F&A(b) combne to wrte(a + b); F&A(a) and read combne to F&A(a); wrte(a) and read combne to wrte(a).. Obect supportng swap and read: swap(a) and swap(b) combne to swap(b); swap(a) and read combne to swap(a). Snce test&set s a specal case of swap, test&set s also a closed type.. Obect supportng read and all operatons n te famly fetc&φ, were Φ s any boolean operaton and, or, or complement. For example, f te obect s a 6-bt word, fetc&or takes a 6-bt argument, or s t wt te value of te obect, stores te new value n te obect and returns te old value. To close ts type, we add te closng operaton closng-op(a,b, f), were te arguments a and b are of te sze of te obect and f s a boolean. If x s te current state of te obect, applyng closng-op(a, b, f) canges te state as follows: f f s false, te new state s (a x) b; f f s true, te new state s (a x) b. From ts defnton, we see tat closng-op(a,b, f) and fetc&and(c) combne to closng-op(a c, b c, f); closng-op(a, b, f) and fetc&or(c) combne to closng-op(a, b c, f); closng-op(a,b, f) and fetc&complement combne to closng-op(b, a b, f).. Obect supportng all of read, swap (notce tat swap s more general tan wrte), fetc&add and fetc&multply. Here agan we close te obect by addng an operaton closng-op(a,b) wc, wen appled to an obect n state x, canges te state to ax + b.. Obect wose state conssts of a par of values (x, y) and supports te followng operatons (for eac operaton, te state mmedately before te operaton s assumed to be (x, y)): move canges state to (x, x), move canges state to (y, y), swap canges state to (y, x), wrte (z) canges state to (z, y), wrte (z) canges state to (x, z), wrte(z, z ) canges state to (z,z ), and read returns (x, y). As n Example, we need to add a closng operaton to close te obect. Unlke prevous examples, ts type s unversal [9, ]. Tus, tere s a lot of varety among closed types: tere are commutatve, overwrtng, non-commutatve and nonoverwrtng, and unversal types. Furter, as te examples ave sown, ts class ncludes many commonly used syncronzaton obects. Our constructon mplements all of tese n polylog tme.. Tme complexty measures In a wat-free mplementaton of obect O from obects O, O,... (we call O, O,... base obects), eac operaton on O s mplemented by some sequence of operatons on te base obects, along wt some local computaton. We assocate two tme complexty measures wt an operaton op of a process P on O. Te sared-accesstme complexty of op s te total number of operatons tat P performs on te base obects n order to complete op. Te local tme complexty of op s te total number of local computaton steps tat P performs n order to complete op. Te worst-case saredaccess (resp., local) tme complexty s te maxmum, over all operatons op and runs R, of sared-access tme (resp., local tme) complexty of op n R.. Contenton-senstve tme complexty Te contenton experenced by op, denoted by n c, s te number of processes tat ave operatons concurrent wt op. Ideally, f an operaton experences low contenton (.e., n c << n), ts tme complexty sould be smaller tan te worst-case tme complexty []. More precsely, te tme complexty of an operaton sould be a functon of n c, not of n. Afek, Dauber, and Toutou defned and aceved ts property n ter unversal constructon [].. Te result and ts sgnfcance We present an n-process constructon tat, wen nstantated wt a sequental mplementaton of any closed type T, yelds a wat-free mplementaton of an obect of type T tat can be accessed concurrently by a maxmum of n processes. Te sared-access and local tme complextes of an operaton (on te mplemented obect) are bot O(mn(n c,log n)), were n c s te contenton experenced by te operaton. Te tme complexty grows lnearly wt contenton, but s never more tan O(log n). Tus, ts combnes te benefts of contenton-senstve tme complexty wt a guaranteed small worst-case tme complexty. Ts feature, togeter wt te fact tat closed types nclude several useful syncronzaton obects, makes te constructon useful. Our constructon assumes tat te underlyng saredmemory supports load-lnk (LL) and store-condtonal (SC) operatons. Snce closed types nclude unversal types (see Example above), any constructon tat s unversal for closed types s necessarly based on unversal operatons, suc as LL and SC. To te best of our knowledge, f we consder constructons tat can mplement a class of obects (as opposed to a specfc obect), ts s te frst tme tat te polynomal barrer as been broken for te worst-case tme complexty. Jayant proves a lower bound of Ω(log n) on te saredaccess tme complexty of any mplementaton of a class

3 of types tat ncludes fetc&add, fetc&multply, and fetc&and (from LL and SC) []. Tus, te sared-access tme complexty upper bound of O(log n) aceved n ts paper s wtn a logartmc factor of te optmal. Related Work Te noton of contenton-senstve tme complexty s due to Afek, Dauber, and Toutou [] wo, n ter unversal constructon, aceve ts property troug two novel deas: bnary tree based elpng and breadt-frst searc of te tree to capture a node close to te root. We employ tese deas n our constructon. Kruskal, Rudolf, and Snr descrbe ow operaton combnng, wen mplementng closed obects n ardware, reduces traffc on te nterconnecton network of multprocessors []. Te noton and te desgn of te frst unversal constructon are due to Herly [8, 9]. Te use of LL and SC n unversal constructons was also ntroduced by Herly [0]. Of te recent unversal constructons, some focus on mprovng te tme complexty wen concurrent operatons access dsont parts of te mplemented obect [,, 6,,, 9,, ]. Oters focus on reducng te worstcase tme complexty []. Afek, Wesberger, and Wesman present polynomal tme mplementatons of some obects at Level of te consensus erarcy, ncludng fetc&add and swap obects, from -consensus obects []. Some fast type-specfc mplementatons are known: examples nclude constant tme mplementatons of compare&swap from LL/SC, and vce versa [], O(w) mplementaton of w-word LL/SC/VL from one-word LL/SC/VL [], and O(w) mplementaton of w-word weakll/sc/vl from one-word compare&swap [8]. Informal descrpton of te constructon Ts secton provdes te ntuton for ow our constructon works. We develop te deas, te data structures, and nformally argue te correctness of te constructon.. Bnary tree prelmnares Let n be te number of processes n te system. We assume tat n s a power of. All trees consdered n ts secton are bnary trees and are of egt at most log n. We say a tree s fully formed f ts egt s exactly log n. We use te standard defnton tat a tree s complete f all leaves are at te same level and all nteror nodes ave two cldren. Below, we descrbe our sceme to number te nodes of a tree [6]. Frst, we descrbe te sceme for a complete, fully formed tree. Fgure (a) sows suc a tree for n =. We assgn te number to te root and number te remanng nodes breadt-frst. Te number assgned to a node s ts poston n te tree. Our numberng sceme causes te leaves to be at postons n, n+,..., n. In partcular, te Pt leaf (we consder te leftmost leaf to be te 0t leaf) s at poston n+p. Also, te parent of a node at poston s at poston /, and te left cld and te rgt cld of a node at poston are at postons and +, respectvely. Te above numberng sceme can be extended to fully formed trees tat are not complete. Fgure (b) presents suc a tree (assumng n = ). Te poston of a node n suc a tree s te number tat would be assgned to t f te tree were complete. Tus, te poston of te leaf n te example tree s 6. Fnally, consder a tree tat s not fully formed. For example, f n =, te tree n Fgure (c) s not fully formed. Snce tere are multple ways n wc suc a tree can be extended nto a fully formed tree, t s mpossble to determne te postons of te nodes wtout furter nformaton. However, f te poston of any one node s gven, te postons of oters can be easly determned. For example, f (for te tree n Fgure (c)) te rgtmost leaf s gven to be at poston, we can nfer tat ts parent s at poston and te oter leaf s at poston.. How operatons are represented Our data structure stores operaton cells n a sequence of bnary trees, wt fully formed trees followed by non-fully formed trees. Fgure (d) sows an example for n =. Here te frst tree trees are fully formed, wle te remanng ones are not. (Te number at a cell ndcates ts poston n te tree; te letter nsde a cell s te operaton stored n tat cell; and a black square nsde a cell denotes a nl ponter.) Recall tat n, n+,..., n are te leaf postons (n a complete, fully formed tree). In our constructon, te leaf at poston n + P of a tree, f t exsts, s assocated exclusvely wt process P (for all 0 P n : processes are numbered 0,,..., n ). In partcular, f a tree as a cell at poston n+p, tat cell was ntroduced nto te global structure by process P and t stores an operaton from process P. Tus, te frst tree (n Fgure (d)) contans operatons from all four processes operaton a from Process 0 (at poston ), operaton b from Process, and operatons c and d from processes and, respectvely. Te second tree contans only one operaton operaton e from Process (lookng at te sape of ts tree, we know tat te only leaf s at poston and ence contans an operaton from Process ). Te trd tree contans two operatons operaton f from Process 0 and operaton g from Process. Te fourt tree s not fully formed (snce ts egt s less tan log n). In fact, gven tat ts tree as only one cell so far, t would be normally mpossble to say wat te poston of ts cell s. Our constructon, owever, ensures tat eac tree grows bottom-up from leaves to te root. Tus, one can conclude tat te lone cell n te fourt tree wll eventually be a leaf (n a fully formed tree). As already mentoned, our constructon also ensures tat a leaf created by process P wll be at poston n+p of a fully formed tree. Tus, assumng tat te cell n te fourt tree was created by Process, we ndcated ts poston as (n a fully formed tree tat ts cell wll eventually be a part of). Te fnal tree n te fgure s also not fully formed. It contans one operaton operaton from Process.. How operatons are lnearzed In our constructon, an operaton takes effect te moment t becomes a part of a fully formed tree. Tus, n our example, operatons a troug g took effect, but operatons and dd not. Operatons tat took effect are lnearzed accordng to te followng rules: all operatons n a tree are lnearzed before any operaton n te next tree; operatons wtn a tree are lnearzed n te natural left to rgt order on te leaves. Tus, n our example, a, b, c, d, e, f, g s te lnearzaton order.

4 . Growng trees bottom-up In our constructon, wen a process P wses to apply an operaton op on te mplemented obect, P gets a cell from ts prvate pool of cells, stores op n te cell, and creates a tree out of ts sngle cell. (Te fourt tree n Fgure (d) s an example of suc a tree: ere Process as ust created a tree out of ts operaton cell.) P ten makes an effort to grow ts (sngle-celled) tree nto a fully formed tree (of egt log n) n wc ts operaton cell wll be a leaf at poston n + P. We already mentoned tat P s operaton takes effect only after ts operaton cell becomes a leaf of a fully formed tree. Snce a process returns from ts operaton only after te operaton takes effect, our constructon satsfes te followng property: Completon Rule: A process P returns from ts operaton only after ts operaton cell s a leaf (at poston n + P) of a fully formed tree. Our constructon also ensures tat a tree always grows bottom-up. Specfcally, te constructon satsfes te followng property: Bottom-up Rule: If C s a cell n a tree, ten te subtree rooted at C does not subsequently cange. For example, consder te fnal tree n Fgure (d). Te parent of te cell contanng operaton as no left cld. By te bottom-up rule, ts cell wll never get a left cld n te future. It s mmedate from te bottom-up rule tat a fully formed tree never subsequently canges: tere won t be any addton or removal of cells from a fully formed tree. Ts fact mples lnearzablty, as we argue now. Consder two operatons op and op suc tat op precedes op (.e., op returns before op s nvoked). By te completon rule, wen op s nvoked, op s already a leaf of a fully formed tree. Snce fully formed trees never subsequently cange, op becomes a leaf n a later tree. By our lnearzaton order, op s lnearzed before op. Hence we ave lnearzablty.. How a process makes progress To understand ow processes make progress, let us consder a specfc example: suppose tat Process 0 nvokes te operaton and runs alone from te confguraton depcted n Fgure (d). (In Fgures (e)-(g), we wll depct te sequence of canges to te confguraton. Snce te tree fully formed trees are a part of all of tese confguratons, we wll not repeat tem n tese fgures.) Process 0 creates a (sngle-celled) tree contanng ts operaton cell (Fgure (e)). Te next goal of Process 0 s to make ts operaton cell a leaf (at poston n+p = n) of a fully formed tree;.e., to get ts cell a parent (at poston (n + P)/ = n/), ten a grandparent (at poston (n + P)/ = n/), ten a parent for te grandparent and so on, untl ts operaton cell as log n ancestors. Tus, te mmedate subgoal s to get a parent for ts operaton cell (contanng te operaton ). Snce te parent wll be a cell at poston (n + P)/, wc n our example s, te parent can potentally ave two cldren: one at poston and anoter at poston. Terefore, Process 0 cecks f tere s already an unparented cell at poston and fnds te operaton cell contanng. So t creates a cell wose left and rgt cldren are te operaton cells contanng and, respectvely (Fgure (f)). Process 0 ten proceeds to get a parent (at poston ) for ts new cell. Snce a cell at poston can potentally ave cells at postons and as ts left and rgt cldren, t cecks f tere s an unparented cell at poston. Snce tere s suc a cell, t creates a cell at poston as sown n Fgure (g). At ts pont, te operaton of Process 0 as taken effect. So ave te operatons and of processes and : te steps of Process 0 ave elped tem take effect as well. Te above example also rougly suggests wy our sared-access and local tme complexty as a logartmc, rater tan lnear, dependence on n. To understand certan ntrcaces of our constructon, let us consder anoter example: a run, agan startng from te confguraton n Fgure (d), n wc te steps of Process 0 and Process nterleave. (We wll depct te sequence of canges to te confguraton n Fgures ()-(l).) Specfcally, te run s as follows: Process, wc as already announced ts operaton, proceeds to get a parent for ts operaton cell. Ts parent can potentally ave a cell at poston as ts left cld; owever, Process does not fnd an unparented cell at poston. So t creates a cell C wose left cld s nl and rgt cld s te operaton cell contanng (see Fgure ()). Process 0 announces a new operaton (Fgure ()). Process 0 proceeds to get a parent for ts operaton cell. Snce ts parent can potentally ave a cell at poston as ts rgt cld, t looks for an unparented cell at poston. Snce tere s no suc cell, t creates a cell C wose rgt cld s nl and left cld s ts operaton cell. Notce tat Cell C, lke Cell C, s a cell at poston. If we make t possble for Process 0 to nstall cell C nto te global structure, tere wll be two unparented cells at poston. Our constructon does not permt ts. Specfcally, our constructon satsfes te followng nvarant: At Most One Orpan Rule: Tere s at most one unparented cell n any poston at any tme. Accordngly, te attempt of Process 0 to nstall C nto te global structure wll fal. Suppose Process 0 s te only process alve. Clearly, because of At most one orpan rule and bottomup rule (descrbed earler), Process 0 wll not be able to get a parent for ts operaton cell untl C gets a parent. So Process 0 gets a parent for C, even toug ts operaton cell s not a descendent of C (see Fgure ()). Process 0 ten gets a parent for ts operaton cell (Fgure (k)) and ten a grandparent (Fgure (l)). At ts pont, ts operaton as taken effect..6 Data structures Conceptually, as already explaned, te prncpal global structure mantaned by our constructon s a sequence of trees. In ts secton, we descrbe ow ts conceptual global structure s actually represented n sared memory. We also

5 state te precse nvarants tat our data structures satsfy so as to respect te rules Bottom-up rule, At most one orpan rule etc. tat we motvated earler..6. Representng a sequence of trees Let Σ be a sequence of trees at some pont n a run (we wll use te sequence of trees n Fgure (d) as our example). In our constructon, Σ s represented usng n sngly lnked lsts. Te lsts are numbered,,..., n. Lst lst conssts of all cells at poston lst n te trees n Σ. Fgure (m) depcts te lsts for te sequence of trees n Fgure (d). Te parent-cld relatonsp wtn eac tree n Σ s preserved n te representaton by ncludng approprate left cld and rgt cld ponters between cells n dfferent lsts. For example, Fgure (m) depcts tese ponters correspondng to te trd tree n Fgure (d). (To keep te fgure uncluttered, te left cld and rgt cld ponters correspondng to te remanng trees are not sown.) Notce tat, f C s a cell n lst lst, eter C as no left cld or C s left cld s a cell n te lst numbered lst. Smlarly, eter C as no rgt cld or C s rgt cld s a cell n te lst numbered lst Te felds of a cell Te varous felds n eac cell are as follows: LC, RC, and Parent felds of a cell pont to te left cld, rgt cld, and parent of tat cell (f a cell as no left cld or rgt cld or parent, te correspondng feld as te value ). Next feld ponts to te next cell n te same lst (f a cell s te last one n a lst, ts Next feld as te value ). Op feld of a cell C contans a sngle operaton tat results from combnng te operatons at te leaves of te subtree rooted at C. For example, Op feld of te trd cell n lst contans te operaton tat f and g combne to. Op feld of te frst cell n lst contans te operaton tat c and d combne to, and Op feld of te frst cell n lst contans a. Lop feld of a cell C contans a sngle operaton tat results from combnng te operatons at te leaves of te left subtree of C (f C as no left cld, ten C s Lop feld as te value ). For example, Lop feld of te frst cell n lst contans te operaton tat a and b combne to, Lop feld of te frst cell n lst contans c, and Lop feld of te frst cell n lst contans. State feld of a cell C s useful for recordng te state tat results after all operatons at te leaves to te left of Cell C are appled, n te natural left-to-rgt order. (Leaves to te left of C are all te leaves, n all trees, tat are to te left of te leftmost leaf descendent of C.) For example, State feld of te trd cell n lst contans te state tat results after te operatons a, b, c, d, e, f are appled, n tat order. Fnally, eac cell as a Ready feld tat olds a boolean value. A value of false ndcates tat te cell s not yet ready to ave a parent, wle a value of true ndcates tat te cell s eager to ave a parent. Te motvaton for ncludng Ready feld s gven n te followng paragrap, were we explan ow ts feld elps satsfy te requrement tat trees be bult bottom-up. Our constructon s suc tat, once a cell C becomes a part of a tree, te values of ts LC and RC felds wll not subsequently cange. In oter words, f a cell C as a left cld (respectvely, rgt cld) D, ts LC (respectvely, RC) feld ponts to D rgt from te moment C becomes a part of te tree. However, t s only after C becomes a part of te tree tat D s Parent feld s set to C. So, after a cell C gets nto a tree, ts cldren s parent ponter wll need to be set to C. Snce we ws to buld trees bottom-up, te settng of te parent ponter of C s cldren must be completed before C gets a parent. We mplement ts by ensurng tat C s Ready feld ntally as false and tat t canges to true only after te parent ponters of C s cldren are set to C. Te gst of te last paragrap s summarzed by Invarants and, stated below. Te frst states tat a cell gets a parent only after t announces tself ready to ave one. Te second states tat a cell c announces tself ready (to ave a parent) only after ts cldren s parent feld s set to c. Ts nvarant captures te bottom-up buldng of trees. Invarant : For any cell c n any lst lst, c Parent mples c Ready = true. Invarant : For any cell c n any lst lst, f c Ready = true ten te followng old:. If c LC, ten c LC Parent = c.. If c RC, ten c RC Parent = c. We use te followng termnology. A cell s an orpan f ts Parent feld as ; oterwse t s parented or t as a parent. A ready orpan s an orpan wose Ready feld as true. A cell c as a ready parent f c as a parent wose Ready feld as true. Recall te At Most One Orpan rule, wc states tat tere s at most one orpan at eac poston. We capture ts wt te followng nvarant: Invarant : Eac lst as at most one orpan. If a lst as an orpan, t s te last cell n te lst..6. Te ead varables For eac lst lst, lst n, our constructon mantans a sared varable Head[lst] tat, rougly speakng, ponts to te last parented cell n lst lst. Te exact propertes of Head[lst] are expressed by te followng nvarant: Invarant : If te value of Head[lst] s c, ten te followng statements old:. c ponts to a parented cell n lst lst.. c ponts eter to te last cell or to te cell prevous to te last cell n lst lst.. If a cell D n lst lst as a ready parent, ten c ponts to D or beyond D n lst lst. Wt Invarants and, a process P can easly determne f lst lst as a ready orpan as follows:lst P reads te value of Head[lst] nto a local varable c; P ten reads c Next nto d; f d, d Ready as true and d Parent as, ten d s a ready orpan n lst lst.

6 . Understandng te constructon Our constructon s presented n Fgure and contnued n Fgure. We wll use top-down reasonng to argue tat te constructon s correct. Tus, f procedure A calls procedure B, we prove tat A satsfes ts stated propertes on te premse tat B satsfes ts propertes, and later prove te premse. We wll state te propertes of procedures as lemmas. It turns out tat lst s often a specal case. To not obscure te man ntuton, we wll owever omt references to suc specal cases n te statements of te lemmas below. A process P apples an operaton op on te mplementaton by executng te procedure apply(op). We argue te correctness of te response returned by apply on te premse tat promote and percolatestate satsfy followng propertes. Lemma (Property of promote) If, before promote(lst) s called, a cell c s a ready orpan n lst lst, ten after completng promote c as a ready parent. Lemma (Property of percolatestate) Suppose, before a call to percolatestate(c,n + P), c s a cell n lst n + P, c as an ancestor d n lst, and d State s te state obtaned by applyng operatons n trees tat are before c s tree. Ten, after te call completes, c State s te state obtaned by applyng operatons to te left of c tese are ()operatons n trees tat are before c s tree, and ()operatons to te left of c n c s tree. Wen process P calls apply(op), t frst executes announce(op). Durng ts procedure, P grabs a fres cell from ts prvate pool of cells, stores op n te Op feld, sets te Ready feld to true, and treads ts opcell to te end of lst n +P. P ten calls promote on lst n+p wc, by te property of promote stated above, results n opcell gettng a ready parent. P ten calls promote on lst (n + P)/, ten on lst (n + P)/, and so on, so tat opcell gets a grandparent, parent to grandparent etc. Ultmately, after log n suc calls, opcell as an ancestor n lst, and te state feld of ts ancestor corresponds to te state tat results after all operatons n pror trees are appled. P ten calls percolatestate, wc flls te state feld of opcell wt te state tat results after all operatons to te left of opcell are appled. P apples ts operaton op to ts state, and te resultng response s te mplementaton s response to op... How promote works We argue tat promote(lst) satsfes Lemma on te premse tat te followng two lemmas Lemmas and are true. Lemma After a cell d n lst lst or n lst lst + becomes a ready orpan, te lst lst can grow by at most two cells before d gets a ready parent. apply(op : nvoc) returns result. opcell := announce(op). lst := n + P. for := to log n. promote (lst). lst := lst/ 6. percolatestate(opcell, n + P). return δresp (opcell State, op) end apply promote(lst : nteger). d := append( lst/ ). f (d ) and ( lst/ > ) ten promote( lst/ ). append( lst/ ) end promote append(lst : nteger) returns cell. ead := Head[lst]. newcell := LL(ead Next). f newcell =. lc := readyorpan( lst). rc := readyorpan( lst + ) 6. f (lc ) or (rc ). c := combne(lc, rc) 8. SC (ead Next, c) 9. newcell := ead Next 0. f newcell = return. f newcell LC. newcell LC Parent := newcell. updatehead( lst, newcell LC). f newcell RC. newcell RC Parent := newcell 6. updatehead( lst +, newcell RC). newcell Ready := true 8. f lst = 9. newcell State := δ state (ead State, ead Op) 0. updatehead(lst, newcell). return newcell end append Fgure : Constructon for closed obects (contnued on te next fgure) Lemma (Property of append) If, before append(lst) s called, tere s a ready orpan d n lst lst or n lst lst +, ten executng te procedure eter ()causes d to get a ready parent or ()ensures tat some ready cell s appended to lst lst, and returns tat cell. Before promote(lst) s called, let c be a ready orpan n lst lst. We now sketc a proof of Lemma by argung tat,

7 readyorpan(lst : nteger) returns cell. ead := Head[lst]. next := ead Next. f (next ) and (next Ready). return next. else return end readyorpan updatehead(lst : nteger, c : cell). ead := LL(Head[lst]). f ead Next = c. SC(Head[lst], c) end updatehead announce(op : nvoc) returns cell. allocate a new cell c and ntalze t as follows: c Parent :=, c Next :=, c State := c LC :=, c RC :=, c Op := op, c Lop :=, c Ready := true. ead := Head[n + P]. ead Next := c. return c end announce combne(lc, rc : cell) returns cell. allocate a new cell c and ntalze t as follows: c Parent :=, c Next :=, c State := c LC := lc, c RC := rc, c Ready := false f lc c Lop := lc Op else c Lop := f rc c Op := combne-operatons(c Lop, rc Op) else c Op := c Lop. return c end combne percolatestate(c : cell, lst : nteger). f lst = return. p := c Parent. percolatestate(p, lst/ ). f lst = lst/. c State := p State 6. else c State := δ state (p State, p Lop) end percolatestate Fgure : Constructon for closed obects (contnued from prevous fgure) after completng te procedure, c as a ready parent. Snce promote s a recursve procedure, te argument s nductve. After executng Lne of promote, by Lemma, eter c gets a ready parent or some ready cell s appended to lst lst/ and returned, wc (n te algortm) s stored n d. In te former case, Lemma s mmedate. In te latter case, on Lne, promote( lst/ ) s recursvely called. By nducton ypotess, after ts recursve call, d as a ready parent. Terefore, by Part of Invarant, Head[ lst/ ] ponts to d or beyond d. On Lne of promote, append( lst/ ) s agan executed. After ts, by Lemma, eter c gets a ready parent or some ready cell e s appended to lst lst/ and returned. In te former case, Lemma s mmedate. In te latter case, we know tat e s after d n lst lst/. Tus, lst lst/ as grown by at least two cells (d and e are te two cells) snce c as become a ready orpan. Terefore, by Lemma, c as a ready parent. Hence Lemma... How append works A leaf lst,.e., lst n + P (0 P n ), grows wen process P executes announce(op) and treads ts operaton cell to te lst. An nteror lst lst ( lst n ), on te oter and, grows wen a process P executes append(lst). Rougly speakng, ts procedure fnds te end of lst lst, and appends tere a cell tat becomes parent to ready orpans n lsts lst and lst +. We now provde a detaled, yet nformal, descrpton of ow process P executes append(lst). P reads Head[lst] and obtans a ponter to te last parented cell n lst lst (stored n ead on lne ), and ten cecks f tere s an orpan next to ead (lnes and ). If tere s an orpan, t proceeds to elp t (lne onwards). Oterwse P looks at lsts lst and lst + to ceck f tey ave ready orpans (lnes and ). If so, P combnes te nformaton n te ready orpans and stores t n a new cell c (lne ) and attempts to append c at te end of lst lst (lne 8). Its attempt may fal f some oter process as already appended a cell next to ead. Regardless of weter t succeeded n appendng c or someone else succeeded n appendng some oter cell, P obtans a ponter to te cell next to ead (lne 9). If no cell exsts tere, t means tat tere was notng to append to ead, so P returns from te procedure wt (lne 0). Oterwse newcell s a cell tat as ust been appended next to ead, and P proceeds to notfy newcell s cldren of te fact tat tey now ave a parent. It sets te parent feld of newcell s left cld to newcell (lne ) and, snce newcell s left cld s now parented, updates Head[ lst] to pont to newcell LC (lne ). P notfes newcell s rgt cld smlarly (lnes -6). Once te cldren of newcell ave been notfed, newcell s permtted to get a parent. So P wrtes true n te Ready feld (lne ). If newcell s n lst, t s te root of a fully formed tree. Te state tat corresponds to applyng operatons of te prevous tree to te state n te root of te prevous tree s wrtten to newcell s state feld. Tus, newcell s state feld corresponds to applyng operatons n all prevous trees. Also, f newcell s n lst, t s te root; snce tere s no need for t to get a parent, te Head[] varable s updated to pont to newcell. P ten returns newcell, te cell appended to lst lst. Te proofs of Lemmas and follow from te append procedure. Tey are, owever, long and beyond te scope of ts extended abstract.

8 .8 Te man teorem We make te followng observatons:. A call to readyorpan, updatehead, announce, or combne results n O() accesses to sared obects and O() local steps.. A call to append(lst) results n O() sared-memory steps and O() local steps.. Wen te recurson n te promote procedure s elmnated, a call to promote results n at most log n calls to append, tus gvng rse to O(log n) sared-memory steps and O(log n) local steps.. A call to percolatestate(c, lst) results n O(log n) sared-memory steps and O(log n) local steps.. apply makes one call to announce, log n calls to promote, and one call to percolatestate. Terefore, a call to apply results n O(log n) sared-memory steps and O(log n) local steps. Tus, we ave: Teorem Te constructon presented n Fgure s lnearzable and wat-free. Te sared-access tme complexty and te local tme complexty of te constructon are bot O(log n). Contenton-senstve tme complexty We now descrbe an enancement to te constructon tat elps aceve a tme complexty of O(mn(n c, log n)) for eac operaton op, were n c s te number of processes wose operatons are concurrent wt op. Te dea, used below, of dong breadt-frst searc to attan contentonsenstve tme complexty s due to Afek, Dauber, and Toutou []. Te followng enancements are made to te earler constructon: (). We mantan one addtonal fxed bnary tree T tat as a total of log n nodes. We number tese nodes breadt frst, startng wt for te root of T. Eac node s value s eter a process d P, or. In te former case, te node as been captured by P. In te latter, t s avalable for capture. To capture a node n T, a process P performs a breadt-frst searc of te nodes of T, startng at te root, tryng to cange te value of an avalable node from to P, usng LL and SC operatons. (). In addton to te possble node postons as specfed by a bnary tree of egt log n (see Fgure (a)), we ave log n new node postons: + /, for =,,,log n. A node at poston + / s te mddle cld of te node at poston. (). In te new constructon, eac cell n lst lst, lst log n, as tree cldren: a left cld and a rgt cld as n te orgnal constructon, and a mddle cld, wc s eter or a cell n lst lst + /. Te mddle cld, f present, s a leaf. (). In te orgnal constructon, wen a process P nvokes a new operaton op, t stores op n a cell c, nstalls c (as a leaf) n te lst n+p (wc belongs exclusvely to P), and works towards makng c a part of a fully formed tree (.e., untl c as log n ancestors). In te new constructon, wen P nvokes a new operaton, t performs a breadt-frst searc of T, lookng for an avalable node n T to capture. Suppose P succeeds n capturng a node x n T numbered m. It stores op n a cell c, and nstalls c (as a leaf) n te lst m + /. P ten works towards gettng c a parent n lst m, a grandparent n lst m/ and so on, untl c as an ancestor n lst. Ten, P computes te response to ts operaton, and releases x by settng ts value to. Breadtfrst searc takes O(m) tme and te rest of te work takes O(log m). As n [], m s at most n c (n c s te contenton). Furter, snce T as only log n nodes, m log n. Tus, m mn(n c,log n). Hence we ave te desred bound. If P does not succeed n capturng a node n T, t follows from [] tat n c s more tan te number of nodes n T; tat s, n c > log n. In ts case, P performs ts operaton as n te orgnal constructon, by nstallng an opcell n lst n+p and workng towards te root from tere. In ts case, te total tme spent s O(log n), but ten we already argued tat n c > log n. So we ave te desred O(mn(n c,log n)) bound. (). For te strategy n () to work, we enance te append procedure so tat, wen attemptng to append a new cell c to te lst lst, lst log n, n addton to parentng any ready orpans n lsts lst and lst +, c wll also adopt as ts mddle cld any ready orpan n lst lst + /. (6). Up to tree operatons, as recorded n te Op felds of c s cldren, are combned and recorded n c s Op feld. In addton, c as a Mop feld tat records te operaton of c s mddle cld. Te procedure percolatestate s also approprately modfed. Memory management As presented, te data structures grow wtout bound. We now explan ow a fnte pool of cells suffces. Wen all te cldren of a cell c ave ter State felds set (lnes,6 of percolatestate), ten c s no longer needed for te operatons rooted at c to complete: suc an operaton OP can execute percolatestate recursvely, untl t reaces a cld d of c. Usng d State, te correct response to OP can be computed. Furter, f suc a cell c n lst lst s at least two cells bend Head[lst], any attempt to append a cell to lst tat accesses c can be aborted. Ts s because at least two new cells beyond c ave already been appended to lst. We add approprate bts to eac cell c to ndcate weter ()te State felds of c s cldren are set, () c s at least two cells bend Head[lst]. If so, c s ready to be reclamed, because all operatons can complete wtout c. We now descrbe te canges tat need to be made to our constructon, n order to reclam cells. Te owner of a cell c mantans locally a set of ponter values assocated wt te current ncarnaton of c: parent, LC, RC, prevous (were prevous Next = c). Tese are used to access all ponters tat pont to c some tme durng te current ncarnaton of c. Tere are two reserved values for te felds of c: # denotes tat c s currently nvald; %, wc s a reserved value for ponter felds p of c, denotes tat te cell ponted to by te prevous value n p s nvald. To kll an ncarnaton of c, c s owner Q wrtes # to every feld of c, and ten, usng ts local copy of ponters (parent, LC, RC, prevous), LL s all ponters p tat at some tme pont to te current ncarnaton of c. If p s stll pontng to c, Q executes SC(p,%) to sgnal tat c s nvald. Q

9 s now free to reuse c. If a process P encounters values #,% n executng any procedure, a recovery routne s executed, to allow P to contnue ts operaton. If P accesses cell c va ponter p, t must ensure tat c as not canged ts ncarnaton between te tme P reads p, and te tme P accesses c. To aceve ts, P executes LL(p) wen t frst reads p. P also follows any read of a feld of c by a V aldate operaton, VL(p). By examnng ow c s owner klls an ncarnaton of c, t can be seen tat f VL(p) succeeds, ten te value P read s of te same ncarnaton as tat ponted to by p. To wrte to a feld w of c, P frst executes LL(w), ten VL(p), and, f VL(p) succeeds, executes SC on w to wrte to w. An mportant feature ere s tat, f c s of a new ncarnaton wen P executes SC on w, ts SC wll fal. Agan, recovery procedures are executed wenever a new ncarnaton of a cell s encountered. By dove-talng te executon of te memory management procedure wt our constructon, eac process needs to mantan only a pool of O(nlog n) cells to ensure te constant avalablty of a free cell. (Furter detals are provded n te full verson of te paper.) References [] Afek, Y., Dauber, D., and Toutou, D. Wat-free made fast. In Proceedngs of te t Annual ACM Symposum on Teory of Computng (99), pp. 8. [] Afek, Y., Merrtt, M., Taubenfeld, G., and Toutou, D. Dsentanglng mult-obect operatons. In Proceedngs of te 6t Annual Symposum on Prncples of Dstrbuted Computng (August 99), pp. 0. [] Afek, Y., Wesberger, E., and Wesman, H. A completeness teorem for a class of syncronzaton obects. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (August 99), pp [] Anderson, J., and Mor, M. Unversal constructons for large obects. In Proceedngs of te 9t Internatonal Worksop on Dstrbuted Algortms (99), pp [] Anderson, J., and Mor, M. Unversal constructons for mult-obect operatons. In Proceedngs of te t Annual ACM Symposum on Prncples of Dstrbuted Computng (August 99), pp [6] Attya, H., and Dagan, E. Unversal operatons: unary versus bnary. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (May 996), pp.. [] Barnes, G. A metod for mplementng lock-free sared data structures. In Proceedngs of te t Annual ACM Symposum on Parallel Algortms and Arctectures (99), pp [8] Herly, M. Impossblty and unversalty results for wat-free syncronzaton. In Proceedngs of te t ACM Symposum on Prncples of Dstrbuted Computng (988). [9] Herly, M. Wat-free syncronzaton. ACM TOPLAS, (99), 9. [0] Herly, M. A metodology for mplementng gly concurrent data structures. ACM Transactons on Programmng Languages and Systems, (99), 0. [] Israel, A., and Rappoport, L. Dsont-Access- Parallel mplementatons of strong sared-memory prmtves. In Proceedngs of te t Annual ACM Symposum on Prncples of Dstrbuted Computng (August 99), pp. 60. [] Jayant, P. A lower bound on te local tme complexty of unversal constructons. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (June 998). [] Jayant, P. A tme complexty lower bound for randomzed mplementatons of some sared obects. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (June 998). [] Jayant, P., and Toueg, S. Some results on te mpossblty, unversalty, and decdablty of consensus. In Proceedngs of te 6t Worksop on Dstrbuted Algortms, Hafa, Israel (November 99). Appeared n Lecture Notes n Computer Scence, Sprnger-Verlag, No: 6. [] Klenberg, J., and Mullanatan, S. Resource bounds and combnatons of consensus obects. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (August 99). [6] Knut, D. E. Te Art of Computer Programmng, second ed., vol.. Addson-Wesley. [] Kruskal, C., Rudolf, L., and Snr, M. Effcent syncronzaton on multprocessors wt sared memory. In Proceedngs of te t Annual Symposum on Prncples of Dstrbuted Computng (August 986), pp [8] Mor, M. Practcal mplementatons of non-blockng syncronzaton prmtves. In Proceedngs of te 6t Annual ACM Symposum on Prncples of Dstrbuted Computng (August 99), pp [9] Mor, M. Transparent support for wat-free transactons. In Proceedngs of te t Internatonal Worksop on Dstrbuted Algortms (September 99), pp [0] Plotkn, S. Stcky bts and unversalty of consensus. In Proceedngs of te 8t ACM Symposum on Prncples of Dstrbuted Computng (August 989), pp. 9. [] Savt, N., and Toutou, D. Software transactonal memory. In Proceedngs of te t Annual ACM Symposum on Prncples of Dstrbuted Computng (August 99), pp. 0. [] Turek, J., Sasa, D., and Prakas, S. Lockng wtout blockng: Makng lock-based concurrent data structure algortms non-blockng. In Proceedngs of te t Symposum on Prncples of Database Systems (99), pp..

10 (a) (b) (c) 6 6 (d) 6 a b c d e f 6 g Tree Tree Tree Tree Tree (e) (g) C C (f) () () () C Process 0 s attempt to nstall C nto global structure fals C (k) (m) Lst (l) Lst Lst a f b c g d e Lst Lst Lst 6 Lst Fgure : (a)a fully formed tree for n=, (b)numberng a fully formed tree tat s not complete, (c)a non-fully formed tree, (d)a typcal snapsot of operaton cells, (e)process 0 creates an operaton cell for, (f)process 0 creates a cell wose left and rgt cldren are and, (g)process 0 creates a cell at poston. as now taken effect. ()Process creates a parent for, ()Process 0 creates an operaton cell for, ()Snce process 0 cannot create a parent for, t gets a parent for C, (k)process 0 gets a parent for, (l)process 0 gets a grandparent for. Operaton as now taken effect, (m)te lsts for te sequence of trees n (d).