concurrent queues and stacks - brown...

Concurrent Queues and Stacks

Companion slides for

The Art of Multiprocessor Programming

by Maurice Herlihy & Nir Shavit

Art of Multiprocessor Programming 22

The Five-Fold Path

• Coarse-grained locking

• Fine-grained locking

• Optimistic synchronization

• Lazy synchronization

• Lock-free synchronization


Another Fundamental Problem

• We told you about

– Sets implemented by linked lists

– Hash Tables

• Next: queues

• Next: stacks


Queues & Stacks

• pool of items


Queues

deq()/enq( )

Total order

First in

First out


Stacks

pop()/

push( )

Total order

Last in

First out


Bounded

• Fixed capacity

• Good when resources an issue


Unbounded

• Unlimited capacity

• Often more convenient


Blocking

zzz …

Block on attempt to remove from empty stack or queue


Blocking

zzz …

Block on attempt to add to full bounded stack or queue


Non-Blocking

Ouch!

Throw exception on attempt to remove from empty stack or queue


This Lecture

• Queue

– Bounded, blocking, lock-based

– Unbounded, non-blocking, lock-free

• Stack

– Unbounded, non-blocking lock-free

– Elimination-backoff algorithm


Queue: Concurrency

enq(x) y=deq()

enq() and deq()

work at different

ends of the object

tail head


Concurrency

enq(x)

Challenge: what if

the queue is empty

or full?

y=deq()


Bounded Queue

Sentinel

head

tail


Bounded Queue

head

tail

First actual item


Bounded Queue

head

tail

Lock out other

deq() calls

deqLock


Bounded Queue

head

tail

Lock out other

enq() calls

deqLock

enqLock


Not Done Yet

head

tail

deqLock

enqLock

Need to tell whether

queue is full or

empty


Not Done Yet

head

tail

deqLock

enqLock

Max size is 8 items

size

1


Not Done Yet

head

tail

deqLock

enqLock

Incremented by enq()

Decremented by deq()

size

1


Enqueuer

1

Lock enqLock

head

tail

deqLock

enqLock

size


Enqueuer

1

Read size

OK

head

tail

deqLock

enqLock

size


Enqueuer

1

No need to

lock tail

head

tail

deqLock

enqLock

size


Enqueuer

1

Enqueue Node

head

tail

deqLock

enqLock

size


Enqueuer

size

12

getAndincrement()

head

tail

deqLock

enqLock


Enqueuer

8Release lock

2

head

tail

deqLock

enqLock

size


Enqueuer

2

If queue was empty,

notify waiting dequeuers

head

tail

deqLock

enqLock

size


Unsuccesful Enqueuer

8

Uh-oh

Read size

…head

tail

deqLock

enqLock

size


Dequeuer

2

Lock deqLock

head

tail

deqLock

enqLock

size


Dequeuer

2

Read sentinel’s

next field

OK

head

tail

deqLock

enqLock

size


Dequeuer

siz

2

Read value

head

tail

deqLock

enqLock

size


Dequeuer

2

Make first Node

new sentinel

head

tail

deqLock

enqLock

size


Dequeuer

1

Decrement

size

head

tail

deqLock

enqLock

size


Dequeuer

1Release

deqLock

head

tail

deqLock

enqLock

size


Unsuccesful Dequeuer

0

Read sentinel’s

next field

uh-oh

head

tail

deqLock

enqLock

size


Bounded Queue

public class BoundedQueue<T> {

ReentrantLock enqLock, deqLock;

Condition notEmptyCondition, notFullCondition;

AtomicInteger size;

Node head;

Node tail;

int capacity;

enqLock = new ReentrantLock();

notFullCondition = enqLock.newCondition();

deqLock = new ReentrantLock();

notEmptyCondition = deqLock.newCondition();

}


Bounded Queue




AtomicInteger size;

Node head;

Node tail;

int capacity;





}

enq & deq locks


(push)


