Guy KorlandTel Aviv University

CRAFTINGA READY-TO-GO STM

Process 1 Process 2

a = acc.get()a = a + 100 b = acc.get()

b = b + 50acc.set(b)

acc.set(a)

... Lost Update! ...

Process 1 Process 2

lock(A) lock(B)

lock(B) lock(A)

... Deadlock! ...

Process 1 Process 2

atomic{ atomic{a = acc.get() b = acc.get()a = a + 100 b = b + 50 acc.set(a) acc.set(b)

} }

... WIIIII ...

@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);

} });

DSTM2MAURICE HERLIHY ET AL, A FLEXIBLE FRAMEWORK … [OOPSLA06]

public class Account{

private VBox<Long> balance = new VBox<Long>();

public @Atomic void withdraw(long amount) {

balance.put (balance.get() - amount);

}

}

JVSTMJOÃO CACHOPO AND ANTÓNIO RITO-SILVA, VERSIONED BOXES AS THE BASIS FOR MEMORY TRANSACTIONS [SCOOL05]

public class Bank{

private double commission = 10;

@Atomic

public void transaction( Account ac1, Account ac2, double amount){

ac1.balance -= (amount + commission);

ac2.balance += amount;

}

}

DEUCE STM - APIGuy Korland, Nir Shavit and Pascal Felber, “Noninvasive Java Concurrency with Deuce STM”, [MultiProg '10]

DEUCE STM - OVERVIEW

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

BENCHMARKS (AZUL – VEGA2 – 2 X 48)

BENCHMARK - THE DARK SIDE

0

0.2

0.4

0.6

0.8

1

1.2

1 2 3 4 5 6 7 8 9 10

Lock

Deuce

• Contention – Retries, Aborts, Contention Manager …

• STM Algorithm – Data structures, optimistic, pessimistic…

• Semantic – Consistency model, Privatization…

• Instrumented Memory access – Linear overhead on every

read/write

OVERHEAD

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.

NEW STATIC ANALYSIS OPTIMIZATIONS

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. …

Yehuda Afek, Guy Korland, and Arie Zilberstein, “Lowering STM Overhead with Static Analysis”, LCPC'10

BENCHMARKS – K-MEANS

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

WWW.DEUCESTM.ORG