Hi, Dominic! Thanks for advice. I will definitely use it for now. When I wrote
Do I have to call iterate only once at a time
It was obscure and has wrong words. I was trying to ask if it is necessary to run computeP every time I want to modify(traverse) an array? I was contemplating similar solution as you advise, but there is a concern. I want to modify it thousands of times and do not want to allocate and garbage more memory than needed. Here is the implementation I dream of: There must be function traverseNTimes that takes also an arbitrary number (the number of times to repeat traversal). Then it allocates but two new blocks and uses them to iterate the process as needed. No superfluous memory consumption. Is it unusual case? Is it worth thinking about? Do it give any performance gain? Actually I started with repa only yesterday, so I was thinking of delayed or cursored arrays which are capable of magic. Now I am beginning to see that it is not the case, though I don't know it for sure yet... )
BTW I think you can use stencils for what you are doing (I assume it is some sort of relaxation method) as the coefficients are constant. I think this should speed things up further as you won't be testing the boundary conditions on every loop. Sadly, there are much more sophisticated formulae and more than one boundary conditions on each side (and these conditions are moving)...
2013/1/14 Dominic Steinitz
Andrey Yankin
writes: Greetings to all!
anew, which means that delayed arrays are inefficient when the data is needed multiple times"( http://www.haskell.org/haskellwiki/Numeric_Haskell:_A_Repa_Tutorial).I started diving into Guiding Parallel Array Fusion with Indexed Types mentioned
repa?I wrote this rough sketch that shows what I am into. Apparently, program is severely slow. I think reason is:"Every time an element is requested from a delayed array it is calculated there. Is it a right place to find any answer to my question?
It's certainly possible to do this in repa. As I understand it, that is pretty much what repa is for. I'm not sure about your explanation for the slowdown although it sounds plausible.
I amended your code slightly and it runs pretty quickly for me using my 2 processors!
updater :: Source r Int => Array r DIM2 Int -> Array D DIM2 Int updater a = traverse a id step
updaterM :: Monad m => Int -> Array U DIM2 Int -> m (Array U DIM2 Int) updaterM n = foldr (>=>) return (replicate n (computeP . updater))
and replace
g <- computeP $ accumulate n grid :: IO (Array U DIM2 Int)
by
g <- updaterM n grid
BTW I think you can use stencils for what you are doing (I assume it is some sort of relaxation method) as the coefficients are constant. I think this should speed things up further as you won't be testing the boundary conditions on every loop.
Dominic.
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe