Cloud Haskell / OTP evaluation
This program uses Cloud Haskell to dispatch jobs to nodes on the network and collect the result.
The nodes are connected in a ring structure. Every node has one neighbour it can communicate with. This leads to n network connections with n nodes.
A message is passed from one node to another, until it reaches the originator again. On message receipt every node does its job and attaches a new message to the incoming messages, then sends these to its next node. Therefore, a package contains at most n messages when received and resent in a ring with n nodes.
./bin/chotpeval worker -p 10010 &
./bin/chotpeval worker -p 10011 &
./bin/chotpeval worker -p 10012 &
./bin/chotpeval controller --send-for=10 --wait-for=5 --with-seed=77
On my dated laptop this has a throughput of about 8000 messages per second.
- stack build; stack install
- stack haddock
- stack test
in GHCi the distributed computation can be verified:
stack ghci
ghci> setStdGen $ mkStdGen <rng seed>
ghci> sumprod <lastindex>
Using LiquidHaskell types in Haskell can be restrained further and the propositions automatically checked with a SMT solver (e.g. z3).
for the random number generator, its output is restricted to be in the interval (0,1] (not including zero)
stack exec liquid -- --notermination src/HCOTP/Computation/Random.hs
in the controller we validate that at least two nodes are present when running the network
stack exec liquid -- --notermination src/HCOTP/Network/Controller.hs