GNU C++ SSE PROBLEM

Vertex Matrix::operator * (const Vertex &v) const
{
Vertex r;

__asm__ volatile
(
"movss (%[v]), %%xmm0 \n\t"
"shufps $0, %%xmm0, %%xmm0 \n\t"
"movss 4(%[v]), %%xmm1 \n\t"
"mulps (%[m]), %%xmm0 \n\t"
"shufps $1, %%xmm1, %%xmm1 \n\t"
"movss 8(%[v]), %%xmm2 \n\t"
"mulps 16(%[m]), %%xmm1 \n\t"
"shufps $0, %%xmm2, %%xmm2 \n\t"
"movss 12(%[v]), %%xmm3 \n\t"
"mulps 32(%[m]), %%xmm2 \n\t"
"shufps $0, %%xmm3, %%xmm3 \n\t"
"addps %%xmm1, %%xmm0 \n\t"
"mulps 48(%[m]), %%xmm3 \n\t"
"addps %%xmm3, %%xmm2 \n\t"
"addps %%xmm2, %%xmm0 \n\t"
"movups %%xmm0, (%[r]) \n\t"
"movw $1, 12(%[r]) \n\t" : [r] "=mr" (r) : [v] "mr" (&v), [m] "mr" (this) : "xmm0", "xmm1", "xmm2", "xmm3"
);
return r;
}

javi mi napako:
/tmp/cc8bu4Jt.s: Assembler messages:
/tmp/cc8bu4Jt.s:151: Error: register value used as expression
/tmp/cc8bu4Jt.s:152: Error: junk `((%edi))' after expression

to sta sigurno zadnji dve vrstici assemblerske kode...
ce ju zakomentiram mi dela, samo potem vseeno kreshne...

prej sm mel mal drugac narjen, pa mi je pravilno delal, zracunal vse uredu, sam je po nekaj zracunanih mnozenj prislo do seg. fault-a...
mogoce kdo vid se kksno napako?

bojan

Vse skupaj bi lahko napisal kot:

...
"movups %%xmm0, (%[r]) \n\t"
"movw $1, 12(%[r]) \n\t"
: [r] "=mr" (r)
: [v] "mr" (&v), [m] "mr" (this)
: "xmm0", "xmm1", "xmm2", "xmm3"

Te zadnje tri vrstice niso assembler, ampak output, input
in clobber list (po domace kaj vracas, kaj je zate input in
kaj vse si spremenil).
Torej tisti xmm0 - xmm3 so tam ker si dejansko te registre spremenil
in moras to gcc-ju povedati (da jih ne uporabi ze on v kaksni optimizaciji).
: [r] "=mr" (r) - tole pomeni r je alias za izhodno spremenljivko
r, ki je bodisi v registru procesorja ali nekje v pomnilniku.

: [v] "mr" (&v), [m] "mr" (this)
vhodi so pa v kakor poimenujes &v in this, ki mu pravis m.
(As of GCC version 3.1, one may write [name] instead of the operand number for a matching constraint.)

Ko imas v kodi recimo
"mulps 32(%[m]), %%xmm2 \n\t"

to potem pomeni "mulps 32(this), %xmm2".

%edi je pac nek register, ki ga izbere gcc zaradi "r".

Bolj bi pomgalo ce bi tocno vedel v kateri vrstici dobis napako, se mi pa zdi cudno, da je r
kvazi izhod, ko pa nikjer ne pises v r, ampak samo na naslov kamor kaze r in neke odmike od tega.

__asm__ volatile
(
"movups (%[m]), %%xmm4 \n\t"
"movups 16(%[m]), %%xmm5 \n\t"
"movups 32(%[m]), %%xmm6 \n\t"
"movups 48(%[m]), %%xmm7 \n\t"
"movss (%[v]), %%xmm0 \n\t"
"shufps $0, %%xmm0, %%xmm0 \n\t"
"movss 4(%[v]), %%xmm1 \n\t"
"mulps %%xmm4, %%xmm0 \n\t"
"shufps $1, %%xmm1, %%xmm1 \n\t"
"movss 8(%[v]), %%xmm2 \n\t"
"mulps %%xmm5, %%xmm1 \n\t"
"shufps $0, %%xmm2, %%xmm2 \n\t"
"movss 12(%[v]), %%xmm3 \n\t"
"mulps %%xmm6, %%xmm2 \n\t"
"shufps $0, %%xmm3, %%xmm3 \n\t"
"addps %%xmm1, %%xmm0 \n\t"
"mulps %%xmm7, %%xmm3 \n\t"
"addps %%xmm3, %%xmm2 \n\t"
"addps %%xmm2, %%xmm0 \n\t"
"movups %%xmm0, (%[r]) \n\t"
"movw $1, 12(%[r]) \n\t"
:
: [r] "mr" (&r), [v] "mr" (&v), [m] "mr" (this)
: "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
);

no za 1x, sm kr nalozu najprej vse vrstice matrik v xmm registre pa pol rajs mnozil z njimi..
pa zdej dela ok, bom se pol optimizeru za hitrost :)

bojan

sm pa stestiru funkcijo pa je blazno pocasna:) ma kdo kksn predlog za pohitritev, razno da dam movups v movaps...

bojan

Bemti... Pol ure gledam kodo in mi ni jasno kako hudiča sploh kar koli dela in potem preberem na netu da ima GCC drugačen vrstni red operandov kot Intel ASM.
Drgač pa:
-četrtega množenja ne rabiš, samo add
-namesto da "v" nalagaš vsakič posebej po en skalar spravi cel "v" v recimo xmm0 in potem prestavlji in shuffli v xmm1 recimo
To je pa se mi zdi vse kar se da še naredit.

se brez odvecnega mnozenja (ob prepostavki da je 4 element vektorja 1):

__asm__ volatile
(
"movups (%[v]), %%xmm0 \n\t"
"movaps %%xmm0,%%xmm2 \n\t"
"movaps %%xmm0,%%xmm1 \n\t"
"shufps $0x00, %%xmm0, %%xmm0 \n\t"
"shufps $0xaa, %%xmm1, %%xmm1 \n\t"
"shufps $0x55, %%xmm2, %%xmm2 \n\t"
"mulps 0(%[m]), %%xmm0 \n\t"
"mulps 16(%[m]), %%xmm1 \n\t"
"mulps 32(%[m]), %%xmm2 \n\t"
"movaps 48(%[m]), %%xmm3 \n\t"
"addps %%xmm1, %%xmm0 \n\t"
"addps %%xmm3, %%xmm2 \n\t"
"addps %%xmm2, %%xmm0 \n\t"
"movaps %%xmm0, (%[r]) \n\t"
"movl $0x3f800000, 12(%[r]) \n\t"
:
: [r] "mr" (&r), [v] "mr" (&v), [m] "mr" (&mr)
: "xmm0", "xmm1", "xmm2", "xmm3"
);

To je to, hitrejše pa ne bo šlo, razen če je še kakšen catch z input dekleracijami (in pa pshufd kot si že ugotovil).

Je pa tko, če rabiš cel kup vektorjev transformirat (kjer se take zadeve itak največ poznajo) z eno matriko, se da to tudi lepo optimizirat.

Če imaš eno matriko in N vertexov (kar je običajno; no odvisno kaj točno počneš) lahko izkoristiš to dejstvo in ne nalagaš matrike vsakič posebej.
Link kjer je par primerov točno tega, kar ti počneš.