slabo znam sse (chyba z powodu tego ze nie ma dobrych
tutoriali) ale z tego co sie poorientowalem to dziwi
mnie pare rzeczy:

oprocz zestawu podstawowych operatorow typu +-*/&!<> itp
sa tam zdefiniowane jakies bardziej wyjechane operacje
ale zdaje sie ze nie ma kilku operacji sie wyraznie
narzucajacych (szczegolnie dla float4): dot, cross, pozatym
nie ma tez sie mz narzucajacego przeliczenia liczby
zespolonej postaci a-b na modul-faza, pozatym
nie ma tam chyba prostego przerzucania dowolnego floata
z wektora do np eax, inne pytanie dotyczy np
kwestii zrobienia na sse/avx np liczenia zbioru
mandelbrota, poczatek gdy zaden z iterowanych 'punktow'
(moze powinienem uzyc raczej slowa liczba) nie ucieka
mozna zrobic zdaje mi sie ok w prosty sposob

int iterPointTilescape(double4 pointReal, double4 pointImaginary)
{

double4 real = pointReal,
imaginary = pointImaginary,
nextReal ,
nextImaginary ,
pointModule ,
pointPhase ; // phase unused

int iterCount = 1;

for(;;)
{
pointModule = real*real + imaginary*imaginary;

if(max(pointModule)>=4.0) return iterCount; /// (***)

iterCount++;

nextReal = real*real - imaginary*imaginary + pointReal;

nextImaginary = 2*real*imaginary + pointImaginary;

real = nextReal;
imaginary = nextImaginary;
}

}


ale co gdy ktorys pojedynczy ucieka (***) - nalezy wtedy
dokonczyc na skalarach ?









--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@g...SKASUJ-TO.pl> napisał(a):
> int iterPointTilescape(double4 pointReal, double4 pointImaginary)
Co to jest double4?
Pozdrawiam


--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> <f...@g...SKASUJ-TO.pl> napisał(a):
> > int iterPointTilescape(double4 pointReal, double4 pointImaginary)
> Co to jest double4?
> Pozdrawiam
>
>

tutaj jest to

"4 x 64 bity - wektor 4 liczb zmiennoprzecinkowych
podwójnej precyzji"

jeden z 'typow danych' na jakich operuja instrukcje sse (avx)

proponuje wbudowac taki typ jako dodatkowy akcelerowany
typ prosty w c (jako rozszerzenie specyficzne dla x86)
- w tedy mozna by pisac w ce w prosty sposob akcelerowane
kody pod sse/avx np "c = a * b " pomnoz 8 floatow a razy 8
floatow b i zapisz do c i tak dalej - wiecej napisalem na
pl.lang.c (akurat jestem zmeczony - mala imprezka dzisiaj,
ale jek odpoczne to pewnie bede dalej 'opracowywac' temat)







--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@W...gazeta.pl> napisał(a):

> M.M. <m...@W...gazeta.pl> napisał(a):
>
> > <f...@g...SKASUJ-TO.pl> napisał(a):
> > > int iterPointTilescape(double4 pointReal, double4 pointImaginary)
> > Co to jest double4?
> > Pozdrawiam
> >
> >
>
> tutaj jest to
>
> "4 x 64 bity - wektor 4 liczb zmiennoprzecinkowych
> podwójnej precyzji"
>
> jeden z 'typow danych' na jakich operuja instrukcje sse (avx)
>
> proponuje wbudowac taki typ jako dodatkowy akcelerowany
> typ prosty w c (jako rozszerzenie specyficzne dla x86)
> - w tedy mozna by pisac w ce w prosty sposob akcelerowane
> kody pod sse/avx np "c = a * b " pomnoz 8 floatow a razy 8
> floatow b i zapisz do c i tak dalej - wiecej napisalem na
> pl.lang.c
Hmmm jeszcze dwa pytania mi sie nasuwaja:

Po pierwsze czy w C++ nie ma czegos gotowego ze sie pisze
po prostu a = b * c ?

Po drugie czy instrukcje SEE/AVX da sie wykorzystac do budowania
drzew/regul decyzyjnych? Innymi slowy czy da sie przyspieszyc ponizsza
pteleke, tak zeby jakos bral cztery/osiem wektorow na raz?

int_or_short vectors[M][N+1] = { rand() };
int_or_short s = rand()%N;
int_or_short t = rand();

for( int i=0 ; i<M ; i++ ) {
if( vectors[i][s] <= t )
vectors[i][N] = 1;
else
vectors[i][N] = 0;
}

