Software Transactional Memory Pure functional approach

Transcription

1 Software Transactional Memory Pure functional approach Alexander Granin C++ Russia 2018, Saint Petersburg

2

3 struct Presentation Introduction1 Functional programming in C++ Introduction2 Parallel and concurrent programming in C++ Theory Software Transactional Memory Practice Dining philosophers task Implementation What s inside? Limitations What you should be aware of

4 Introduction 1. Functional programming in C++ Lambdas, closures, functions (almost pure) std::function<> Combining of pure functions Immutability, POD-types Templates - pure functional language for_each(), recursion Type inference Pain

5 Introduction 2. Parallel and concurrent programming in C++ std::thread std::atomic std::future std::mutex std::promise std::condition_variable std::async

6 Theory. Software Transactional Memory Concurrent data model Independent parallel computations ( transactions ) over a different parts of the model Atomic commit of changed at the end of the computations: Successful, if there are no conflicts of competing changes Failed, if there are conflicts Changes will be rollbacked, transaction will be restarted It s also nice to have: Absence of explicit synchronizations Composable transactions Capability to retry transactions Adequate behavior and safety

7 Technical Specification ISO/IEC TS 19841:2015 New blocks: atomic_noexcept atomic_cancel atomic_commit synchronized Transaction-safe functions transaction_safe Pros: Transaction-safe functions Cons: Too chaotic Too far from release Bad way to do STM Requirements: GCC 6.1 int f() static int i = 0; atomic_noexcept ++i; return i; } }

8 Wyatt-STM Pros: WSTM::Atomically ([&](WSTM::WAtomic& at) Composable transactions Retry operation ++repeat1; In production v1.set (v1.get (at) + v2.get (at), at); Cons: barrier.wait (); Too imperative: easy to hack }); Has some unwanted weakness Boost Requirements: Visual Studio 2015, GCC 4.9, Clang 3.4 Boost CppCon 2015: Brett Hall Transactional Memory in Practice"

9 My library: cpp_stm_free Pros: Purely functional: hard to hack Composable monadic transactions Retry operation Adequate behavior Many ways to improve and optimize Cons: Highly experimental, Proof of Concept Mind blowing, probably Performance -??? (will measure later) Requirements: GCC 7.2, C STML<ForkPair> readforks(const TForkPair& forks) STML<Fork> lm = readtvar(forks.left); STML<Fork> rm = readtvar(forks.right); return both(lm, rm, mkforkpair);

10 TVar operations TVar<int> tmyint = newtvario(10);

11 TVar operations TVar<int> tmyint = newtvario(10); auto someresult = readtvar(tmyint);

12 TVar operations TVar<int> tmyint = newtvario(10); auto someresult = readtvar(tmyint); writetvar(tmyint, 20);

13 TVar operations TVar<int> tmyint = newtvario(10); // Why IO? auto someresult = readtvar(tmyint); // someresult is int? writetvar(tmyint, 20); // Doesn t return anything, right?

14 Transactions TVar<int> tmyint = newtvario(10); STML<int> someresult = readtvar(tmyint); STML<Unit> m = writetvar(tmyint, 20); STML<int> - transactional type, thus: readtvar writetvar newtvario - transaction - transaction - not a transaction // Why IO? // Not a transaction. // someresult is int? // Nope. It s STML<int>. // Doesn t return anything, right? // Actually returns STML<Unit>. (returns stm::stml<t>) (returns stm::stml<unit>) (returns something else)

15 Transactions template <typename A> STML<TVar<A>> newtvar(const A& val); newtvar :: A STML<TVar<A>> template <typename A> STML<A> readtvar(const TVar<A>& tvar); readtvar :: TVar<A> STML<A> template <typename A> STML<Unit> writetvar(const TVar<A>& tvar, const A& val); writetvar :: TVar<A> A STML<Unit> template <typename A> STML<A> retry(); retry :: STML<A> template <typename A> STML<A> pure(const A& val); pure :: A STML<A>

16 Composing transactions template <typename A, typename B> STML<B> bind(const STML<A> ma, const function<stml<b>(a)>& f); STML<int> transaction() STML<TVar<int>> t1 = newtvar(10); STML<int> t2 = bind(t1, [](const TVar<int>& tvar) return readtvar(tvar); }); return t2; } bind :: STML<A> (A STML<B>) STML<B> transaction :: STML<int> transaction = do tvar newtvar (10) readtvar (tvar)

