Hello Chris,
Would you like for me to post your response on blogs.perl.org? I'd be happy
to do so (under my account, but starting with "Chris Marshal replied...")
Believe it or not, this case is not too pathological for my research. My
calculations often only need local or nearby information and can often make
an early exit to save lots of compute cycles. Usually if I need speed I've
reached for Inline::Pdlpp. (And to be fair, I should add an Inline::Pdlpp
solution.) In most other cases I had assumed that PDL would still be fairly
performant, however, in cases where calculations only need to proceed on a
subset of the data. These benchmarks seem to indicate that my assumption
was wrong.
I'd be happy to get any feedback on the benchmark code. In particular, if
anybody can think of a way to speed things up, I'd like to know. I think it
would be useful for all of us to know if there is a trick to getting PDL to
crunch this calculation efficiently, or if this really is best solved using
Inline::Pdlpp.
David
On Tue, Apr 26, 2016 at 4:01 PM, Chris Marshall <[email protected]>
wrote:
> Hi David
>
> I tried to add this comment to your post on blogs.perl.org but there
> seems to be something wrong with the site, my browser cookies, whatever I
> cannot submit. Here it is via e-mail. We still have the PDL mailing lists
> (http://pdl.perl.org/?page=mailing-lists) for general or specific PDL
> discussion. Hope things are well.
>
> --Chris
>
> Hi David, nice to see work again on C::Blocks. The mandelbrot algorithm
>> is likely a pathological case for PDL-2.015 for a number of reasons:
>>
>> (1) PDL computations are basically memory to memory without things like
>> register operations and often the cache is broken for large data,
>>
>> (2) even the optimized algorithms appear to have a large number of PDL
>> creation operations---very expensive,
>>
>> (3) PDL can be very efficient in compute and memory for *uniform*
>> computations but here the memory breaks the cache and introduces page
>> faults.
>>
>> One way to get comparable performance with the current PDL implementation
>> is pretty much the same way you've done in C::Blocks---implement a tight
>> loop that is operation and memory efficient. (Hint: See the documentation
>> for PDL::PP)
>>
>>
>
--
"Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are,
by definition, not smart enough to debug it." -- Brian Kernighan
------------------------------------------------------------------------------
Find and fix application performance issues faster with Applications Manager
Applications Manager provides deep performance insights into multiple tiers of
your business applications. It resolves application problems quickly and
reduces your MTTR. Get your free trial!
https://ad.doubleclick.net/ddm/clk/302982198;130105516;z
_______________________________________________
pdl-general mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/pdl-general
