Simon Peyton-Jones
In contrast, in a pure functional language there are no reads and writes, so all the pure part has zero overhead. Only when you do readTVar' and 'writeTVar' do you pay the overhead; these are a tiny fraction of all memory accesses.
From my small time experiments, there seems to be a noticeable but
I'm curious if there are any work done on the scalability of STM. Or rather - I expect the answer to be yes, but I'm curious what the results are :-) liveable overhead to STM, even without collisions. This is to be expected. But there also seem to be scalability issues, and in particular, the time a transaction takes, appears to scale superlinearly (in fact, more than O(n²)) with the number of TVars involved. Is this correct? (This is a killer for TArrays if you naïvely try to do: x <- atomically $ (newListArray (0,n-1) [0..n-1] :: STM (TArray Int Int)) and atomically $ unsafeFreeze x Instead, I had to do: x <- atomically $ (newArray (0,n-1) 0 :: STM (TArray Int Int)) sequence_ [atomically $ writeArray x i i | i <- [0..n-1]] and a <- newArray (0,n-1) empty :: IO (IOArray Int Cluster) mapM_ (\i -> do v <- atomically $ readArray cmap i writeArray a i v) [0..n-1] unsafeFreeze a After doing this, I measure roughly a factor of two between (single-threaded) operations on TArrays and STArrays, which I think is pretty good. Remains to be seen how it scales with multiple threads, though...) -k -- If I haven't seen further, it is by standing in the footprints of giants