Pozdrawiam










--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> <f...@W...gazeta.pl> napisał(a):
>
> > M.M. <m...@W...gazeta.pl> napisał(a):
> >
> > > <f...@g...SKASUJ-TO.pl> napisał(a):
> > > > int iterPointTilescape(double4 pointReal, double4 pointImaginary)
> > > Co to jest double4?
> > > Pozdrawiam
> > >
> > >
> >
> > tutaj jest to
> >
> > "4 x 64 bity - wektor 4 liczb zmiennoprzecinkowych
> > podwójnej precyzji"
> >
> > jeden z 'typow danych' na jakich operuja instrukcje sse (avx)
> >
> > proponuje wbudowac taki typ jako dodatkowy akcelerowany
> > typ prosty w c (jako rozszerzenie specyficzne dla x86)
> > - w tedy mozna by pisac w ce w prosty sposob akcelerowane
> > kody pod sse/avx np "c = a * b " pomnoz 8 floatow a razy 8
> > floatow b i zapisz do c i tak dalej - wiecej napisalem na
> > pl.lang.c
> Hmmm jeszcze dwa pytania mi sie nasuwaja:
>
> Po pierwsze czy w C++ nie ma czegos gotowego ze sie pisze
> po prostu a = b * c ?
>
> Po drugie czy instrukcje SEE/AVX da sie wykorzystac do budowania
> drzew/regul decyzyjnych? Innymi slowy czy da sie przyspieszyc ponizsza
> pteleke, tak zeby jakos bral cztery/osiem wektorow na raz?
>
> int_or_short vectors[M][N+1] = { rand() };
> int_or_short s = rand()%N;
> int_or_short t = rand();
>
> for( int i=0 ; i<M ; i++ ) {
> if( vectors[i][s] <= t )
> vectors[i][N] = 1;
> else
> vectors[i][N] = 0;
> }
>
troche nie rozumiem tego kodu bo o ile randy sa poza
petla to mozna po prostu zrobic

for( int i=0 ; i<M ; i++ )
sseInt8[i] = value;

gdzie value - np { 0.0, 0.0, 0.0 ,0.0 ,0.0 ,1.0 ,1.0 ,1.0}

co do instrukcji do rozgalezien decyzyjnych
to nie wiem jak na dzis ale chyba nie - sa blokowy
operator porownania ktore zapisuja wyniki do rejestru
cos w stylu a ?> b jesli a jest 8floatowe to dla tych
par floatow dla ktorych a>b do a trafiaja 32 jedynki
a w przeciwnym wypadku 32 zera
(ale nie przejrzalem mnemonikow do konca)

jak budowac z tego kody ktore by sie rozgalezialy
decyzyjnie nie wiem, dla mnie jest to rzecz 'do
opanowania' trzebe sie bedzie przylozyc to
okaze sie co sie da zrobic i gdzie sa minusy



--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@W...gazeta.pl> napisał(a):

> M.M. <m...@W...gazeta.pl> napisał(a):
>
> > <f...@W...gazeta.pl> napisał(a):
> >
> > > M.M. <m...@W...gazeta.pl> napisał(a):
> > >
> > > > <f...@g...SKASUJ-TO.pl> napisał(a):
> > > > > int iterPointTilescape(double4 pointReal, double4 pointImaginary)
> > > > Co to jest double4?
> > > > Pozdrawiam
> > > >
> > > >
> > >
> > > tutaj jest to
> > >
> > > "4 x 64 bity - wektor 4 liczb zmiennoprzecinkowych
> > > podwójnej precyzji"
> > >
> > > jeden z 'typow danych' na jakich operuja instrukcje sse (avx)
> > >
> > > proponuje wbudowac taki typ jako dodatkowy akcelerowany
> > > typ prosty w c (jako rozszerzenie specyficzne dla x86)
> > > - w tedy mozna by pisac w ce w prosty sposob akcelerowane
> > > kody pod sse/avx np "c = a * b " pomnoz 8 floatow a razy 8
> > > floatow b i zapisz do c i tak dalej - wiecej napisalem na
> > > pl.lang.c
> > Hmmm jeszcze dwa pytania mi sie nasuwaja:
> >
> > Po pierwsze czy w C++ nie ma czegos gotowego ze sie pisze
> > po prostu a = b * c ?
> >
> > Po drugie czy instrukcje SEE/AVX da sie wykorzystac do budowania
> > drzew/regul decyzyjnych? Innymi slowy czy da sie przyspieszyc ponizsza
> > pteleke, tak zeby jakos bral cztery/osiem wektorow na raz?
> >
> > int_or_short vectors[M][N+1] = { rand() };
> > int_or_short s = rand()%N;
> > int_or_short t = rand();
> >
> > for( int i=0 ; i<M ; i++ ) {
> > if( vectors[i][s] <= t )
> > vectors[i][N] = 1;
> > else
> > vectors[i][N] = 0;
> > }
> >
> troche nie rozumiem tego kodu bo o ile randy sa poza
> petla to mozna po prostu zrobic
>
> for( int i=0 ; i<M ; i++ )
> sseInt8[i] = value;
>

