Post on 13-Jan-2016
State Teleportation
How Hardware Transactional Memory can Improve Legacy Data
Structures
Maurice Herlihy and Eli Wald
Brown University
Transactional Memory
2
Concurrent Data Structure = State Machine
3
atomicstep
memorybarrier
atomicstep
memorybarrier
atomicstep
memorybarrier
Concurrent Data Structure = State Machine
4
atomicstep
memorybarrier
atomicstep
memorybarrier
atomicstep
memorybarrier
critical section,CAS, load/store
State Teleportation
5
atomicstep
memorybarrier
atomicstep
memorybarrier
atomicstep
memorybarrierHardware Transaction
“as if” sequence of transitions
Three Concurrent Lists
6
lazy
lock-free
locking
wait-free traversal + locks
lock-free everything
hand-over-hand locking
7
Hand-Over-Hand Locking
a b c d
remove(b)
8
Hand-Over-Hand Locking
a b c d
remove(b)
9
Hand-Over-Hand Locking
a b c d
remove(b)Found
it!
10
Hand-Over-Hand Locking
a b c d
remove(b)
11
Lazy List
a b c
remove(b)
12
Lazy List
a b c
remove(b)
13
Lazy List
a b c
remove(b)
14
Lazy List
a b c
remove(b)
15
Lazy List
a b c
validate …
remove(b)
16
Lazy List
a b c
Logical delete
remove(b)
17
Lazy List
a b c
Physical delete
bCAS
18
Lock-Free List
a c d
remove(c)
Benchmarks
19
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free lock-coupling
seconds to finish 100,000 operations
80% writes, 20% modifications
higher = worse
median of 6 runs
Benchmarks
20
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free lock-coupling
1-4
every threadhas a core
Benchmarks
21
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free lock-coupling
5-8
every threadhas a hyperthread
Benchmarks
22
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free lock-coupling
9-up
No Memory Management
23
1 2 3 4 5 6 7 8 9 10 11 120
500000000
1000000000
1500000000
2000000000
2500000000
3000000000
3500000000
4000000000
45000000008.86E+10115394692330off the charts!
lazy lock-free locking
Memory Management?
24
Locking:
Lazy:
Lock-Free:
immediate re-use
hazard pointers
hazard pointers
25
Hazard Pointers
Node* hazardRead(Node** object) { while (true) { Node* read = *object; hazard[myIndex] = read; membar(); Node* reread = *object; if (read == reread) return read; }}
26
Hazard Pointers
Node* hazardRead(Node** object) { while (true) { Node* read = *object; hazard[myIndex] = read; membar(); Node* reread = *object; if (read == reread) return read; }}
read pointer to object
27
Hazard Pointers
Node* hazardRead(Node** object) { while (true) { Node* read = *object; hazard[myIndex] = read; membar(); Node* reread = *object; if (read == reread) return read; }}
announce hazard
28
Hazard Pointers
Node* hazardRead(Node** object) { while (true) { Node* read = *object; hazard[myIndex] = read; membar(); Node* reread = *object; if (read == reread) return read; }} make announcement
visible (expensive)
29
Hazard Pointers
Node* hazardRead(Node** object) { while (true) { Node* read = *object; hazard[myIndex] = read; membar(); Node* reread = *object; if (read == reread) return read; }}
reread and validate
Without Memory Management
30
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free locking
With Memory Management
31
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free locking
32
Lock Teleportation
a b c d
33
Lock Teleportation
a b c dread transaction
34
Lock Teleportation
a b c dread transaction
35
Lock Teleportation
a b c d
no locks acquired
36
Hazard PointerTeleportation
a b c dread transaction
37
Hazard PointerTeleportation
a b c d
38
Hazard Pointer Teleportation
a b c dread transaction
39
Hazard Pointer Teleportation
a b c d
no memory barriers
Without Teleportation
40
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
lazy lock-free locking
With Teleportation
41
lazy lock-free locking
1 2 3 4 5 6 7 8 9 10 11 120
1000000000
2000000000
3000000000
4000000000
5000000000
6000000000
7000000000
Speedup
42
1 2 3 4 5 6 7 8 9 10 11 120
1
2
3
4
5
6
7
8Speedup
lazy lock-free locking
Adaptive Jumps
43
If transaction commits …Add 1 to next distance
If transaction aborts…Cut next distance in half
Average Teleport Distance
44
1 2 3 4 5 6 7 8 9 10 11 120
50
100
150
200
250
300
350
400
450
lazy lock-free locking
Average Commit Rate
45
1 2 3 4 5 6 7 8 9 10 11 1288
90
92
94
96
98
100
lazy lock-free locking
82
8
6.52
72
19.5
7
Abort Reasons
46
capacity explicitconflict unknown
4 threads 8 threads
Conclusions
47
True cost of concurrent data structuresshould include memory management
Cost of hazard pointers can equalizelock-based and lock-free structures
Adaptive Teleportation can substantiallyimprove memory management costs forboth lock-based and lock-free structures