1

Lock-Free Linked Lists Using Lock-Free Linked Lists Using Compare-and-SwapCompare-and-Swap

by John Valois

Speaker’s Name:

Talk Title:

Larry BushLarry Bush

2

ConcurrentConcurrentObjectObject

P1 P2 Pn

Shared Memory

3

Lock-FreeLock-Free

No Mutual Exclusion

Appear Atomic

Lamport

Massalin and Pu

4

Lock-Free Linked Lists?Lock-Free Linked Lists?

5

bool Compare&Swap ( Type * x, Type old, Type new) {

// BEGIN ATOMIC if *x != old {

• *x = new;• return TRUE;

} else {• return FALSE

}// END ATOMIC

}

Compare&Swap Compare&Swap Synchronization Synchronization PrimitivePrimitive

6

Why is this important ?Why is this important ?

Avoids Mutual Exclusion Problems

Convoying

Deadlock

Priority Inversion Busy Waiting

Blocking

7

Universal methods are not efficient (Herlihy).

Massalin and Pu’s method required the uncommon double word Compare&Swap.

Limitations of current Limitations of current implementationsimplementations

8

As quick as spin locks

Without blocking or busy waiting (wait free)

Benefits of new Benefits of new implementationimplementation

9

Part 2Part 2Concurrent Linked ListConcurrent Linked List

Cursor

Cursor

10

Traversal ( no problem )Traversal ( no problem )

Cursor

Cursor

11

Insert ( small problem )Insert ( small problem )

sp

q

12

Insert ( small problem )Insert ( small problem )

sp

q

13

Insert ( small problem )Insert ( small problem )

sp

qswing pointer

14

DeleteDelete

ba d

15

DeleteDelete

ba d

16

Delete Delete ( big problem )( big problem )

Cursor

a d

cb

Cursor

17

Delete Delete ( big problem )( big problem )

Cursor

a d

cb

Cursor

18

Delete Delete ( big problem )( big problem )

Cursor

a d

cb

Cursor

19

Delete Delete ( big problem )( big problem )

a d

cb

Cursor

Cursor

20

Iterator ( at node b )Iterator ( at node b )

a dcb

pre_aux

pre_cell target

21

Auxiliary nodesAuxiliary nodes

a dcb

22

Step OneStep One

a d

c

b

23

Step TwoStep Two

a d

c

b

24

Step ThreeStep Three

a d

c

b

25

Step FourStep Four

a d

c

b

26

Conclusion Conclusion Allows concurrent operations

Good for:parallel processingdistributed memory

Should be used everywhere

27

Questions/FactsQuestions/Facts

28

Why do you say this is lock-free if Why do you say this is lock-free if it uses a mutual exclusion it uses a mutual exclusion

primitive?primitive?Limited to atomic actions provided by the

hardware.Only when swinging pointers. Allows simultaneous traversal, insertion

and deletion.

Lamport (made the distinction)Massalin and Pu (coined the term)

29

Universal Algorithm (a.k.a. Universal Method) An algorithm that provides lock-free functionality for ANY generic

ADT is called universal. Universal meaning “for any.” This requires a powerful synchronization primitive. This is an application that defines a primitives strength.

Universal Primitive A universal primitive can be used to provide lock-free functionality for

any generic Data Type. A universal primitive can also solve the consensus problem.

Analogous Problems Generic Lock-Free ADT is analogous to the consensus problem. If a primitive is powerful enough to solve one it can also solve the

other.

UniversalUniversal

30

An implementation is wait-free if every process finishes in a bounded number of steps,

regardless of interleaving.

Wait-FreeWait-Free

31

Aux NodesAux Nodes

Insertion of new cells takes place between an auxiliary node and an existing regular cell.

Chains of auxilary nodes are allowed. An auxilary node is not required to have a real cell node before and after it.

32

ptr = find ptr of interest

repeat old = Read( ptr ); new = compute new pointer value r = Compare&Swap(ptr, old, new)

until ( r = TRUE )}

Swinging the PointerSwinging the Pointer

33

ABA problemABA problem

sp

qswing pointer

34

ABA SolutionsABA Solutions

Double Compare&Swap

No Cell Reuse

Memory Management

35

q = new cell

Repeat

r = SafeRead ( p -> next ) Write ( q -> next, r )

until Compare&Swap( p -> next, r, q )

Insert ( p, x )Insert ( p, x )

36

node * target; // -> data

node * pre_aux; // -> preceding auxiliary node

node * pre_cell; // -> previous cell

struct Cursor {struct Cursor {

};};

37

// Updates pointers in the cursor so that it becomes valid.

// removes double aux_node.

Update(cursor c) {Update(cursor c) {

};};

38

c.pre_cell = next // deletes cellback_link = c->pre_celldelete pre_auxConcurrent deletions may stall process and create

chains of aux nodes.The last deletion follows the back_links of the

deleted cells.After all deletions the list will have no extra

aux_nodes

Try_delete(cursor c) {Try_delete(cursor c) {

};};

39

Can be implemented using Compare&Swap

Test&Set Sets new value to TRUE.

Fetch&AddAdds an arbitrary value to shared variable.

Test&Set Fetch&AddTest&Set Fetch&Add

40

Created algorithms and data structures that directly implement a non-blocking singly-linked list.

Allows multiple processes to traverse, insert and delete.

Using only commonly available Compare&Swap. Single word version Commonly available on most systems

ValoisValois

41

Lock-Free Structures & Memory Management Techniques for linked list, dictionary and tree.

ContributionsContributions

42

Related WorkRelated Work

LamportHerlihyMassalin and Pu

43

Discovered that mutual exclusion problems can be avoided using lock-free methods.

Gave the first lock-free algorithm for the single writer/ multiple reader shared variable.

Led to more research on the topic.

27 years

LamportLamport