przegladam jedna stronke i tam jest napisane



Żeby jednak w 100% wykorzystać moc obliczeniową, należy liczyć równocześnie 4
iloczyny skalarne.

sse-dotprod4.c:


void sse_dot4(float* v1x4, float* v2x4, float* results) {
__asm__ volatile (
// load 4 vectors from v1
"movups (%0), %%xmm0 \n"
"movups 16(%0), %%xmm1 \n"
"movups 32(%0), %%xmm2 \n"
"movups 48(%0), %%xmm3 \n"

// load 4 vectors from v2
"movups (%1), %%xmm4 \n"
"movups 16(%1), %%xmm5 \n"
"movups 32(%1), %%xmm6 \n"
"movups 48(%1), %%xmm7 \n"

// perfom parallel multiplications
"mulps %%xmm4, %%xmm0 \n" // xmm0 := |A3|A2|A1|A0|
"mulps %%xmm5, %%xmm1 \n" // xmm1 := |B3|B2|B1|B0|
"mulps %%xmm6, %%xmm2 \n" // xmm2 := |C3|C2|C1|C0|
"mulps %%xmm7, %%xmm3 \n" // xmm3 := |D3|D2|D1|D0|
// (xmm4-xmm7 are free)

// perfom additions
"movaps %%xmm0, %%xmm4 \n"
"unpcklps %%xmm1, %%xmm0 \n" // xmm0 := |B1|A1|B0|A0|
"unpckhps %%xmm1, %%xmm4 \n" // xmm4 := |B3|A3|B2|A2| (xmm1 is free)
"movaps %%xmm2, %%xmm1 \n"
"unpcklps %%xmm3, %%xmm2 \n" // xmm2 := |D1|C1|D0|C0|
"unpckhps %%xmm3, %%xmm1 \n" // xmm1 := |D3|C3|D2|C2| (xmm3 is free)
"addps %%xmm4, %%xmm0 \n" // xmm0 := | B13 | A13 | B02 | A02 | (xmm1 is
free)
"addps %%xmm1, %%xmm2 \n" // xmm2 := | D13 | C13 | D02 | C02 | (xmm3 is free)

"movaps %%xmm0, %%xmm1 \n"
"shufps $0b01000100, %%xmm2, %%xmm0 \n" // xmm0 := | D02 | C02 | B02 | A02 |
"shufps $0b11101110, %%xmm2, %%xmm1 \n" // xmm1 := | D13 | C13 | B13 | A13 |
"addps %%xmm1, %%xmm0 \n" // xmm0 := |D0123|C0123|B0123|A0123|
"movups %%xmm0, (%2) \n"
:
: "r" (v1x4), "r" (v2x4), "r" (results)
);
}

przez pare dobrych minut ne moglem pojac czemu to jest tak napisane gdy zwykle
pionowe sse moze sie spokojnie obejsc tutaj bez szufli

xxxx
yyyy
zzzz
XXXX
YYYY
ZZZZ
|
v
x*X+y*Y+z*Z

i mz bedzie to raczej chyba szybsze ze wzgledu na to ze 1) nie uzywa szufli
2) wogole operuje na mniejszej liczbie bajtów.. ta wersja wyzej jak rozumiem
mnozy wektory 4D a czesciej przydatne sa 3D do tego pytanie czemu az czetry na raz,
jesli to jest wlasciwie pozioma wersja to czmu np 4 a nie 2 albo 5? - akurat
rejestrow starczylo na 4?

z drugiej strony rozumiem ze taka pozioma wersja ma zalety co do tego poziomego
rozkladu wektorow

drugie pytanie czy taki sposob pisania zagwarantuje jakis standardowy prolog i epilog
takiej funkcji? (tj bez jakichs zmuleń) i co to jest -
: "r" (v1x4), "r" (v2x4), "r" (results)
?

czy jest to asm pod gcc? (w sumie po przyzwyczajeniu sie nie jest gorszy od
tego starego - jest chyba nawet lepszy pominawszy odwrocona kolejnosc)

do góry