Digression: Monitor Locks

• Java synchronized objects and ReentrantLocks are monitors

• Allow blocking on a condition rather than spinning

• Threads: – acquire and release lock

– wait on a condition


public interface Lock {

void lock();

void lockInterruptibly() throws InterruptedException;

boolean tryLock();

boolean tryLock(long time, TimeUnit unit);

Condition newCondition();

void unlock;

}

The Java Lock Interface

Acquire lock



void lock();


boolean tryLock();



void unlock;

}


Release lock



void lock();


boolean tryLock();



void unlock;

}


Try for lock, but not too hard



void lock();


boolean tryLock();



void unlock;

}


Create condition to wait on




void lock();


boolean tryLock();



void unlock;

}

Never mind what this method does


Lock Conditions

public interface Condition {

void await();

boolean await(long time, TimeUnit unit);

…

void signal();

void signalAll();

}



void await();


…

void signal();

void signalAll();

}

Lock Conditions

Release lock and

wait on condition



void await();


…

void signal();

void signalAll();

}

Lock Conditions

Wake up one waiting thread



void await();


…

void signal();

void signalAll();

}

Lock Conditions

Wake up all waiting threads


Await

• Releases lock associated with q

• Sleeps (gives up processor)

• Awakens (resumes running)

• Reacquires lock & returns

q.await()


Signal

• Awakens one waiting thread

– Which will reacquire lock

q.signal();


Signal All

• Awakens all waiting threads

– Which will each reacquire lock

q.signalAll();


A Monitor Lock

Cri

tical S

ecti

on

waiting room

lock()

unlock()


Unsuccessful Deq

Cri

tical S

ecti

on

waiting room

lock()

await()

deq()

Oh no,

empty!


Another One

Cri

tical S

ecti

on

waiting room

lock()

await()

deq()

Oh no,

empty!


Enqueuer to the Rescue

Cri

tical S

ecti

on

waiting room

lock()

signalAll()enq( )

unlock()

Yawn!Yawn!


Yawn!

Monitor Signalling

Cri

tical S

ecti

on

waiting room

Yawn!

Awakened thread

might still lose lock to

outside contender…


Dequeuers Signalled

Cri

tical S

ecti

on

waiting room

Found it

Yawn!


Yawn!

Dequeuers Signaled

Cri

tical S

ecti

on

waiting room

Still empty!


Dollar Short + Day Late

Cri

tical S

ecti

on

waiting room


public class Queue<T> {

int head = 0, tail = 0;

T[QSIZE] items;

public synchronized T deq() {

while (tail – head == 0)

wait();

T result = items[head % QSIZE]; head++;

notifyAll();

return result;

}

…

}}

Java Synchronized Methods




T[QSIZE] items;



wait();


notifyAll();

return result;

}

…

}}


Each object has an implicit

lock with an implicit condition




T[QSIZE] items;



wait();


notifyAll();

return result;

}

…

}}


Lock on entry,

unlock on return




T[QSIZE] items;



wait();


this.notifyAll();

return result;

}

…

}}


Wait on implicit

condition




T[QSIZE] items;



this.wait();


notifyAll();

return result;

}

…

}}


Signal all threads waiting

on condition


(Pop!) The Bounded Queue




AtomicInteger size;

Node head;

Node tail;

int capacity;





}


Bounded Queue Fields




AtomicInteger size;

Node head;

Node tail;

int capacity;





}

Enq & deq locks






AtomicInteger size;

Node head;

Node tail;

int capacity;





}

Enq lock’s associated

condition






AtomicInteger size;

Node head;

Node tail;

int capacity;





}

size: 0 to capacity






AtomicInteger size;

Node head;

Node tail;

int capacity;





}

Head and Tail


Enq Method Part Onepublic void enq(T x) {

boolean mustWakeDequeuers = false;

enqLock.lock();

try {

while (size.get() == Capacity)

notFullCondition.await();

Node e = new Node(x);

tail.next = e;

tail = tail.next;

if (size.getAndIncrement() == 0)

mustWakeDequeuers = true;

} finally {

enqLock.unlock();

}

…

}