to troche zakrawa na przyblizenie, ale mozna
tak postrzegac czesc operacji np przerzutowanie
tablicy floatow na tablice ssefloat8 i liczenie
osmiu operacji arytmetycznych na raz

z tymi branchami jest problem, wogole jest problem
pt "jak dostosowac sse do przyspieszania jak najwiekszej
ilosci przypadkow intensywnych obliczen w petlach"
(niektorzy nazywaja takie miejsca chyba goracymi petlami
ale to okreslenie mi nie bardzo pasuje, slowko intensywne
tez nie jest calkiem dobre)

dla mnie sa to ciekawe tematy, obok wielopotokowosci
to jest drugi sposob zwiekszenia mocy przetwarzania
rdzenia











> gdzie value - np { 0.0, 0.0, 0.0 ,0.0 ,0.0 ,1.0 ,1.0 ,1.0}
>
> co do instrukcji do rozgalezien decyzyjnych
> to nie wiem jak na dzis ale chyba nie - sa blokowy
> operator porownania ktore zapisuja wyniki do rejestru
> cos w stylu a ?> b jesli a jest 8floatowe to dla tych
> par floatow dla ktorych a>b do a trafiaja 32 jedynki
> a w przeciwnym wypadku 32 zera
> (ale nie przejrzalem mnemonikow do konca)
>
> jak budowac z tego kody ktore by sie rozgalezialy
> decyzyjnie nie wiem, dla mnie jest to rzecz 'do
> opanowania' trzebe sie bedzie przylozyc to
> okaze sie co sie da zrobic i gdzie sa minusy
>
>
>


--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@g...SKASUJ-TO.pl> napisał(a):

> slabo znam sse (chyba z powodu tego ze nie ma dobrych
> tutoriali) ale z tego co sie poorientowalem to dziwi
> mnie pare rzeczy:
>
> oprocz zestawu podstawowych operatorow typu +-*/&!<> itp
> sa tam zdefiniowane jakies bardziej wyjechane operacje
> ale zdaje sie ze nie ma kilku operacji sie wyraznie
> narzucajacych (szczegolnie dla float4): dot, cross, pozatym

tez length i normalize, raytracery itp by przyspieszyly
pozatym te 'horyzentalne' operacje mozy by sie przydaly

fajny jest ten asm, cos innego niz c jednak w pewnym sensie
lepszy feeling, od razu mi sie humor porawil







--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

<f...@W...gazeta.pl> napisał(a):
> to troche zakrawa na przyblizenie, ale mozna
> tak postrzegac czesc operacji np przerzutowanie
> tablicy floatow na tablice ssefloat8 i liczenie
> osmiu operacji arytmetycznych na raz
>
> z tymi branchami jest problem, wogole jest problem
> pt "jak dostosowac sse do przyspieszania jak najwiekszej
> ilosci przypadkow intensywnych obliczen w petlach"
> (niektorzy nazywaja takie miejsca chyba goracymi petlami
> ale to okreslenie mi nie bardzo pasuje, slowko intensywne
> tez nie jest calkiem dobre)
>
> dla mnie sa to ciekawe tematy, obok wielopotokowosci
> to jest drugi sposob zwiekszenia mocy przetwarzania
> rdzenia

No wlasnie musze przyspieszyc program, a czasu na testowanie
kolejnych rozwiazan nie mam.

Jesli przetransponuje macierz danych, to na uproszczonym tescie
juz zyskuje 10krotne przyspieszenie.
Cos w rodzaju:
for( i=0 ; i<N ; i++ )
for( j=0 ; j<M ; j++ )
operacje( dane[i][j] )
VS
for( j=0 ; j<M ; j++ )
for( i=0 ; i<N ; i++ )
operacje( dane[i][j] )

Do tego pidzial na watki i na 6 rdzeniach powinno byc 60 razy szybciej.
Niestety to nadal troche za malo.

