Concurrent Queues and Stackscs.brown.edu/courses/csci1760/lectures/chapter_10_and_11.pdf · 2018....

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

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

Bounded Queue

First actual item

Bounded Queue

Lock out other

deq() calls

deqLock

Bounded Queue

Lock out other

enq() calls

deqLock

enqLock

Not Done Yet

deqLock

enqLock

Need to tell whether

queue is full or

Not Done Yet

deqLock

enqLock

Max size is 8 items

Not Done Yet

deqLock

enqLock

Incremented by enq()

Decremented by deq()

Enqueuer

Lock enqLock

deqLock

enqLock

Enqueuer

Read size

deqLock

enqLock

Enqueuer

No need to

lock tail

deqLock

enqLock

Enqueuer

Enqueue Node

deqLock

enqLock

Enqueuer

getAndincrement()

deqLock

enqLock

Enqueuer

8Release lock

deqLock

enqLock

Enqueuer

If queue was empty,

notify waiting dequeuers

deqLock

enqLock

Unsuccesful Enqueuer

Read size

…head

deqLock

enqLock

Dequeuer

Lock deqLock

deqLock

enqLock

Dequeuer

Read sentinel’s

next field

deqLock

enqLock

Dequeuer

Read value

deqLock

enqLock

Dequeuer

Make first Node

new sentinel

deqLock

enqLock

Dequeuer

Decrement

deqLock

enqLock

Dequeuer

1Release

deqLock

enqLock

Unsuccesful Dequeuer

Read sentinel’s

next field

deqLock

enqLock

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

• 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

tical S

waiting room

lock()

unlock()

Unsuccessful Deq

tical S

waiting room

lock()

await()

Oh no,

empty!

Another One

tical S

waiting room

lock()

await()

Oh no,

empty!

Enqueuer to the Rescue

tical S

waiting room

lock()

signalAll()enq( )

unlock()

Yawn!Yawn!

Monitor Signalling

tical S

waiting room

Awakened thread

might still lose lock to

outside contender…

Dequeuers Signalled

tical S

waiting room

Found it

Dequeuers Signaled

tical S

waiting room

Still empty!

Dollar Short + Day Late

tical S

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();

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();

while (size.get() == capacity)

tail.next = e;

tail = tail.next;

} finally {

enqLock.unlock();

Enq Method Part One

Lock and unlock

enq lock

enqLock.lock();

tail.next = e;

tail = tail.next;

} finally {

enqLock.unlock();

Enq Method Part One

Wait while queue is full …

enqLock.lock();

tail.next = e;

tail = tail.next;

} finally {

enqLock.unlock();

Enq Method Part One

when await() returns, you

might still fail the test !

enqLock.lock();

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();

tail.next = e;

tail = tail.next;

} finally {

enqLock.unlock();

Enq Method Part One

Add new node

enqLock.lock();

tail.next = e;

tail = tail.next;

} finally {

enqLock.unlock();

Enq Method Part One

If queue was empty, wake

frustrated dequeuers

Beware Lost Wake-Ups

tical S

waiting room

lock()

Queue empty

so signal ()

enq( )

unlock()

Lost Wake-Up

tical S

waiting room

lock()

enq( )

unlock()

Queue not

empty so no

need to signal

Lost Wake-Up

tical S

waiting room

Lost Wake-Up

tical S

waiting room

Found it

What’s Wrong Here?

tical S

waiting room

Still waiting ….!

Solution to Lost Wakeup

• Always use

– signalAll() and notifyAll()

• Not

– signal() and notify()

Enq Method Part Deux

if (mustWakeDequeuers) {

deqLock.lock();

notEmptyCondition.signalAll();

} finally {

deqLock.unlock();

deqLock.lock();

} finally {

deqLock.unlock();

}Are there dequeuers to be signaled?

deqLock.lock();

} finally {

deqLock.unlock();

Lock and

unlock deq lock

deqLock.lock();

} 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

Compare and Set

Enqueue

enq( )

Enqueue

Logical Enqueue

Physical Enqueue

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

Read value

Dequeuer

Make first Node

new sentinel

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

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

head tail

One Node Recycled

Free pool

head tail

Why Recycling is Hard

Free pool

head tail

OK, here

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

head tail

Head reference has value B

Node A freed

head tail

Head reference has value A again

Node A recycled and reinitialized

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

Reference

Can get reference & stamp atomically

Concurrent Stack

• Methods

– push(x)

– pop()

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

• Lock-Free!

Empty Stack

TopCAS

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( )

