[Haskell-cafe] Repa: traverse delayed array multiple times

[Andrey Yankin]

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 at 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 at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20130114/840d854f/attachment.htm>