17 Atomic evaluation STML<TVar<int>> t1 = newtvar(10); STML<int> t2 = bind(t1, readtvar); // short form without lambda Context context; int result1 = atomically(context, t2); int result2 = atomically(context, t2); // All TVars live in the context // result1 == 10 // result2 == 10, also* // * but can be different on case of many competing threads trying to change this TVar.

18 Retrying STML<TVar<int>> t1 = newtvar(10); STML<int> t2 = bind(t1, readtvar); STML<int> t3 = bind(t2, [](int i) if (i == 10) return retry(); return pure(i + 1); }); Context context; int result1 = atomically(context, t2); int result2 = atomically(context, t2); int result3 = atomically(context, t3); // short form without lambda // retry if i == 10 // return incremented i otherwise // All TVars live in the context // result1 == 10 // result2 == 10, also* // tries hard to retry the transaction // * but can be different on case of many competing threads trying to change this TVar.

19 Useful combinators template <typename A, typename B, typename Ret> STML<Ret> both(const STML<A>& ma, const STML<B>& mb, const function<ret(a, B)>& f); // Do both computations separately, // combine the results with function, // return combined result template <typename A, typename B> STML<B> sequence(const STML<A>& ma, const STML<B>& mb); // Do the first computation, // drop its result, // do the second computation, // return its result template <typename B> STML<B> ifthenelse(const STML<bool>& m, const STML<B>& montrue, const STML<B>& monfalse); // Do the conditional computation `m`, // if true, do `montrue` // otherwise, do `monfalse`

20 Practice. Dining philosophers task

21 enum class ForkState Free, Taken struct TForkPair TVar<Fork> left; TVar<Fork> right; struct Fork std::string name; ForkState state; struct Philosopher std::string name; TVar<Activity> activity; TForkPair forks; enum class Activity Thinking, Eating

22 Fine vs. Coarse Grained // Fine grained TVar<Fork> tfork1 = newtvario(somecontext, Fork "1", ForkState::Free}); TVar<Fork> tfork2 = newtvario(somecontext, Fork "2", ForkState::Free}); TVar<Fork> tfork3 = newtvario(somecontext, Fork "3", ForkState::Free}); // Coarse grained std::vector<fork> forks = Fork "1", ForkState::Free}, Fork "2", ForkState::Free}, Fork "3", ForkState::Free} } TVar<std::vector<Fork>> tforks = newtvario(somecontext, forks);

23 Taking a fork STML<bool> takefork(const TVar<Fork>& tfork) STML<bool> alreadytaken = withtvar(tfork, isforktaken); STML<Unit> takenbyus = modifytvar(tfork, setforktaken); STML<bool> success = sequence(takenbyus, pure(true)); STML<bool> fail = pure(false); STML<bool> result = ifthenelse(alreadytaken, fail, success); return result; const function<bool(fork)> isforktaken = [](const Fork& fork) return fork.state == ForkState::Taken; const function<fork(fork)> setforktaken = [](const Fork& fork) return Fork fork.name, ForkState::Taken

24 Taking both forks STML<bool> takeforks(const TForkPair& forks) STML<bool> lefttaken = takefork(forks.left); STML<bool> righttaken = takefork(forks.right); STML<bool> bothtaken = both(lefttaken, righttaken, [](bool l, bool r) return l && r; }); return bothtaken;

25 Philosopher: changing activity STML<Activity> changeactivity(const Philosopher& philosopher) STML<Activity> mactivity = readtvar(philosopher.activity); STML<Activity> mnewactivity = bind(mactivity, [=](Activity currentactivity) if (currentactivity == Activity::Thinking) STML<bool> taken = takeforks(philosopher.forks); STML<Unit> change = writetvar(philosopher.activity, Activity::Eating); STML<Unit> m = ifthenelse(taken, change, retry()); return sequence(m, pure(activity::eating)); } // more code here } return mnewactivity; } // try take forks // retry if not taken

26 Running the task void philosopherworker(stm::context& context, const Philosopher& philosopher) while (true) stm::atomically(context, changeactivity(philosopher)); std::this_thread::sleep_for(std::chrono::seconds(5)); } } stm::context context; stm::tvar<fork> tfork1 = stm::newtvario(context, Fork "1", ForkState::Free }, " Fork 1"); stm::tvar<fork> tfork2 = stm::newtvario(context, Fork "2", ForkState::Free }, " Fork 2"); Philosopher philosopher1 = mkphilosopher(context, "1", tfork1, tfork2); Philosopher philosopher2 = mkphilosopher(context, "2", tfork2, tfork1); std::thread(philosopherworker, context, philosopher1); std::thread(philosopherworker, context, philosopher2); // default activity TVar // will be created here

