__restrict, architecture intrinsics vs asm, consoles, and other stuff

[Manu]

On 24 September 2011 15:37, Iain Buclaw <ibuclaw at ubuntu.com> wrote:

> == Quote from Manu Evans (turkeyman at gmail.com)'s article
> > > > How can I do this in a nice way in D? I'm long sick of writing
> > > > unsightly vector classes in C++, but fortunately using vendor
> > > > specific compiler intrinsics usually leads to decent code
> > > > generation. I can currently imagine an equally ugly (possibly worse)
> > > > hardware vector library in D, if it's even possible. But perhaps
> > > > I've missed something here?
> > > Your C++ vector code should be amenable to translation to D, so that
> effort of
> > > yours isn't lost, except that it'd have to be in inline asm rather than
> intrinsics.
> > But sadly, in that case, it wouldn't work. Without an intrinsic hardware
> vector
> type, there's
> > no way to pass vectors to functions in registers, and also, using
> explicit asm,
> you tend to
> > end up with endless unnecessary loads and stores, and potentially a lot
> of redundant
> > shuffling/permutation. This will differ radically between architectures
> too.
> > I think I read in another post too that functions containing inline asm
> will not
> be inlined?
> > How does the D compiler go at optimising code around inline asm blocks?
> Most
> compilers have a
> > lot of trouble optimising around inline asm blocks, and many don't even
> attempt
> to do so...
> > How does GDC compare to DMD? Does it do a good job?
> > I really need to take the weekend and do a lot of experiments I think.
>
> GDC is just the same as DMD (same runtime library implementation for vector
> array
> operations).
>
>
> You can define vector types in the language through use of GCC's attribute
> though
> (is a pragma in GDC), then use a union to interface between it and the
> corresponding static array.  It's deliberately UGLY and PRONE to you
> hitting lots
> of brick walls if you don't handle them in a very specific way though. :~)
>
> Stock example:
>
> pragma(attribute, vector_size())
>  typedef float __v4sf_t
>
> union __v4sf {
>  float[4] f;
>  __v4sf_t v;
> }
>
>
> __v4sf a = {[1,2,3,4]}
>       b = {[1,2,3,4]}
>       c;
>
> c.v = a.v + b.v;
> assert(c.f == [2,4,6,8]);
>
>
> The assignment compiles down to ~5 instructions:
> movaps -0x88(%ebp),%xmm1
> movaps -0x78(%ebp),%xmm0
> addps  %xmm1,%xmm0
> movaps %xmm0,-0x68(%ebp)
> flds   -0x68(%ebp)
>
> And is far quicker than c[] = a[] + b[] due to it being inlined, and not an
> external library call.
>
> Regards
> Iain
>

Nice!
Is there an IRC channel, or anywhere for realtime D discussion?
I'm interested in trying to build some GDC cross compilers, and perhaps
contributing to the standard library on a few embedded systems, but I have a
lot of little questions and general things that don't suit a mailing list...
Perhaps some IM? It seems to me that you are the authority on GDC
implementation and support...
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20110924/0bae3add/attachment.html>