public void enq(T x) {


enqLock.lock();

try {

while (size.get() == capacity)



tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Enq Method Part One

Lock and unlock

enq lock




enqLock.lock();

try {




tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Enq Method Part One

Wait while queue is full …




enqLock.lock();

try {




tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Enq Method Part One

when await() returns, you

might still fail the test !




enqLock.lock();

try {




tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Be Afraid

After the loop: how do we know the

queue won’t become full again?




enqLock.lock();

try {




tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Enq Method Part One

Add new node




enqLock.lock();

try {




tail.next = e;

tail = tail.next;



} finally {

enqLock.unlock();

}

…

}

Enq Method Part One

If queue was empty, wake

frustrated dequeuers


Beware Lost Wake-Ups

Cri

tical S

ecti

on

waiting room

lock()

Queue empty

so signal ()

enq( )

unlock()

Yawn!


Lost Wake-Up

Cri

tical S

ecti

on

waiting room

lock()

enq( )

unlock()

Yawn!

Queue not

empty so no

need to signal


Lost Wake-Up

Cri

tical S

ecti

on

waiting room

Yawn!


Lost Wake-Up

Cri

tical S

ecti

on

waiting room

Found it


What’s Wrong Here?

Cri

tical S

ecti

on

waiting room

Still waiting ….!


Solution to Lost Wakeup

• Always use

– signalAll() and notifyAll()

• Not

– signal() and notify()

83


(pop)


Enq Method Part Deux


…

if (mustWakeDequeuers) {

deqLock.lock();

try {

notEmptyCondition.signalAll();

} finally {

deqLock.unlock();

}

}

}




…


deqLock.lock();

try {


} finally {

deqLock.unlock();

}

}

}Are there dequeuers to be signaled?



…


deqLock.lock();

try {


} finally {

deqLock.unlock();

}

}

}


Lock and

unlock deq lock



…


deqLock.lock();

try {


} finally {

deqLock.unlock();

}

}

}


Signal dequeuers that

queue is no longer empty


The enq() & deq() Methods

• Share no locks

– That’s good

• But do share an atomic counter

– Accessed on every method call

– That’s not so good

• Can we alleviate this bottleneck?


Split the Counter

• The enq() method

– Increments only

– Cares only if value is capacity

• The deq() method

– Decrements only

– Cares only if value is zero


Split Counter

• Enqueuer increments enqSize

• Dequeuer increments deqSize

• When enqueuer hits capacity– Locks deqLock

– Sets size = enqSize - DeqSize

• Intermittent synchronization

– Not with each method call

– Need both locks! (careful …)


A Lock-Free Queue

Sentinel

head

tail


Compare and Set

CAS


Enqueue

head

tail

enq( )


Enqueue

head

tail


Logical Enqueue

head

tail

CAS


Physical Enqueue

head

tailCAS


Enqueue

• These two steps are not atomic

• The tail field refers to either

– Actual last Node (good)

– Penultimate Node (not so good)

• Be prepared!


Enqueue

• What do you do if you find

– A trailing tail?

• Stop and help fix it

– If tail node has non-null next field

– CAS the queue’s tail field to tail.next

• As in the universal construction


When CASs Fail

• During logical enqueue

– Abandon hope, restart

– Still lock-free (why?)

• During physical enqueue

– Ignore it (why?)


Dequeuer

head

tail

Read value


Dequeuer

head

tail

Make first Node

new sentinel

CAS


Memory Reuse?

• What do we do with nodes after we

dequeue them?

• Java: let garbage collector deal?

• Suppose there is no GC, or we prefer

not to use it?


Dequeuer

head

tail

CAS

Can recycle


Simple Solution

• Each thread has a free list of unused

queue nodes

• Allocate node: pop from list

