Of Concurrent Data Structures and Iterations

Nikolakopoulos, Yiannis; Gidenstam, Anders; Papatriantafilou, Marina; Tsigas, Philippas

doi:10.1007/978-3-319-24024-4_20

Cited by 2 publications

(2 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Some papers present wait-free implementations of Scan (or RangeScan) on data structures other than trees or in different settings. Nikolakopoulos et al [32,33] gave a set of consistency definitions for Scan and presented Scan algorithms for the lock-free concurrent queue in [28] that ensure different consistency and progress guarantees. Fatourou et al [15] presented a wait-free implementation of Scan on top of the non-blocking deque implementation of [27].…”

Section: Related Workmentioning

confidence: 99%

“…There has been much recent work on designing efficient concurrent implementations of set data structures [4,5,8,10,12,13,21,29,36,38], which provide algorithms for Insert, Delete, and Find. There is increasing interest in providing additional operations for modern applications, including iterators [1,32,33,35,36,37] or general range queries [6,9]. These are required in many big-data applications [11,26,34], where shared in-memory tree-based data indices must be created for fast data retrieval and useful data analytics.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Persistent Non-Blocking Binary Search Trees Supporting Wait-Free Range Queries

Fatourou

Papavasileiou

Ruppert

2019

The 31st ACM Symposium on Parallelism in Algorithms and Architectures

View full text Add to dashboard Cite

This paper presents the first implementation of a search tree data structure in an asynchronous shared-memory system that provides a wait-free algorithm for executing range queries on the tree, in addition to non-blocking algorithms for Insert, Delete and Find, using single-word Compareand-Swap (CAS). The implementation is linearizable and tolerates any number of crash failures.Insert and Delete operations that operate on different parts of the tree run fully in parallel (without any interference with one another). We employ a lightweight helping mechanism, where each Insert, Delete and Find operation helps only update operations that affect the local neighbourhood of the leaf it arrives at. Similarly, a RangeScan helps only those updates taking place on nodes of the part of the tree it traverses, and therefore RangeScans operating on different parts of the tree do not interfere with one another. Our implementation works in a dynamic system where the number of processes may change over time.The implementation builds upon the non-blocking binary search tree implementation presented by Ellen et al. [13] by applying a simple mechanism to make the tree persistent. 15 type Internal { subtype of Node 16 Key ∪ {∞1, ∞2} key 17 Update update 18 Node *left, *right 19 Node *prev 20 int seq 21 } 22 type Leaf { subtype of Node 23 Key ∪ {∞1, ∞2} key 24 Update update 25 Node *prev 26 int seq 27 } 28Initialization: 29 shared counter Counter := 0 30 shared Info *Dummy := pointer to a new Info object whose state field is Abort, and whose other fields are ⊥ 31 shared Internal *Root := pointer to new Internal node with key field ∞2, update field Flag, Dummy , prev field ⊥, seq field 0, and its lef t and right fields pointing to new Leaf nodes whose prev fields are ⊥, seq fields are 0, and keys ∞1 and ∞2, respectively 33 Precondition: seq ≥ 0 Precondition: p is non-⊥ and p → seq ≤ seq 45 if lef t then l := p → left else l := p → right Move down to appropriate child 46 while (l → seq > seq) l := l → prev 47 return l; 48 } 49 ValidateLink(Internal *parent, Internal *child, Boolean lef t): Boolean, Update { 50 Preconditions: parent and child are non-⊥ 51 Update up 52 up := parent → update 53 if Frozen(up) then { 54 Help(up.inf o) 55 return False, ⊥ 56 } 57 if (lef t and child = parent → lef t) or (¬lef t and child = parent → right) then return False, ⊥ 58 else return True, up 59 } Boolean validated 64 validated, pupdate := ValidateLink(p, l, k < p → key) 65 if validated and p = Root then validated, gpupdate := ValidateLink(gp, p, k < gp → key) 66 validated := validated and p → update = pupdate and (p = Root or gp → update = gpupdate) 67 return validated, gpupdate, pupdate 68 } 69 Find(Key k): Leaf* { 70 Internal * gp, p 71 Leaf *l 72 Boolean validated 73 while True { 74 seq := Counter 75 −, p, l := Search(k, seq) 76 validated, −, − := ValidateLeaf(gp, p, l, k) 77 if validated then { 78 if l → key = k then return l 79 else return ⊥ 80 } 81} 82 } 83 CAS-Child(Internal *parent, Node *old, Node *new) { Precondition: parent points to an Int...

show abstract