27 Sample console output [1] [2] [3] [4] [5] (2) (1) (2) (1) (1) Eating, Thinking, Eating, Thinking, Thinking, Philosopher Philosopher Philosopher Philosopher [1] [2] [3] [4] [5] (3) (2) (3) (2) (1) =Taken 2=Taken 3=Taken 4=Taken 5=Free changed changed changed changed Thinking, Eating, Thinking, Eating, Thinking, : : : : : 2=Taken 3=Taken 4=Taken 5=Free 1=Taken activity activity activity activity 1=Free 2=Taken 3=Taken 4=Taken 5=Taken : : : : : to: to: to: to: Thinking Thinking Eating Eating 2=Taken 3=Taken 4=Taken 5=Taken 1=Free for for for for seconds. seconds. seconds. seconds.

28 Implementation. What s inside?

29 Embedded Domain-Specific Language for STM template <typename A, typename Next> struct NewTVar A val; std::function<next(tvar<a>)> next; template <typename A, typename Next> struct WriteTVar TVar<A> tvar; A val; std::function<next(fp::unit)> next; template <typename A, typename Next> struct ReadTVar TVar<A> tvar; std::function<next(a)> next; template <typename A, typename Next> struct Retry

30 STM Algebraic Data Type template <class Ret> struct STMF std::variant<newtvar <std::any, Ret>, ReadTVar <std::any, Ret>, WriteTVar <std::any, Ret>, Retry <std::any, Ret> > stmf;

31 Free Monad Recursive Algebraic Data Type template <class Ret> struct STMF std::variant<newtvar <std::any, Ret>, ReadTVar <std::any, Ret>, WriteTVar <std::any, Ret>, Retry <std::any, Ret> > stmf; template <typename Ret> struct PureF Ret ret; template <typename Ret> struct FreeF STMF<STML<Ret>> stmf; template <typename Ret> struct STML std::variant<puref<ret>, FreeF<Ret> > stml;

32 Free Monad Recursive Algebraic Data Type STML<A> FreeF<A> STMF<STML<A>> ReadTVar<std::any, A> [](std::any any) return STML<A> PureF<A> std::any_cast<a>(any) } STML<A>

33 Free Monad Recursive Algebraic Data Type STML<A> FreeF<A> STMF<STML<A>> ReadTVar<std::any, A> [](std::any any) return STML<A> PureF<A> std::any_cast<a>(any) } STML<A>

34 Monadic binding template <typename A, typename B> struct BindStmlVisitor; template <typename A, typename B> struct BindStmfVisitor; template <typename A, typename B> STML<B> bind(const STML<A>& stml, const std::function<stml<b>(a)>& f) BindStmlVisitor<A, B> visitor(f); std::visit(visitor, stml.stml); return visitor.result; }

35 Pattern-matching template <typename A, typename B> struct BindStmfVisitor void operator() (const NewTVar<std::any, STML<A>>& method); void operator() (const ReadTVar<std::any, STML<A>>& method); void operator() (const WriteTVar<std::any, STML<A>>& method); void operator() (const Retry <std::any, STML<A>>&); template <typename A, typename B> struct BindStmlVisitor void operator() (const PureF<A>& variant); void operator() (const FreeF<A>& variant);

36 Typed / Untyped template <typename A, typename Next> struct ReadTVar TVar<A> tvar; std::function<next(a)> next; // ReadTVar<A, Next> // TVar<A> ReadTVar<std::any, Next> toany() const std::function<next(a)> nextcopy = next; ReadTVar<std::any, Next> m; m.tvar = TVar<std::any> tvar.id m.next = [=](const std::any& val) A val2 = std::any_cast<a>(val); return nextcopy(val2); return m; } // ReadTVar<std::any, Next> // TVar<std::any> // A std::any // std::any A

37 TVar Interface & Implementation using TVarId = utils::guid; template <typename T> struct TVar std::string name; TVarId id; struct TVarHandle GUID ustamp; std::any data; using TVars = std::map<tvarid, TVarHandle>; class Context std::map<tvarid, TVarHandle> _tvars; std::mutex _lock; public: bool trycommit(const GUID& ustamp, const TVars& stagedtvars);

38 Limitations. What you should be aware of Side effects in transactions are prohibited Proper binding of transactions Proper data model (fine grained vs coarse grained) Occasional infinite retry Dangerous closures (be careful passing things by reference) Starvation Deadlock / livelock Implementation isn t optimal by performance (yet)

39 Thanks for watching! Alexander Granin C++ Russia 2018, Saint Petersburg