• Free node: push onto list

• Deal with underflow somehow …


Why Recycling is Hard

Free pool

head tail

Want to

redirect

head from

gray to red

zzz…


Both Nodes Reclaimed

Free pool

zzz

head tail


One Node Recycled

Free pool

Yawn!

head tail


Why Recycling is Hard

Free pool

CAS

head tail

OK, here

I go!


Recycle FAIL

Free pool

zOMG what went wrong?

head tail


The Dreaded ABA Problemhead tail

Head reference has value A

Thread reads value A


Dreaded ABA continued

zzz

head tail

Head reference has value B

Node A freed



Yawn!

head tail

Head reference has value A again

Node A recycled and reinitialized



CAS

head tail

CAS succeeds because references match,

even though reference’s meaning has changed


The Dreaded ABA FAIL

• Is a result of CAS() semantics

– Oracle, Intel, AMD, …

• Not with Load-Locked/Store-Conditional

– IBM …


Dreaded ABA – A Solution

• Tag each pointer with a counter

• Unique over lifetime of node

• Pointer size vs word size issues

• Overflow?

– Don’t worry be happy?

– Bounded tags?

• AtomicStampedReference class


Atomic Stamped Reference


– Java.util.concurrent.atomic package

address S

Stamp

Reference

Can get reference & stamp atomically


Concurrent Stack

• Methods

– push(x)

– pop()

• Last-in, First-out (LIFO) order

• Lock-Free!


Empty Stack

Top


Push

Top


Push

TopCAS


Push

Top


Push

TopCAS


Push

Top


Pop

Top


Pop

TopCAS


Pop

TopCAS

mine!


Pop

TopCAS


Pop

Top


public class LockFreeStack {

private AtomicReference top =

new AtomicReference(null);

public boolean tryPush(Node node){

Node oldTop = top.get();

node.next = oldTop;

return(top.compareAndSet(oldTop, node))

}

public void push(T value) {

Node node = new Node(value);

while (true) {

if (tryPush(node)) {

return;

} else backoff.backoff();

}}

Lock-free Stack



private AtomicReference top = new

AtomicReference(null);

public Boolean tryPush(Node node){


node.next = oldTop;


}



while (true) {


return;

} else backoff.backoff()

}}

Lock-free Stack

tryPush attempts to push a node







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

Read top value







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

current top will be new node’s successor







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

Try to swing top, return success or failure







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

Push calls tryPush







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

Create new node







node.next = oldTop;


}



while (true) {


return;


}}

Lock-free Stack

If tryPush() fails,

back off before retrying


Lock-free Stack

• Good

– No locking

• Bad

– Without GC, fear ABA

– Without backoff, huge contention at top

– In any case, no parallelism


Big Question

• Are stacks inherently sequential?

• Reasons why

– Every pop() call fights for top item

• Reasons why not

– Stay tuned …


Elimination-Backoff Stack

• How to

– “turn contention into parallelism”

• Replace familiar

– exponential backoff

• With alternative

– elimination-backoff


Observation

Push( )

Pop()

linearizable stack

After an equal number

of pushes and pops,

stack stays the sameYes!


Idea: Elimination Array

Push( )

Pop()

stack

Pick at

random

Pick at

random Elimination

Array


Push Collides With Pop

Push( )

Pop()

stack

continue

continue

No need to

access stack Yes!


No Collision

Push( )

Pop()

stack

If no collision,

access stack

If pushes collide or

pops collide

access stack



• Lock-free stack + elimination array

• Access Lock-free stack,

– If uncontended, apply operation

– if contended, back off to elimination array

and attempt elimination



Push( )

Pop()TopCAS

If CAS fails, back off


Dynamic Range and Delay

Push( )

Pick random range and

max waiting time based

on level of contention

encountered

50-50, Random Slots

0

20000

40000

60000

80000

100000

120000

2 4 8 121 62 4 324 04 85 66 4

Threads

