Abort Free SemanticTM by Dependency Aware Scheduling of Transactional Instructions Shlomi Dolev...

Abort Free SemanticTM by Abort Free SemanticTM by Dependency Aware Scheduling Dependency Aware Scheduling of Transactional Instructionsof Transactional Instructions

Shlomi DolevBen-Gurion University of the Negev

Israel

WTM 2013

Panagiota FatourouUniversity of Crete & FORTH-ICS

Greece

Eleftherios KosmasUniversity of Crete & FORTH-ICS

Greece

WTM 2013S. Dolev & P. Fatourou & E. Kosmas

When two transactions conflict, most TM systems abort one of them to ensure consistency

Ideally: All transactions should commit Parallelism should not be sacrificed

TMs that never abort transactions are highly desirable support of irrevocable transactions avoid the cost of re-executing aborted transactions

Two transactions conflict, if they both access the same t-variable and at least one of these accesses is a

write

Introduction


SemanticTM

an opaque TM algorithm

no transaction ever aborts guarantees wait-freedom/local progress for the

execution of transactions

fine-grain parallelism at the transactional instruction level

An execution of a TM algorithm is opaque if it satisfies strict serializability and active

transactions read “consistent” values for t-variables

Our Result


Transaction Level Parallelism

p1 p2 pn

2. T1.read(z)

x y z w

1. T1.read(x)

5. T1.write(w)

4. T1.read(w)

3. T1.write(y)

T2.read

T2.write

T2.write

T2.read

Tm.read

Tm.read

Tm.read

T2T1 Tm


Transactional Instruction Level Parallelism

p1 p2 pn

2. T1.read

x y z w

1. T1.read

5. T1.write

4.T1.read3. T1.write

dependencies may exist between instructions of the same transaction

T2.read

T2.write

T2.write

T2.read

Tm.read

Tm.read

Tm.read

T2 Tm


SemanticTM

p1 p2 pn

T1.read

x y z w

T1.read

T1.write

T1.readT1.write

T2.readT2.write

T2.write

T2.read

Tm.readTm.read

Tm.read

t-var lists

a scheduler places transactional intructions into t-var lists together with their dependencies

transactions are processed by the scheduler the one after the other each process randomly chooses a t-var list and executes its ready instructions no conflicts occur between transactions

p3

For relatively simple transactions the work of the scheduler can be done at compile time.


If the execution of a transactional instruction e2 depends on the execution of a transactional instruction e1

there is a dependency between e1 and e2

input dependency for e2

output dependency for e1

A dependency between a read and a write instruction → data dependency a cond and a read (or a write) instruction → control

dependency

Dependencies

x:=3x++y:=x

if ( ) then x:=1

x+y = 5


x:=3x++y:=x

write(x,3)tmp1 := read(x)write(x,tmp1+1)tmp2 := read(x)write(y,tmp2)

write write

00

x y

read

writedata dep

p1 p2

read

Reads and Writes

0 0434


if(x+y = 5) then x := 1

tmp1 := read(x)tmp2 := read(y)tmp3 := tmp1+tmp2 cond(tmp3=5) write(x,1)

x y

read

cond

write

data dep

control dep

p1 p2

If cond evaluates to TRUE then the write is executedOtherwise it is invalidated

read

Conditionals – if statement


if(x = 1) then x := 2else x := 4y := x

tmp1 := read(x)cond(tmp1 = 1) write(x,2)cond(tmp1 <> 1) write (x,4)tmp2 := read(x)write(y,tmp2)

x y

read write

cond

cond

write

write

read

data dep

control dep

p1 p2

Conditionals – if..else statements

0404


Loops

while(x < 10) do y := x x := 2* x

tmp1 := read(x)cond(tmp1 < 10, loop) tmp2 := read(x) write(y,tmp2) tmp3 := 2 * tmp2

write(x,tmp3) tmp1 := read(x)

x y

read

cond

read

write

write

readcontrol

dep

data dep

across iteration data

dep


Loops

01

x y

read

cond

read

output data dep

control dep

write

write

read

across iteration data

dep

0 000

0

0

0

0Metadata

01

1

1

1

1

0 01 0 1 111 2

2

2

2

2

2 222

while (x < 10) y := x x := x*2

44 444

4

4

4

4

Metadata

p1 p2

12 24 816


Synchronization

for each transactional instruction status (ACTIVE, DONE)

together with the value of each input data dependency iteration number CAS object

for each control dependency CAS object

x y

status statusval iter

for the value of each t-variable version

CAS object update using oldvalue

iteration number

CAS object

val read

ver ver1

oldval iterwrite

1


Support of transactions accessing t-variables that are known at run time accessing an element of an array

Extensions

A[1] A[2] A[3] A[m]

read readread

write

read

read read

read: A[*]

write: A[*]

read: A[3]

write: A[2]

read: A[*]

read: A[*]

write: A[*]

A[*]

Dynamic transactions similar strategy as above, if we consider the memory heap as an

array Nested conditionals & loops (cond c2 in the block of outer cond

c1) add a control dependency from c1 to c2 but not to the instructions

of the block of c2.


Summary We presented SemanticTM:

executes transactions without ever causing any aborts parallelism is fine-grained achieved at the level of

transactional instructions

Blocking version of SemanticTM

Future Work Implement an optimized version of SemanticTM

Experimental Study

Conclusion & Future Work


QUESTIONS?

Thank you!

Abort Free SemanticTM by Dependency Aware Scheduling of Transactional Instructions Shlomi Dolev...

Documents

Transcript of Abort Free SemanticTM by Dependency Aware Scheduling of Transactional Instructions Shlomi Dolev...