Hello, all.
I'm experimenting with concurrent haskell using GHC 6.4.
I wrote these fuctions as described in "Tackling the Awkward Squad":
par_io :: IO a -> IO a -> IO a
par_io t1 t2 = do c <- newEmptyMVar :: IO (MVar a)
id1 <- forkIO $ wrapper c t1
id2 <- forkIO $ wrapper c t2
res <- takeMVar c
killThread id1
killThread id2
return res
where wrapper :: MVar a -> IO a -> IO ()
wrapper mvar io = do res <- io
putMVar mvar res
timeout :: Int -> IO a -> IO (Maybe a)
timeout n t = do res <- par_io thr timer
return res
where thr = do res <- t
return $ Just res
timer = do threadDelay n
return Nothing
Now, then I try something like
timeout 1000000 (print $ cycle "test")
it behaves correctly: repeatingly prints "test" for one second and then
returns Nothing.
But then I try this:
timeout 1000000 (print $ 2^2^2^2^2^2)
it hangs for about eight seconds.
Currently I'm playing with theorem-proving using resolution. So I need
some technique to break a computation, if takes too long. It seems that
using "timeout" there does nothing. I waited for several minutes for
invalid theorem and timeout didn't expire.
"Control.Concurrent" page of "Haskell Hierarchical Libraries" says, that
a thread may be pre-empted whenever it allocates some memory, and that
tight loops which do no allocation tend to lock out other threads.
But resolution function, i wrote, hogs a *lot* of memory and (print $
2^2^2^2^2^2) does either. So i'm curious about this behavior of timeout.
So what is the correct way of running such computations in parallel?
Maybe I'm missing something?
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
