Re: [boost] Accelerating algorithms with SIMD - Segmented iterators and alternatives

Subject: Re: [boost] Accelerating algorithms with SIMD - Segmented iterators and alternatives
From: Mathias Gaunard (mathias.gaunard_at_[hidden])
Date: 2010-10-11 19:53:53

On 11/10/2010 23:34, Simonson, Lucanus J wrote:

> Have you seen the ct thing coming from Intel?  I just learned about it last week.
>
> http://software.intel.com/en-us/articles/intel-array-building-blocks/

I haven't had a chance to look at it myself, but I've heard this is 
based on Rapidmind.
I would say NT2 is quite comparable to that product, albeit, since NT2 
is a public research project that doesn't have the full backing of 
Intel, it is probably inferior in some aspects, while still having good 
original ideas too.

We are however only looking at submitting the SIMD part to Boost, rather 
than the whole of NT2 that does also threads, MPI, matrices, vectors, 
numerical stuff, etc.

I believe it is important to be able to isolate and decouple components 
as much as possible; and I can indeed think of quite of few applications 
where I would want to use SIMD but not the whole artillery of different 
parallel technologies and making my application depend on a big runtime 
that does a lot behind the scenes.
Being able to use it non-intrusively with my own types, or extend it as 
needed, is a plus too.

So for now, for Boost, we're just looking at providing nice ways to help 
the programmer organize its code around packs of data (also known as 
vectors, but for various reasons we prefer to use a different name), 
each pack being the size of a SIMD register, and ensuring that code can 
then generate efficient SIMD code.

>
> It looks like a container library for vector processing in C++ with a JIT compilation runtime environment as part of the library.  As a guy who appreciates compilers, langauges and libraries there is a lot to like there.  This area is evolving very fast.

An interesting area to look into indeed.

We have a few compilation-related projects around NT2 (some using Proto, 
some using an actual compiler) where we optimize array programming, but 
none using a JIT.

NT2 does all its fine tuning (including for size of cache etc.) at 
compile-time, so it cannot adapt as well for different CPUs without a 
recompilation.