ops/ msec Exchanger

Treiber

Asymmetric Rendevous

pop1()pop2()

Push( )

Pops find first vacant slot

and spin. Pushes hunt for

pops.

15 94 26head:

Asymmetric vs. Symmetric

0

20000

40000

60000

80000

100000

120000

2 4 8 12 16 24 32 40 48 56 64

op

s/m

se

c

Threads

50% Push/50% Pop/Random ids

Exchanger

Rendezvous

Treiber

(a) Instructions/op

0

100

200

300

400

500

600

2 4 8 12 16 24 32 40 48 56 64

Threads

instr

ucti

on

s/o

p

Exchanger

Rendezvous

Treiber

(b) Cache misses/op

0

5

10

15

20

25

30

2 4 8 12 16 24 32 40 48 56 64

Threads

instr

ucti

on

s/o

p

Exchanger

Rendezvous

Treiber

(c) CAS/op

0

5

10

15

20

25

30

2 4 8 12 16 24 32 40 48 56 64

Threads

instr

ucti

on

s/o

p

Exchanger

Rendezvous

Treiber

50% Push/50% Pop/Random ids

0

20000

40000

60000

80000

100000

120000

2 4 8 12 16 24 32 40 48 56 64

Threads

op

s/m

sec

Exchanger

Rendezvous

Treiber

50% Push/50% Pop

0

20000

40000

60000

80000

100000

120000

140000

2 4 8 12 16 24 32 40 48 56 64

Threads

op

s/m

se

c

Rendezvous (random ids)

Rendezvous(backoff,

random ids)

Rendezvous (seq ids)

Rendezvous(backoff, seq

ids)

Effect of Backoff and Slot Choice

Effect of Slot Choice

Random choice Sequential choice

Darker shades mean more exchanges

110

115

120

125

130

135

140

145

150

2 4 8 12 16 24 32 40 48 56 64

ins

tru

cti

on

s/o

p

Threads

Rendezvous instruction count:

sequential vs. random ids

Push (random ids) Pop (random ids)

Push (seq ids) Pop (seq ids)

Rendezvous array probes:


0

2

4

6

8

10

2 4 8 12 16 24 32 40 48 56 64

Threads

# p

ro

bes

Push (random ids) Push (seq ids)

Pop (random ids) Pop (seq ids)

Effect of Slot Choice

Rendezvous Pop spin iterations:


0

2

4

6

8

1 2 3 4 5 6 7 8 9 10 11

Threads

# s

pin

s

Pop (random ids) Pop (seq ids)


Linearizability

• Un-eliminated calls

– linearized as before

• Eliminated calls:

– linearize pop() immediately after

matching push()

• Combination is a linearizable stack


Un-Eliminated Linearizability

push(v1)

timetime

push(v1)

pop(v1)pop(v1)


Eliminated Linearizability

pop(v2)push(v1)

push(v2)

timetime

push(v2)

pop(v2)push(v1)

pop(v1)

Collision

Point

Red calls are

eliminated

pop(v1)


Backoff Has Dual Effect

• Elimination introduces parallelism

• Backoff to array cuts contention on lock-

free stack

• Elimination in array cuts down number

of threads accessing lock-free stack


public class EliminationArray {

private static final int duration = ...;

private static final int timeUnit = ...;

Exchanger<T>[] exchanger;

public EliminationArray(int capacity) {

exchanger = new Exchanger[capacity];

for (int i = 0; i < capacity; i++)

exchanger[i] = new Exchanger<T>();

…

}

…

}

Elimination Array



private static final int duration = ...;

private static final int timeUnit = ...;

Exchanger<T>[] exchanger;

public EliminationArray(int capacity) {

exchanger = new Exchanger[capacity];

for (int i = 0; i < capacity; i++)

exchanger[i] = new Exchanger<T>();

…

}

…

}

Elimination Array

An array of Exchangers


