Software Transactional Memory (STM) in Frege
1 like1,145 views
STM in Frege uses transactional variables (TVars) to allow for safe parallel programming without locks. TVars can only be accessed inside atomic transactions that isolate work and retry as needed to ensure consistency. This avoids issues like deadlocks seen with manual locking. The purely functional Frege language provides additional safety through type checking and preventing side effects inside transactions. Examples shown include counters and an account transfer that compose transactions for modularity.
Software Transactional Memory (STM) in Frege
- 1. STM Software Transactional Memory in Frege - a purely functional JVM language Parallel 2016, Heidelberg
- 3. Goal: make you curious How to program with STM How STM works in principle The benefits of STM How Frege keeps you safe
- 4. Silly Clock 10010 every ms on overflow every so often
- 6. Create new TVar type Counter = TVar Int newCounter :: STM Counter newCounter = TVar.new 0 STM action type
- 7. Read & Write TVar tick :: Counter -> STM () tick counter = do value <- counter.read counter.write (value + 1) STM action (no IO)
- 8. Check transaction invariant maxTick :: Counter -> Int -> STM () maxTick counter max = do tick counter value <- counter.read check (value <= max) Composition !
- 9. Consistent update onOverflow :: Counter->Counter->Int->STM () onOverflow counter overflowCounter max = do value <- counter.read check (value == max) tick overflowCounter reset counter Composition !
- 10. Type of reset enforced reset :: Counter -> STM () reset counter = counter.write 0 must be STM action
- 11. Atomically report :: Counter -> Counter -> IO () report millis secs = do (millisValue, secsValue) <- atomically $ do a <- millis.read b <- secs.read return (a, b) println $ show secsValue ++ " " ++ show millisValue Transaction demarcation calls STM action inside IO action
- 12. Starting the threads main _ = do millis <- atomically newCounter secs <- atomically newCounter milliOverflow = 1000 runTicker = maxTick millis milliOverflow runSec = onOverflow millis secs milliOverflow forkOS $ forever (atomically runTicker >> Thread.sleep 1) forkOS $ forever (atomically runSec ) forever (report millis secs >> Thread.sleep 100)
- 13. STM Works like compare and swap but for all TVars inside an atomically function plus invariants (check) plus alternatives (orElse) plus proper exception handling No user-managed locks -> No deadlocks
- 14. First one wins isolated work commit fail retry
- 15. Problem with locks Issue Risk Too few locks Race conditions Wrong lock order Deadlock Too many locks Less throughput Lock leakage Breaks modularity
- 16. Less concurreny errors STM replaces all your locks just like GC replaces manual memory management Makes compositional and modular code Is optimistic and thus works best in low contention scenarios Is not a panacea (sorry).
- 17. You must not Use TVars outside a transaction Do side effects inside a transaction no REST calls, no DB access, no file system access, no I/0 at all (time, threads, random), no object mutation, not even a „harmless“ println!
- 18. Developer Discipline Pure Functional Language code inspection type system
- 21. Classic: Account transfer deposit :: Account -> Int -> STM () deposit account amount = do balance <- account.read account.write (balance + amount) withdraw :: Account -> Int -> STM () withdraw account amount = deposit account (- amount) -- composed limitedWithdraw :: Account -> Int -> STM () limitedWithdraw account amount = do withdraw account amount -- composed balance <- account.read check (balance >= 0) transfer :: Account -> Account -> Int -> STM () transfer from to amount = do limitedWithdraw from amount -- composed deposit to amount -- composed
- 24. Frege STM summary No access to TVars outside transactions No side effects inside transactions TYPE SYSTEM (pure FP) Developer discipline (everybody else) www.frege-lang.org is the only option on the JVM
- 25. Dierk König canoo mittie Please give feedback! Credits Volker Steiss master thesis Simon Peyton-Jones Beautiful concurrency