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 <dominic@steinitz.org>

Andrey Yankin <yankin013 <at> gmail.com> writes:

>
>
> Greetings to all!
>
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
> 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
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