Beginners guide-concurrency

The Disruptor - A Beginners Guide to Hardcore Concurrency

Trisha Gee & Michael Barker / LMAX

Sunday, 13 November 11

Why is Concurrency So Difficult?


Program Order:

int w = 10;int x = 20;int y = 30;int z = 40;

int a = w + z;int b = x * y;

Execution Order (maybe):

int x = 20;int y = 30;int b = x * y;

int w = 10;int z = 40;int a = w + z;


Why Should We Care About the Details

?


static long foo = 0;

private static void increment() { for (long l = 0; l < 500000000L; l++) { foo++; }}


public static long foo = 0;public static Lock lock = new Lock();

private static void increment() { for (long l = 0; l < 500000000L; l++){ lock.lock(); try { foo++; } finally { lock.unlock(); } }}


static AtomicLong foo = new AtomicLong(0);

private static void increment() { for (long l = 0; l < 500000000L; l++) { foo.getAndIncrement(); }}


Cost of Contention

Increment a counter 500 000 000 times.

• One Thread : 300 ms


Cost of Contention


• One Thread : 300 ms• One Thread (volatile): 4 700 ms (15x)


Cost of Contention


• One Thread : 300 ms• One Thread (volatile): 4 700 ms (15x)• One Thread (Atomic) : 5 700 ms (19x)


Cost of Contention


• One Thread : 300 ms• One Thread (volatile): 4 700 ms (15x)• One Thread (Atomic) : 5 700 ms (19x)• One Thread (Lock) : 10 000 ms (33x)


Cost of Contention


• One Thread : 300 ms• One Thread (volatile): 4 700 ms (15x)• One Thread (Atomic) : 5 700 ms (19x)• One Thread (Lock) : 10 000 ms (33x)• Two Threads (Atomic) : 30 000 ms (100x)


Cost of Contention


• One Thread : 300 ms• One Thread (volatile): 4 700 ms (15x)• One Thread (Atomic) : 5 700 ms (19x)• One Thread (Lock) : 10 000 ms (33x)• Two Threads (Atomic) : 30 000 ms (100x)• Two Threads (Lock) : 224 000 ms (746x) ^^^^^^^^ ~4 minutes!!!


Parallel v. Serial - String Split

15

Guy Steele @ Strangle Loop:

http://www.infoq.com/presentations/Thinking-Parallel-Programming

Scala Implementation and Brute Force version in Java:

https://github.com/mikeb01/folklore/


0

500.0

1000.0

1500.0

2000.0

String Split (ops/sec) higher is better

Parallel (Scala) Serial (Java)


CPUs Are Getting Faster

17


Ya Rly!

18

0

750.0

1500.0

2250.0

3000.0

String Split

P8600 (Core 2 Duo)E5620 (Nehalem EP)i7 2667M (Sandy Bridge ULV)i7 2720QM (Sandy Bride)


What Problem Were Trying To Solve?


20


21


Why Queues Suck - Array Backed

22


Why Queues Suck - Linked List

23


Why Queues Suck - Linked List

24


Contention Free Design

25


26


How Fast Is It - Throughput

27

0

7500000.0

15000000.0

22500000.0

30000000.0

Unicast Diamond

ABQ Disruptor


How Fast Is It - Latency

28

ABQ Disruptor

Min 145 29

Mean 32,757 52

99 Percentile 2,097,152 128

99.99 Percentile 4,194,304 8,192

Max 5,069,086 175,567


How Does It Work?


Ordering and Visibility

30

private static final int SIZE = 32;private final Object[] data = new Object[SIZE];private volatile long sequence = -1;private long nextValue = -1;

public void publish(Object value) { long index = ++nextValue; data[(int)(index % SIZE)] = value; sequence = index;}

public Object get(long index) { if (index <= sequence) { return data[(int)(index % SIZE)]; } return null;}


Ordering and Visibility - Store

31

mov $0x1,%ecxadd 0x18(%rsi),%rcx ;*ladd;...lea (%r12,%r8,8),%r11 ;*getfield data;...mov %r12b,(%r11,%r10,1)mov %rcx,0x10(%rsi)lock addl $0x0,(%rsp) ;*ladd


Ordering and Visibility - Load

32

mov %eax,-0x6000(%rsp)push %rbpsub $0x20,%rsp ;*synchronization entry ; - RingBuffer::get@-1mov 0x10(%rsi),%r10 ;*getfield sequence ; - RingBuffer::get@2cmp %r10,%rdxjl 0x00007ff92505f22d ;*iflt ; - RingBuffer::get@6mov %edx,%r11d ;*l2i ; - RingBuffer::get@14


Look Ma’ No Memory Barrier

33

AtomicLong sequence = new AtomicLong(-1);

public void publish(Object value) { long index = ++nextValue; data[(int)(index % SIZE)] = value; sequence.lazySet(index);}


False Sharing - Hidden Contention

34


Cache Line Padding

35

public class PaddedAtomicLong extends AtomicLong {

public volatile long p1, p2, p3, p4, p5, p6 = 7L;

//... lines omitted

public long sumPaddingToPreventOptimisation() { return p1 + p2 + p3 + p4 + p5 + p6; }}


Summary

36

• Concurrency is a tool• Ordering and visibility are the key challenges• For performance the details matter• Don't believe everything you read

o Come up with your own theories and test them!


Q & A

[email protected]


Beginners guide-concurrency

Technology

Transcript of Beginners guide-concurrency