Software Transactional Memory (STM) provides an alternative to locks for concurrency. STM exploits features of Haskell like purity and immutability. Transactions are atomic, isolated, and retryable. The STM library provides primitives like TVar, TMVar, and TChan. Transactions use the atomically block and retry if inputs change. STM handles exceptions and guarantees without needing rollback. Bounded queues and strictness ensure performance and memory management. STM has been implemented in other languages like Clojure, Scala, C++, and C#.

1. Software Transactional Memory
Steve Severance – Alpha Heavy Industries

2. Motivation
• Innovations in concurrency has not kept pace
• Still using locks
• Immutability has helped in Haskell

3. STM Basics
• Transactional Concurrency
• Atomicity – Results are visible all at once
• Isolation – Action unaffected by other threads
• Everything you need is in the stm-2.4.2
package

4. Haskell and STM
• Exploits Three Haskell Features:
– Purity (Transactions must be pure)
– Monads
– Immutability (Values are never modified)
• Utilizes the Type System
– Anything involved in the transaction is marked
(TVar, TChan, STM, etc…)

5. Basic Transaction Pattern
• atomically $ do …
• atomically evaluates the transaction
main :: IO ()
main = do
var <- newTVarIO False
atomically $ do
val <- readTVar var
if val == False then writeTVar var True else return ()

6. Primitives
• TVar (Always has a Value)
• TMVar (Analogous to Regular MVar)
• TChan (Multicast Capabilities)
• TQueue (FIFO Queue)
• TBQueue (Bounded Queue)
• TSem (Semaphore)

7. Retrying
• Use the retry function to retry the transaction
• The transaction will only be run when one of
the inputs has changed
withdrawFunds :: TVar Account -> Money -> STM Money
withdrawFunds accountVar amount = do
account <- readTVar accountVar
if (aBalance account) > amount
then
writeTVar accountVar account{aBalance = (aBalance account) `subtract` amount} >> return amount
else retry

8. Choices
• orElse runs a second option if the first retrys
withdrawEvil :: TVar Account -> TChan Account -> Money -> STM Money
withdrawEvil accountVar nsfChan amount = do
withdrawFunds accountVar amount
`orElse` withdrawNonSufficientFunds accountVar nsfChan amount

9. Using Alternative
• You always wanted to use those cool
operators
• Use <|> instead of orElse

10. Dealing with Exceptions
• Revisiting the Atomic Guarantee
– No need for rollback unlike MVar and Chan
• STM can throw and catch

11. Bounded Queues
• TBQueue limits its size
• Writers will block until space becomes
available
• Useful for performance and memory
management

12. Being Strict
• Use NFData (deepseq)
• We internally use special write functions to
keep work from leaking across thread
boundaries
• Transaction TimewriteTVar’ :: NFData a => TVar a -> a -> STM ()
{-# INLINE writeTVar' #-}
writeTVar' var val =
rnf val `seq` writeTVar var val

13. Other Languages
• Clojure
• Scala
• C++
• C#/.Net

14. References
• Composable Memory Transactions
• Beautiful Concurrency
• STM Retrospective for .Net
• Gists:
– Sample 1