This document discusses techniques for building efficient software transactional memory (STM) systems. It begins by demonstrating how STM avoids problems like lost updates and deadlocks that can occur with traditional locking. It then reviews several existing STM implementations and their approaches. Benchmark results showing the performance of STM systems are presented, along with analysis of overhead sources. The document concludes by discussing optimizations like static analysis that can reduce STM overhead and make data structures more friendly to concurrent transactions.

1. CRAFTING
A READY-TO-GO STM
Guy Korland
Tel Aviv University

4. Process 1
a = acc.get()
a = a + 100
acc.set(a)
Process 2
b = acc.get()
b = b + 50
acc.set(b)
... Lost Update! ...

5. Process 1
Process 2
lock(A)
lock(B)
lock(B)
lock(A)
... Deadlock! ...

7. Process 1
Process 2
atomic{
a = acc.get()
a = a + 100
acc.set(a)
}
atomic{
b = acc.get()
b = b + 50
acc.set(b)
}
... WIIIII ...

9. DSTM2
MAURICE HERLIHY ET AL, A FLEXIBLE FRAMEWORK … [OOPSLA06]
@atomic public interface INode{
int getValue ();
void setValue (int value );
}
Factory<INode> factory = Thread.makeFactory(INode.class );
final INode node = factory.create();
factory result = Thread.doIt(new Callable<Boolean>() {
public Boolean call () {
return node.setValue(value);
} });

10. JVSTM
JOÃO CACHOPO AND ANTÓNIO RITO-SILVA, VERSIONED BOXES AS THE BASIS
FOR MEMORY TRANSACTIONS [SCOOL05]
public class Account{
private VBox<Long> balance = new VBox<Long>();
public @Atomic void withdraw(long amount) {
balance.put (balance.get() - amount);
}
}

11. DEUCE STM - API
Guy Korland, Nir Shavit and Pascal Felber, “Noninvasive Java
Concurrency with Deuce STM”, [MultiProg '10]
public class Bank{
private double commission = 10;
@Atomic
public void transaction( Account ac1, Account ac2, double amount){
ac1.balance -= (amount + commission);
ac2.balance += amount;
}
}

12. DEUCE STM - OVERVIEW

13. BENCHMARKS
(SUN ULTRASPARC T2 PLUS – 2 X QUAD X 8HT)

14. BENCHMARKS
(AZUL – VEGA2 – 2 X 48)

17. BENCHMARK - THE DARK SIDE
1.2
1
0.8
0.6
Lock
Deuce
0.4
0.2
0
1
2
3
4
5
6
7
8
9
10

19. OVERHEAD
• Contention – Retries, Aborts, Contention Manager …
• STM Algorithm – Data structures, optimistic, pessimistic…
• Semantic – Consistency model, Privatization…
• Instrumented Memory access – Linear overhead on every
read/write

20. STATIC ANALYSIS
OPTIMIZATIONS
1. Avoiding instrumentation of accesses to
immutable and transaction-local memory.
2. Avoiding lock acquisition and releases for
thread-local memory.
3. Avoiding readset population in
read-only transactions.

21. NEW STATIC ANALYSIS
OPTIMIZATIONS
Yehuda Afek, Guy Korland, and Arie Zilberstein,
“Lowering STM Overhead with Static Analysis”, LCPC'10
1. Reduce amount of instrumented memory reads using
load elimination.
2. Reduce amount of instrumented memory writes using
scalar promotion.
3. Avoid writeset lookups for memory
not yet written to.
4. Avoid writeset record keeping for memory that
will not be read.
5. Reduce false conflicts by Transaction re-scoping.
6. …

22. BENCHMARKS – K-MEANS

23. STM FRIENDLY LIBRARIES
• Most of the developers/application only use Data Structures.
@Atomic(retries=64)
public void transaction( Map map1, Map map2, String key){
map2.put(key, map1.remove(key));
}
 We should build a set of “STM Friendly” libraries.
Maurice Herlihy, Eric Koskinen: Transactional boosting:
a methodology for highly-concurrent transactional objects. PPOPP’08

25. WWW.DEUCESTM.ORG