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...