public class Exchanger<T> {

AtomicStampedReference<T> slot

= new AtomicStampedReference<T>(null, 0);

Digression: A Lock-Free

Exchanger


public class Exchanger<T> {

AtomicStampedReference<T> slot

= new AtomicStampedReference<T>(null, 0);

A Lock-Free Exchanger

Atomically modifiable

reference + status


Atomic Stamped Reference


– Java.util.concurrent.atomic package

• In C or C++:

address Sreference

stamp


Extracting Reference & Stamp

public T get(int[] stampHolder);


Extracting Reference & Stamp

public T get(int[] stampHolder);

Returns reference to

object of type T

Returns stamp at

array index 0!


Exchanger Status

enum Status {EMPTY, WAITING, BUSY};


Exchanger Status


Nothing yet



Exchange Status

Nothing yet

One thread is waiting

for rendez-vous


Exchange Status


Nothing yet

One thread is waiting

for rendez-vous

Other threads busy

with rendez-vous


public T Exchange(T myItem, long nanos)

throws TimeoutException {

long timeBound = System.nanoTime() + nanos;

int[] stampHolder = {EMPTY};

while (true) {

if (System.nanoTime() > timeBound)

throw new TimeoutException();

T herItem = slot.get(stampHolder);

int stamp = stampHolder[0];

switch(stamp) {

case EMPTY: … // slot is free

case WAITING: … // someone waiting for me

case BUSY: … // others exchanging

}

}

The Exchange






while (true) {





switch(stamp) {




}

}

The Exchange

Item and timeout






while (true) {





switch(stamp) {




}

}

The Exchange

Array holds status


public T Exchange(T myItem, long nanos) throws

TimeoutException {


int[] stampHolder = {0};

while (true) {





switch(stamp) {

case EMPTY: // slot is free

case WAITING: // someone waiting for me

case BUSY: // others exchanging

}

}}

The Exchange

Loop until timeout



TimeoutException {



while (true) {





switch(stamp) {



case BUSY: // others exchanging

}

}}

The Exchange

Get other’s item and status



TimeoutException {



while (true) {





switch(stamp) {




}

}}

The Exchange

An Exchanger has three possible states


Lock-free Exchanger

EMPTY


EMPTY

Lock-free Exchanger

CAS


WAITING

Lock-free Exchanger


Lock-free Exchanger

In search of

partner …

WAITING


WAITING

Lock-free Exchanger

Slot

Still waiting …

Try to exchange

item and set

status to BUSY

CAS


BUSY

Lock-free Exchanger

Slot

Partner showed

up, take item and

reset to EMPTY

item status


EMPTYBUSY

Lock-free Exchanger

Slot

item status

Partner showed

up, take item and

reset to EMPTY



if (slot.CAS(herItem, myItem, EMPTY, WAITING)) {

while (System.nanoTime() < timeBound){

herItem = slot.get(stampHolder);

if (stampHolder[0] == BUSY) {

slot.set(null, EMPTY);

return herItem;

}}

if (slot.CAS(myItem, null, WAITING, EMPTY)){


} else {



return herItem;

}

} break;

Exchanger State EMPTY








return herItem;

}}



} else {



return herItem;

}

} break;


Try to insert myItem and

change state to WAITING








return herItem;

}}



} else {



return herItem;

}

} break;


Spin until either

myItem is taken or timeout








return herItem;

}}



} else {



return herItem;

}

} break;


myItem was taken,

so return herItem

that was put in its place








return herItem;

}}



} else {



return herItem;

}

} break;


Otherwise we ran out of time,

try to reset status to EMPTY

and time out

Art of Multiprocessor Programming 190Art of Multiprocessor

Programming© Herlihy-Shavit

2007

190


if (slot.compareAndSet(herItem, myItem, WAITING,

BUSY)) {





return herItem;

}}

if (slot.compareAndSet(myItem, null, WAITING,

EMPTY)){throw new TimeoutException();

} else {



return herItem;

}

} break;