> __asm__ volatile (
> // load 4 vectors from v1
> "movups (%0), %%xmm0 \n"

taka teraz moda, czy zabrałeś się od dupy strony?
P.S. ja się nie znam... tak twierdzi tusk i gronkiewicz...

do góry

W dniu 05.07.2014 17:49, feldmarszałek tusk pisze:
>> __asm__ volatile (
>> // load 4 vectors from v1
>> "movups (%0), %%xmm0 \n"
>
> taka teraz moda, czy zabrałeś się od dupy strony?
> P.S. ja się nie znam... tak twierdzi tusk i gronkiewicz...

To która strona jest właściwa i czy została już zaaprobowana przez Unię
Europejską?

do góry

wogole wlasnie ta forma z tymi 'końcówkami' (nawet nie wiem jak to nazwac) dla inline
assembly w gcc wydaje mi sie w sumie fatalna

co to ma byc

void sse_dot(float vec1[4], float vec2[4], float* result) {
__asm__ volatile (
"movups (%0), %%xmm0 \n" // load vec1: |w1|z1|y1|x1|
"movups (%1), %%xmm1 \n" // load vec2: |w2|z2|y2|x2|
" \n"
"mulps %%xmm1, %%xmm0 \n" // xmm0 := |w1*w2|z1*z2|y1*y2|x1*x2|
"movhlps %%xmm0, %%xmm1 \n" // xmm1 := | . | . |w1*w2|z1*z2|
"addps %%xmm0, %%xmm1 \n" // xmm1 := | . | . | w+y | z+x |
"movaps %%xmm1, %%xmm0 \n" // save xmm1
"shufps $0x01, %%xmm1, %%xmm1 \n" // xmm1 := | . | . | . | w+y |
"addss %%xmm1, %%xmm0 \n" // xmm0[0] := dot product
"movss %%xmm0, (%2) \n"
:
: "r" (vec1), "r" (vec2), "r" (result));
}

juz o wiele lepiej wyglada tow czystym asmie
przynajmniej wszystko jasne


Dump of assembler code for function sse_dot(float*, float*, float*):
0x000000a0 <+0>: mov 0xc(%esp),%ecx
0x000000a4 <+4>: mov 0x8(%esp),%edx
0x000000a8 <+8>: mov 0x4(%esp),%eax
0x000000ac <+12>: movups (%eax),%xmm0
0x000000af <+15>: movups (%edx),%xmm1
0x000000b2 <+18>: mulps %xmm1,%xmm0
0x000000b5 <+21>: movhlps %xmm0,%xmm1
0x000000b8 <+24>: addps %xmm0,%xmm1
0x000000bb <+27>: movaps %xmm1,%xmm0
0x000000be <+30>: shufps $0x1,%xmm1,%xmm1
0x000000c2 <+34>: addss %xmm1,%xmm0
0x000000c6 <+38>: movss %xmm0,(%ecx)
0x000000ca <+42>: ret
End of assembler dump.

aczkolwiek ani jedna ani druga (czyli ta ms vs gcc) skladnia mi sie nie podoba i
wolalbym uzywac jakiejs swojej o wiele lepszej

// function sse_dot(float*, float*, float*)

mov ecx (!c)
mov edx (!8)
mov eax (!4)
mov-u-ps x0 eax
mov-u-ps x1 edx
mul-ps x0 x1
mov-hl-ps x1 x0
add-ps x1 x0
mov-a-ps x0 x1
shuf-ps x1 x1 1
add-ss x0 x1
mov-ss (ecx) x0
ret

tj nawrzucalbym troche skrótów np (!c) dla trzeciego inta na stosie itd - byloby
ladniej

(niestety nie chce mi sie pisac asemblera, te tabele rozkazow sa za dlugie) - szkoda
ze nie mam tyle kasy zeby komus zaplacic za napisanie tego , ciekawe ile musialbym
wybulic za taki skromny ale dzialajacy asembler, nie jest to az tak duzo roboty w
miesiac chyba mozna by sie uwinąć

do góry

ja się podobno nie znam, ale dlaczego wymyślono coś takiego jak inline
asm? to po to, żeby eksperci na tej grupie mogli się popisywać głupotą?

nie dało by się napisać procedury w oddzielnym pliku assemblerowym? nie
czaję geniuszu tego inlina...

do góry

nie czaję też, dlaczego nie nie można mieszać kodu asm z c, przerosło to
teleinformatyków współtworzących społecznościowo gcc? a może jakaś
dyrektywa była?

do góry

a za tego inlina to na pewno granty się posypały...

do góry

> (niestety nie chce mi sie pisac asemblera, te tabele rozkazow sa za
> dlugie) - szkoda ze nie mam tyle kasy zeby komus zaplacic za
> napisanie tego , ciekawe ile musialbym wybulic za taki skromny ale
> dzialajacy asembler, nie jest to az tak duzo roboty w miesiac chyba
> mozna by sie uwinąć

za 15-20k pln mogę Ci taki napisać. Jeśli jesteś zainteresowany, to
podaj dokładniejszą specyfikację wymagań.

--
Pozdrawiam,
Stregor

do góry

i co znajdują się jakieś powskie głupki które dają się na to nabrać?

do góry

Dnia Mon, 07 Jul 2014 17:16:45 +0200, feldmarszałek tusk napisał(a):

> i co znajdują się jakieś powskie głupki które dają się na to nabrać?

Pisowcy programuja za free?

--
pozdro
R.e.m.e.K

do góry