linearizable stack

After an equal number

of pushes and pops,

stack stays the sameYes!

Idea: Elimination Array

Push( )

Pick at

random

Pick at

random Elimination

Push Collides With Pop

Push( )

continue

No need to

access stack Yes!

No Collision

Push( )

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

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

15 94 26head:

Asymmetric vs. Symmetric

100000

120000

2 4 8 12 16 24 32 40 48 56 64

Threads

50% Push/50% Pop/Random ids

Exchanger

Rendezvous

Treiber

(a) Instructions/op

2 4 8 12 16 24 32 40 48 56 64

Threads

Exchanger

Rendezvous

Treiber

(b) Cache misses/op

2 4 8 12 16 24 32 40 48 56 64

Threads

Exchanger

Rendezvous

Treiber

(c) CAS/op

2 4 8 12 16 24 32 40 48 56 64

Threads

Exchanger

Rendezvous

Treiber

50% Push/50% Pop/Random ids

100000

120000

2 4 8 12 16 24 32 40 48 56 64

Threads

Exchanger

Rendezvous

Treiber

50% Push/50% Pop

100000

120000

140000

2 4 8 12 16 24 32 40 48 56 64

Threads

Rendezvous (random ids)

Rendezvous(backoff,

random ids)

Rendezvous (seq ids)

Rendezvous(backoff, seq

Effect of Backoff and Slot Choice

Effect of Slot Choice

Random choice Sequential choice

Darker shades mean more exchanges

2 4 8 12 16 24 32 40 48 56 64

Threads

Rendezvous instruction count:

sequential vs. random ids

Push (random ids) Pop (random ids)

Push (seq ids) Pop (seq ids)

Rendezvous array probes:

2 4 8 12 16 24 32 40 48 56 64

Threads

Push (random ids) Push (seq ids)

Pop (random ids) Pop (seq ids)

Effect of Slot Choice

Rendezvous Pop spin iterations:

1 2 3 4 5 6 7 8 9 10 11

Threads

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

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

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

WAITING

Lock-free Exchanger

In search of

partner …

WAITING

Lock-free Exchanger

Still waiting …

Try to exchange

item and set

status to BUSY

Lock-free Exchanger

Partner showed

up, take item and

reset to EMPTY

item status

EMPTYBUSY

Lock-free Exchanger

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

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;

someone is waiting to exchange,

so try to CAS my item in

and change state to BUSY

return herItem;

break;

If successful, return other’s item,

otherwise someone else took it,

so try again from start

return herItem;

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

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

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

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

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

Concurrent Queues and Stackscs.brown.edu/courses/csci1760/lectures/chapter_10_and_11.pdf · 2018....

Documents

Transcript of Concurrent Queues and Stackscs.brown.edu/courses/csci1760/lectures/chapter_10_and_11.pdf · 2018....

Performance modeling of multiprocessor systems for ...atiq/papers/93-multiprocessor-data-loading.pdfPerformance modeling of multiprocessor systems 169 achieved from algorithms requiring

Chapter 25 Lists, Stacks, Queues, and Priority Queues

Multiprocessor architecture

Multiprocessor Scheduling

Multiprocessor scheduling 2

Queues & Priority Queues Radix Sort Heap Sort. Outline n Queues queue operationsqueue operations algorithms with queuesalgorithms with queues radix sortradix.

FPGA Based Multiprocessor

A Fully Preemptive Multiprocessor Semaphore Protocol for ...bbb/papers/talks/ecrts13b.pdf · Multiprocessor Semaphore Protocol for Latency ... A fully preemptive multiprocessor semaphore

Creating Multiprocessor Nios II Systems Tutorialjjackson.eng.ua.edu/courses/ece680/lectures/Creating Multiprocessor... · Benefits of Multiprocessor Systems quickly design and build

Queues queues queues — How RabbitMQ enables reactive architectures

Multiprocessor Systems

Stacks and Queues. Abstract Data Types Stacks Queues Priority Queues September 2004John Edgar2.

Concurrent Queues Companion slides for The Art of Multiprocessor Programming by Maurice Herlihy & Nir Shavit.

Queues, Deques, and Priority Queues

STACKS AND QUEUES 1. Outline 2 Stacks Queues.

Symmetric multiprocessor

Data Structures – Week #4 Queues. January 12, 2016Borahan Tümer, Ph.D.2 Outline Queues Operations on Queues Array Implementation of Queues Linked List.

Bit Multiprocessor

Multiprocessor Simulators LV

Multiprocessor scheduling 3