Scale Up with Lock-Free Algorithms. Non-blocking concurrency on JVM Presented at JavaOne 2017 /Roman JetBrains

Transcription

1 Scale Up with Lock-Free Algorithms Non-blocking concurrency on JVM Presented at JavaOne 2017 /Roman JetBrains

2 Speaker: Roman Elizarov 16+ years experience Previously developed high-perf trading Devexperts Teach concurrent & distributed St. Petersburg ITMO University Chief Northern Eurasia Contest / ACM ICPC Now work on JetBrains

3 Shared

4 Shared Mutable

5 Shared Mutable State

6

7

8 Shared Mutable State Why?

9 Big Big Data

10 Data 1 Data 2 Data N

11 Data 1 Data 2 Data N map map map

12 Data 1 Data 2 Data N map map map reduce answer

13 Embarrassingly parallel Data 1 Data 2 Data N map map map reduce answer

14 Big Big Data

15 Big Big Data Real-time

16 Big Big Data Real-time Concurrent requests / processing

17 Big Big Data Real-time Concurrent requests / processing Performance Scalability

18

19 A toy problem

20 A toy problem stack

21 A toy problem stack class Node<T>(val next: Node<T>?, val value: T)

22 A toy problem stack public final class Node<T> { private final Node<T> next; private final T value; public Node(Node<T> next, T value) { this.next = next; this.value = value; public Node<T> getnext() { return next; public T getvalue() { return value;

23 A toy problem stack class Node<T>(val next: Node<T>?, val value: T)

24 A toy problem empty stack class Node<T>(val next: Node<T>?, val value: T) top

25 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1

26 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 B next = A value = 2

27 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 B next = A value = 2

28 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1

29 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = null fun push(value: T) { top = Node(top, value)

30 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = null fun push(value: T) { top = Node(top, value)

31 A toy problem stack push class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = null fun push(value: T) { top = Node(top, value)

32 A toy problem stack class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1

33 A toy problem stack pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur

34 A toy problem stack pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur

35 A toy problem stack pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur result = 2

36 A toy problem stack pop class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = null fun push(value: T) { top = Node(top, value) fun pop(): T? { val cur = top?: return null top = cur.next return cur.value

37 A toy problem stack class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = null fun push(value: T) { top = Node(top, value) fun pop(): T? { val cur = top?: return null top = cur.next return cur.value

38 Does it work?

39 A toy problem concurrent push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 B next = A value = 2

40 A toy problem concurrent push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 B C next = A value = 2 next = A value = 3

41 A toy problem concurrent push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 B C next = A value = 2 next = A value = 3

42 A toy problem synchronized stack class Node<T>(val next: Node<T>?, val value: T) class LinkedStack<T> { private var top: Node<T>? = fun push(value: T) { top = Node(top, fun pop(): T? { val cur = top?: return null top = cur.next return cur.value

43 Does it scale?

44 open class LinkedStackBenchmark { private val stack = fun benchmark() { stack.push(1) check(stack.pop() == 1)

45 open class LinkedStackBenchmark { private val stack = fun benchmark() { stack.push(1) check(stack.pop() == 1)

46 Benchmark results Throughput (ops/s) Millions LinkedStack Number of threads Intel(R) Xeon(R) CPU E GHz; 32 HW threads; Java HotSpot(TM) 64-Bit Server VM (build 9+181, mixed mode)

47 Contention P pop 1 Q

48 Contention P pop 1 Q

49 Contention P pop 1 Q pop 2 wait

50 Contention P pop 1 Q pop 2 wait work

51 Deadlocks

52 Lock-free?

53 Lock-free push class Node<T>(val next: Node<T>?, val value: T) top expect А next = null value = 1 B next = A value = 2

54 Lock-free push class Node<T>(val next: Node<T>?, val value: T) top А next = null value = 1 update B next = A value = 2

55 Lock-free push class Node<T>(val next: Node<T>?, val value: T) top expect update А next = null value = 1 B next = A value = 2

56 AtomicReference package java.util.concurrent.atomic; 1.5 */ public class AtomicReference<V> { private volatile V value; public V get() { return value; public boolean compareandset(v expect, V update) { //

57 AtomicReference package java.util.concurrent.atomic; 1.5 */ public class AtomicReference<V> { private volatile V value; public V get() { return value; public boolean compareandset(v expect, V update) { //

58 AtomicReference package java.util.concurrent.atomic; 1.5 */ public class AtomicReference<V> { private volatile V value; public V get() { return value; public boolean compareandset(v expect, V update) { //

59 Using AtomicReference class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { val cur = top.get() val upd = Node(cur, value) if (top.compareandset(cur, upd)) return

60 Using AtomicReference class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { val cur = top.get() val upd = Node(cur, value) if (top.compareandset(cur, upd)) return

61 Using AtomicReference - push class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { 1 val cur = top.get() val upd = Node(cur, value) if (top.compareandset(cur, upd)) return

62 Using AtomicReference - push class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { 1 val cur = top.get() 2 val upd = Node(cur, value) if (top.compareandset(cur, upd)) return

63 Using AtomicReference class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { 1 val cur = top.get() 2 val upd = Node(cur, value) 3 if (top.compareandset(cur, upd)) return

64 Using AtomicReference - push class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { while (true) { 1 val cur = top.get() 2 val upd = Node(cur, value) 3 if (top.compareandset(cur, upd)) return

65 Powerful we have become!

66 Using AtomicReference - pop class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { fun pop(): T? { while (true) { val cur = top.get()?: return null if (top.compareandset(cur, cur.next)) return cur.value

67 Using AtomicReference class LockFree<T> { private val top = AtomicReference<Node<T>?>(null) fun push(value: T) { fun pop(): T? {

68 It s a trap

69 Using volatile variable class LinkedStackLF<T> private var top: Node<T>? = null fun push(value: T) { //...

70 Using AtomicReferenceFieldUpdater package java.util.concurrent.atomic; 1.5 */ public abstract class AtomicReferenceFieldUpdater<T,V> { public static <U,W> AtomicReferenceFieldUpdater<U,W> newupdater( Class<U> tclass, Class<W> vclass, String fieldname; public abstract boolean compareandset(t obj, V expect, V update;

71 Using AtomicReferenceFieldUpdater private volatile Node<T> top;

72 Using AtomicReferenceFieldUpdater private volatile Node<T> top; private static final AtomicReferenceFieldUpdater<LockFree, Node> TOP = AtomicReferenceFieldUpdater.newUpdater(LockFree.class, Node.class, "top");

73 Using AtomicReferenceFieldUpdater private volatile Node<T> top; private static final AtomicReferenceFieldUpdater<LockFree, Node> TOP = AtomicReferenceFieldUpdater.newUpdater(LockFree.class, Node.class, "top"); if (TOP.compareAndSet(this, cur, upd)) return;

74 Using VarHandle package java.lang.invoke; 9 */ public abstract class VarHandle public native boolean compareandset(object... args);

75 Using VarHandle private volatile Node<T> top; private static final VarHandle TOP; static { try { TOP = MethodHandles.lookup().findVarHandle(LockFree.class, "top", Node.class); catch (NoSuchFieldException IllegalAccessException e) { throw new InternalError(e);

76 Using VarHandle private volatile Node<T> top; private static final VarHandle TOP; static { try { TOP = MethodHandles.lookup().findVarHandle(LockFree.class, "top", Node.class); catch (NoSuchFieldException IllegalAccessException e) { throw new InternalError(e); if (TOP.compareAndSet(this, cur, upd) return;

77 Using AtomicFU J private val top = atomic<node<t>?>(null)

78 Using AtomicFU J private val top = atomic<node<t>?>(null) if (top.compareandset(cur, upd)) return

79 Using AtomicFU J private val top = atomic<node<t>?>(null) if (top.compareandset(cur, upd)) return Code like AtomicReference

80 Using AtomicFU J private val top = atomic<node<t>?>(null) if (top.compareandset(cur, upd)) return Code like AtomicReference compile Bytecode

81 Using AtomicFU J private val top = atomic<node<t>?>(null) if (top.compareandset(cur, upd)) return Code like AtomicReference compile Bytecode atomicfu AtomicReferenceFU

82 Using AtomicFU J private val top = atomic<node<t>?>(null) if (top.compareandset(cur, upd)) return Code like AtomicReference compile Bytecode atomicfu VarHandle

83 Was it worth it?

84 Benchmark results Throughput (ops/s) Millions LockFree LinkedStack Number of threads

85 Benchmark results Millions Yeh! Throughput (ops/s) Nay LockFree LinkedStack Number of threads

86 Contention P pop 1 Q pop 2 try update retry

87 Too toy of a problem? class LinkedStack<T> { private var top: Node<T>? = fun push(value: T) fun pop(): T? { val cur = top?: return null top = cur.next return cur.value

88 Too toy of a problem make it more real? class LinkedStack<T> { private var top: Node<T>? = fun push(value: T) fun pop(): T? { val cur = top?: return null top = cur.next Blackhole.consumeCPU(100L) return cur.value

89 Too toy of a problem make it more real? class LockFree<T> { private val top = atomic<node<t>?>(null) fun push(value: T) { fun pop(): T? { while (true) { val cur = top.value?: return null Blackhole.consumeCPU(100L) if (top.compareandset(cur, cur.next)) return cur.value

90 Benchmark results Millions Throughput (ops/s) Number of threads LockFree LinkedStack

91 open class LinkedStackBenchmark { private val stack = fun benchmark() { stack.push(1) check(stack.pop() == 1)

92 Read-dominated open class LinkedStackBenchmark { private val stack = fun benchmarkreaddominated() { stack.push(1) repeat(10) { check(stack.peek() == 1) check(stack.pop() == 1)

93 Read-dominated open class LinkedStackBenchmark { private val stack = fun benchmarkreaddominated() { stack.push(1) repeat(10) { check(stack.peek() == 1) check(stack.pop() == 1) class LinkedStack<T> fun peek() = top?.value

94 Read-dominated open class LockFreeBenchmark { private val stack = fun benchmarkreaddominated() { stack.push(1) repeat(10) { check(stack.peek() == 1) check(stack.pop() == 1) class LockFree<T> { fun peek() = top.value?.value

95 Benchmark results x10 reads Throughput (ops/s) Millions LockFree LinkedStack Number of threads

96 Benchmark results x100 reads Throughput (ops/s) Millions LockFree LinkedStack Number of threads

97 But scalability?

98 Real-world fun benchmarkreadworld() { stack.push(1) repeat(10) { check(stack.peek() == 1) Blackhole.consumeCPU(100L) check(stack.pop() == 1) Blackhole.consumeCPU(100L)

99 Benchmark results real world Throughput (ops/s) Millions Number of threads LockFree LinkedStack

100 Learn to ask the right questions You shall, young Padawan.

101

102 Links JMH Kotlin AtomicFU

103 Thank you Any questions? Slides are available at me to elizarov at gmail relizarov

104 Appendix

105 A toy problem concurrent pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur 1 cur 2

106 A toy problem concurrent pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur 1 cur 2

107 A toy problem concurrent pop class Node<T>(val next: Node<T>?, val value: T) top B next = A value = 2 A next = null value = 1 cur 1 cur 2 result 1 = 2 result 2 = 2