2011-11-02 | 05:45 PM - 06:35 PM | Victoria The Disruptor is new open-source concurrency framework, designed as a high performance mechanism for inter-thread messaging. It was developed at LMAX as part of our efforts to build the world's fastest financial exchange. Using the Disruptor as an example, this talk will explain of some of the more detailed and less understood areas of concurrency, such as memory barriers and cache coherency. These concepts are often regarded as scary complex magic only accessible by wizards like Doug Lea and Cliff Click. Our talk will try and demystify them and show that concurrency can be understood by us mere mortal programmers.

1. Trisha Gee & Michael Barker / LMAX
The Disruptor -
A Beginners Guide to
Hardcore Concurrency

2. Why is Concurrency So Difficult
?

3. Program Order: Execution Order (maybe):
int w = 10; int x = 20;
int x = 20; int y = 30;
int y = 30; int b = x * y;
int z = 40;
int w = 10;
int a = w + z; int z = 40;
int b = x * y; int a = w + z;

5. Why Should We Care About the
Details
?

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

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

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

9. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms

10. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)

11. Cost of Contention
Increment a counter 500 000 000 times.
• One Thread : 300 ms
• One Thread (volatile): 4 700 ms (15x)
• One Thread (Atomic) : 5 700 ms (19x)

12. Cost of Contention
Increment a counter 500 000 000 times.
• 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)

13. Cost of Contention
Increment a counter 500 000 000 times.
• 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)

14. Cost of Contention
Increment a counter 500 000 000 times.
• 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!!!

15. Parallel v. Serial - String Split
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/
15

16. Parallel (Scala) Serial (Java)
2000.0
1500.0
1000.0
500.0
0
String Split (ops/sec) higher is better

17. CPUs Are Getting Faster
17

18. Ya Rly!
P8600 (Core 2 Duo)
E5620 (Nehalem EP)
i7 2667M (Sandy Bridge ULV)
i7 2720QM (Sandy Bride)
3000.0
2250.0
1500.0
750.0
0
String Split 18

19. What Problem Were Trying To Solve
?

20. 20

21. 21

22. Why Queues Suck - Array Backed
22

23. Why Queues Suck - Linked List
23

24. Why Queues Suck - Linked List
24

25. Contention Free Design
25

26. 26

27. How Fast Is It - Throughput
ABQ Disruptor
30000000.0
22500000.0
15000000.0
7500000.0
0
Unicast Diamond
27

28. How Fast Is It - Latency
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
28

29. How Does It Work
?

30. Ordering and Visibility
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;
}
30

31. Ordering and Visibility - Store
mov $0x1,%ecx
add 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
31

32. Ordering and Visibility - Load
mov %eax,-0x6000(%rsp)
push %rbp
sub $0x20,%rsp ;*synchronization entry
; - RingBuffer::get@-1
mov 0x10(%rsi),%r10 ;*getfield sequence
; - RingBuffer::get@2
cmp %r10,%rdx
jl 0x00007ff92505f22d ;*iflt
; - RingBuffer::get@6
mov %edx,%r11d ;*l2i ; - RingBuffer::get@14
32

33. Look Ma’ No Memory Barrier
AtomicLong sequence = new AtomicLong(-1);
public void publish(Object value) {
long index = ++nextValue;
data[(int)(index % SIZE)] = value;
sequence.lazySet(index);
}
33

34. False Sharing - Hidden Contention
34

35. Cache Line Padding
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;
}
}
35

36. Summary
• 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!
36

37. Q&A
recruitment@lmax.com