programming paradigms for concurrency part 2: transactional memories vasu singh [email protected]
TRANSCRIPT
Computing
Ubiquitous
Ever increasing performance!
Everyone expects computers to get faster
But, what triggers this perennial performance gain?
Moore's Law
Number of transistors per chip doubles once every two years
Moore's Law
Hoped to continue to until around 2015
However,
To get more speed, a processor needs higher chip frequency too
Around 2003, chip manufacturers hit the “heat wall”
Heat wall: Further increase in frequency would destroy the processor due to excessive heating (heat dissipation is cubic in chip frequency)
Alternative to a faster processor
Instead of making one processor faster, add more processors (keeps heat low, and the processor green)
But, how do we make a program faster with multiple processors?Do multiple things in parallelA paradigm shift!This course is about this paradigm shift
Writing Sequential Programs: Easy
X = X + 1 ; Y = Y + 1 ; Z = Z + 1
Correctness: At the end of the program, the variables X, Y, and Z must be incremented by 1.
Writing Parallel Programs: Harder
The programmer must divide work for different processors
The workers are known as “threads”
Examples: X := X + 1 || Y := Y + 1X := X + 1 || X := X + 1
Correctness of Parallel ProgramsThe effect of the program should be as if all threads
executed sequentially
When threads do not share dataX:= X+1 || Y:=Y+1 At the end of the program X and Y should be incremented by 1Easy to guarantee
When threads share dataX := X+1 || X:=X+1At the end of the program X should be incremented by 2Not so easy to guarantee: need to make sure that threads do
not interfere
Concurrency
Different threads may work on the same data
Concurrency: How the threads should interact so that they do not produce unexpected results
Two paradigms: Shared memory concurrency (Pavol and I)Message passing concurrency (Thomas)
We focus on shared memory concurrency now
Synchronization
Parallel programs demand synchronization: a discipline for the threads to access shared variables
Lack of synchronization leads to errors, commonly known as “concurrency bugs”
For example: in (X:=X + 1 || X:=X + 1), when X is initially 0, we can get X=1
Demo
Sequential Bank Account
Synchronized Parallel Bank Account
Unsynchronized Parallel Bank Account
Lock based Synchronization
While using locks, you have to guarantee a few more things:
Mutual exclusionStarvation freedomDeadlock freedom
Alternative programmer-friendly technique
The programmer marks program fragments as transactions
Demo
Transactional memory
A piece of hardware/software that guarantees that program fragments marked as “transactions” do execute atomically
How does a TM work?
PARALLELHARDWARE
TRANSACTIONALMEMORY
PROGRAMTHREADS
• The threads executes transactions.
• The transactions interact with the hardware via the transactional memory.
• The transactional memorykeeps track of all accessesin the different transactions.
• If accesses of two threads conflict, the TM aborts the transactions.
Problems with TM
Hard work pays: Performance of your program may not scale as with fine-grained locking
Speculative execution: Several I/O issues inside transactions (remember, transactions may abort, and so a transaction should not produce any output until it is sure to commit)
And many more…
That's what this course is for!
Course OutlineNovember 11: History of TM (dates back to
1991!)
November 18: Correctness properties in TM, Examples, STM
November 25: Formal Semantics of transactional programs
December 2: Performance issues in implementing STM
Projects
Seminar based (Study a set of coherent papers and summarize in a presentation and a report)
Implementation basedImplementation: task-driven efficient TMVerification: model checking, runtime
verification
Contact me, and we decide together
Thank You