Lock? We don't need no stinkin' locks!

Locks? We don’t need no
stinkin’ Locks!

@mikeb2701
http://bad-concurrency.blogspot.com
Image: http://subcirlce.co.uk

Causality
Causality
Fear will keep the
local systems inline.
instructions
- Grand Moff Wilhuff Tarkin

• Loads are not reordered with other loads.

• Stores are not reordered with other stores.

• Stores are not reordered with older loads.

• In a multiprocessor system, memory ordering obeys causality (memory
ordering respects transitive visibility).

• In a multiprocessor system, stores to the same location have a total order.

• In a multiprocessor system, locked instructions to the same
location have a total order.

• Loads and Stores are not reordered with locked instructions.

public class AtomicLong extends Number
implements Serializable {

// ...
private volatile long value;

// ...
/**
* Sets to the given value.
*
* @param newValue the new value
*/
public final void set(long newValue) {
value = newValue;
}

// ...
}

# {method} 'set' '(J)V' in 'java/util/concurrent/atomic/AtomicLong'
# this: rsi:rsi = 'java/util/concurrent/atomic/AtomicLong'
# parm0: rdx:rdx = long
# [sp+0x20] (sp of caller)
mov 0x8(%rsi),%r10d
shl $0x3,%r10
cmp %r10,%rax
jne 0x00007f1f410378a0 ; {runtime_call}
xchg %ax,%ax
nopl 0x0(%rax,%rax,1)
xchg %ax,%ax
push %rbp
sub $0x10,%rsp
nop
mov %rdx,0x10(%rsi)
lock addl $0x0,(%rsp) ;*putfield value
; - j.u.c.a.AtomicLong::set@2 (line 112)
add $0x10,%rsp
pop %rbp
test %eax,0xa40fd06(%rip) # 0x00007f1f4b471000
; {poll_return}

public class AtomicLong extends Number

// setup to use Unsafe.compareAndSwapLong for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

// ...
/**
* Eventually sets to the given value.
*
* @param newValue the new value
* @since 1.6
*/
public final void lazySet(long newValue) {
unsafe.putOrderedLong(this, valueOffset, newValue);
}

// ...
}

# {method} 'lazySet' '(J)V' in 'java/util/concurrent/atomic/
AtomicLong'
mov 0x8(%rsi),%r10d
shl $0x3,%r10
cmp %r10,%rax
jne 0x00007f1f410378a0 ; {runtime_call}
xchg %ax,%ax
xchg %ax,%ax
push %rbp
sub $0x10,%rsp
nop
mov %rdx,0x10(%rsi) ;*invokevirtual putOrderedLong
; - AtomicLong::lazySet@8 (line 122)
add $0x10,%rsp
pop %rbp
test %eax,0xa41204b(%rip) # 0x00007f1f4b471000
; {poll_return}

public class AtomicInteger extends Number

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

private volatile int value;

//...

public final boolean compareAndSet(int expect,
int update) {
return unsafe.compareAndSwapInt(this, valueOffset,
expect, update);
}
}

# {method} 'compareAndSet' '(JJ)Z' in 'java/util/concurrent/
atomic/AtomicLong'
# parm1: rcx:rcx = long
mov 0x8(%rsi),%r10d
shl $0x3,%r10
cmp %r10,%rax
jne 0x00007f6699037a60 ; {runtime_call}
xchg %ax,%ax
xchg %ax,%ax
sub $0x18,%rsp
mov %rbp,0x10(%rsp)
mov %rdx,%rax
lock cmpxchg %rcx,0x10(%rsi)
sete %r11b
movzbl %r11b,%r11d ;*invokevirtual compareAndSwapLong
; - j.u.c.a.AtomicLong::compareAndSet@9 (line
149)
mov %r11d,%eax
add $0x10,%rsp
pop %rbp
test %eax,0x91df935(%rip) # 0x00007f66a223e000
; {poll_return}

set() compareAndSet lazySet()
9

6.75

4.5

2.25

0
nanoseconds/op

Example - Disruptor Multi-producer

private void publish(Disruptor disruptor, long value) {
long next = disruptor.next();
disruptor.setValue(next, value);
disruptor.publish(next);
}

Example - Disruptor Multi-producer
public long next() {
long next;
long current;

do {
current = nextSequence.get();
next = current + 1;
while (next > (readSequence.get() + size)) {
LockSupport.parkNanos(1L);
continue;
}
} while (!nextSequence.compareAndSet(current, next));

return next;
}

Algorithm: Spin - 1

public void publish(long sequence) {
long sequenceMinusOne = sequence - 1;
while (cursor.get() != sequenceMinusOne) {
// Spin
}

cursor.lazySet(sequence);
}

Spin - 1
25

18.75
million ops/sec

12.5

6.25

0
1 2 3 4 5 6 7 8
Producer Threads

Algorithm: Co-Op
int counter = RETRIES;
while (sequence - cursor.get() > pendingPublication.length()) {
if (--counter == 0) {
Thread.yield();
counter = RETRIES;
}
}

long expectedSequence = sequence - 1;
pendingPublication.set((int) sequence & pendingMask, sequence);

if (cursor.get() >= sequence) { return; }

long nextSequence = sequence;
while (cursor.compareAndSet(expectedSequence, nextSequence)) {
expectedSequence = nextSequence;
nextSequence++;
if (pendingPublication.get((int) nextSequence & pendingMask) != nextSequence) {
break;
}
}
}

Spin - 1 Co-Op
30

22.5
million ops/sec

15

7.5

0
1 2 3 4 5 6 7 8
Producer Threads

Algorithm: Buffer
public long next() {
long next;
long current;

do {
current = cursor.get();
next = current + 1;
while (next > (readSequence.get() + size)) {
LockSupport.parkNanos(1L);
continue;
}
} while (!cursor.compareAndSet(current, next));

return next;
}

Algorithm: Buffer

int publishedValue = (int) (sequence >>> indexShift);
published.set(indexOf(sequence), publishedValue);
}

// Get Value
int availableValue = (int) (current >>> indexShift);
int index = indexOf(current);
while (published.get(index) != availableValue) {
// Spin
}

Spin - 1 Co-Op Buffer
70

52.5
million ops/sec

35

17.5

0
1 2 3 4 5 6 7 8
Threads

Q&A
• https://github.com/mikeb01/jax2012
• http://www.lmax.com/careers
• http://www.infoq.com/presentations/Lock-
free-Algorithms
• http://www.youtube.com/watch?
v=DCdGlxBbKU4

Lock? We don't need no stinkin' locks!

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Lock? We don't need no stinkin' locks! (20)

Recently uploaded (20)

Lock? We don't need no stinkin' locks!

Editor's Notes