A jest może coś takiego w SSE, żeby porównał cztery int32 upakowane do
jednego int128 i zwrócił inta z ustawionymi albo wyzerowanymi czterema
najmlodszymi bitami?

Mysle nad czyms takim:

int dane[N] = { wprowadza uzytkownik };
int test[4] = { 5 , 5 , 5 , 5 };

for( int i=0 ; i<N ; i+4 ) {
switch( mniejsze_lub_rowne( dane+i , test ) ) {
case 0: break;
case 1: break;
..............
case 15:
}
}

Wtedy bylby jeden skok pod wyspecjalizowany kod dla kazdego przypadku.

Pozdrawiam

P.S.
Wlasnie w takich przypadkach by sie przydala pragma do poinformowania
kompilatora ze funkcja mniejsze_lub_rowne zwraca liczbe z zakresu
od 0 do 15 i kompilator nie musi generowac zadnego kodu do omijania
switcha.









--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry

M.M. <m...@W...gazeta.pl> napisał(a):

> <f...@W...gazeta.pl> napisał(a):
> > to troche zakrawa na przyblizenie, ale mozna
> > tak postrzegac czesc operacji np przerzutowanie
> > tablicy floatow na tablice ssefloat8 i liczenie
> > osmiu operacji arytmetycznych na raz
> >
> > z tymi branchami jest problem, wogole jest problem
> > pt "jak dostosowac sse do przyspieszania jak najwiekszej
> > ilosci przypadkow intensywnych obliczen w petlach"
> > (niektorzy nazywaja takie miejsca chyba goracymi petlami
> > ale to okreslenie mi nie bardzo pasuje, slowko intensywne
> > tez nie jest calkiem dobre)
> >
> > dla mnie sa to ciekawe tematy, obok wielopotokowosci
> > to jest drugi sposob zwiekszenia mocy przetwarzania
> > rdzenia
>
> No wlasnie musze przyspieszyc program, a czasu na testowanie
> kolejnych rozwiazan nie mam.
>
> Jesli przetransponuje macierz danych, to na uproszczonym tescie
> juz zyskuje 10krotne przyspieszenie.
> Cos w rodzaju:
> for( i=0 ; i<N ; i++ )
> for( j=0 ; j<M ; j++ )
> operacje( dane[i][j] )
> VS
> for( j=0 ; j<M ; j++ )
> for( i=0 ; i<N ; i++ )
> operacje( dane[i][j] )
>
> Do tego pidzial na watki i na 6 rdzeniach powinno byc 60 razy szybciej.
> Niestety to nadal troche za malo.
>
> A jest może coś takiego w SSE, żeby porównał cztery int32 upakowane do
> jednego int128 i zwrócił inta z ustawionymi albo wyzerowanymi czterema
> najmlodszymi bitami?
>
> Mysle nad czyms takim:
>
> int dane[N] = { wprowadza uzytkownik };
> int test[4] = { 5 , 5 , 5 , 5 };
>
> for( int i=0 ; i<N ; i+4 ) {
> switch( mniejsze_lub_rowne( dane+i , test ) ) {
> case 0: break;
> case 1: break;
> ..............
> case 15:
> }
> }
>
> Wtedy bylby jeden skok pod wyspecjalizowany kod dla kazdego przypadku.
>
> Pozdrawiam
>
> P.S.
> Wlasnie w takich przypadkach by sie przydala pragma do poinformowania
> kompilatora ze funkcja mniejsze_lub_rowne zwraca liczbe z zakresu
> od 0 do 15 i kompilator nie musi generowac zadnego kodu do omijania
> switcha.
>
>

zdaje sie ze nie ma czegos takiego - glownie chyba
mozna liczyc na rownolegle wykonywanie podstawowych
opearcji jak * / + - sqrt, i tak nie wiem czy to dziala
rzeczywiscie 4 (avx 8) razy szybciej niz fpu ale jakis
procent szybciej pewin ejednak dziala

jak potrzebujesz pisac jaknajszybsze procedury to sie
najlepiej naucz sse - ja mam zamiar sie nauczyc, w miare
poduczania wrzuce jakiegos posta z uwagami bo pare sie
pojawia

szkoda ze to pisanie bezposrednio kodu maszynowego
przez 'odpalanie stringow' mi sie sypie z niewiadomych
powodow (jeszcze nie szukalem odpowiedzi) na instrukcjach
fpu/sse bo jest dosyc wygodne i moze od razu bym testowal
czy funkcje przyspieszają







--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/

do góry