If reset failed,

someone showed up after all,

so take that item








return herItem;

}}



} else {



return herItem;

}

} break;


Clear slot and take that item








return herItem;

}}



} else {



return herItem;

}

} break;


If initial CAS failed,

then someone else changed status

from EMPTY to WAITING,

so retry from start



if (slot.CAS(herItem, myItem, WAITING, BUSY))

return herItem;

break;

case BUSY: // others in middle of exchanging

break;

default: // impossible

break;

}

}

}

}

States WAITING and BUSY




return herItem;

break;


break;


break;

}

}

}

}


someone is waiting to exchange,

so try to CAS my item in

and change state to BUSY




return herItem;

break;


break;


break;

}

}

}

}


If successful, return other’s item,

otherwise someone else took it,

so try again from start




return herItem;

break;


break;


break;

}

}

}

}


If BUSY,

other threads exchanging,

so start again


The Exchanger Slot

• Exchanger is lock-free

• Because the only way an exchange can

fail is if others repeatedly succeeded or

no-one showed up

• The slot we need does not require

symmetric exchange



…

public T visit(T value, int range)


int slot = random.nextInt(range);

int nanodur = convertToNanos(duration, timeUnit));

return (exchanger[slot].exchange(value, nanodur)

}}

Back to the Stack: the

Elimination Array



…






}}

Elimination Array

visit the elimination array

with fixed value and range



…






}}

Elimination Array

Pick a random array entry



…






}}

Elimination Array

Exchange value or time out



...

while (true) {


return;

} else try {

T otherValue =

eliminationArray.visit(value,policy.range);

if (otherValue == null) {

return;

}

}

Elimination Stack Push



...

while (true) {


return;

} else try {

T otherValue =



return;

}

}


First, try to push



...

while (true) {


return;

} else try {

T otherValue =



return;

}

}


If I failed, backoff & try to eliminate



...

while (true) {


return;

} else try {

T otherValue =



return;

}

}


Value pushed and range to try



...

while (true) {


return;

} else try {

T otherValue =



return;

}

}


Only pop() leaves null,

so elimination was successful



...

while (true) {


return;

} else try {

T otherValue =



return;

}

}


Otherwise, retry push() on lock-free stack


public T pop() {

...

while (true) {

if (tryPop()) {

return returnNode.value;

} else

try {

T otherValue =

eliminationArray.visit(null,policy.range;

if (otherValue != null) {

return otherValue;

}

}

}}

Elimination Stack Pop


public T pop() {

...

while (true) {

if (tryPop()) {

return returnNode.value;

} else

try {

T otherValue =

eliminationArray.visit(null,policy.range;

if ( otherValue != null) {

return otherValue;

}

}

}}

Elimination Stack Pop

If value not null, other thread is a push(),

so elimination succeeded


Summary

• We saw both lock-based and lock-freeimplementations of

• queues and stacks

• Don’t be quick to declare a data structure inherently sequential

– Linearizable stack is not inherently sequential (though it is in the worst case)

• ABA is a real problem, pay attention


This work is licensed under a Creative Commons Attribution-

ShareAlike 2.5 License.

• You are free:

– to Share — to copy, distribute and transmit the work

– to Remix — to adapt the work

• Under the following conditions:

– Attribution. You must attribute the work to “The Art of

Multiprocessor Programming” (but not in any way that

suggests that the authors endorse you or your use of the

work).

– Share Alike. If you alter, transform, or build upon this work,

you may distribute the resulting work only under the same,

similar or a compatible license.

• For any reuse or distribution, you must make clear to others the

license terms of this work. The best way to do this is with a link

to

– http://creativecommons.org/licenses/by-sa/3.0/.

• Any of the above conditions can be waived if you get permission

from the copyright holder.

• Nothing in this license impairs or restricts the author's moral

rights.

http://creativecommons.org/licenses/by-sa/2.5/



concurrent queues and stacks - brown...

Documents