Zmieniłem zarządzanie wątkami, gdy się używa do wątków OpenMP
ma się praktycznie bez wysiłku kilka użytecznych opcji. Tak
więc po zastosowaniu dynamicznego przydziału zadań do wątków z
rozmiarem chunk=1 czas spadł do 14-15s.

Tu efekt:
https://thumbs.rapidshare.com/thumbs/1024/D0F/83731B
B65DA783F6EA92AB7576B7B.jpg

A tu kod rysujący/obliczający:
http://pastebin.com/rvsBJpir


On Thursday, April 18, 2013 10:42:37 AM UTC+2, firr kenobi wrote:
> jesli zrezygnowac z testu z kwadratem
> to tutaj ten kernel z trzema mnozeniami
> mozna zamianic na wersje tylko z dowma
> mnozeniami
> for(n=0; n<=max_iter; n++)
> {
> reim2 = (re + re) * im;
> re = (re - im) * (re + im) + cRe;
> im = reim2 + cIm;
> // if( fabs(re) > 2.0 ) break;
> // if( fabs(im) > 2.0 ) break;
> if( re > 2.0 || re < -2.0
> && im > 2.0 || im < -2.0 ) break;
> }
> to zauwazylem ze szkoly a*a - b*b = (a+b)*(a-b) u mnie w wersji c to akurat
> przyspiesza

U mnie czas wykonania poniższej wersji wzrósł z 14.22s do 14.61s:

static unsigned int computeColor( const double _x, const double _y, const unsigned
int inf ) {
double x=0, y=0;
unsigned int i;
for( i=0 ; i<inf ; i++ ) {
const double tmp = (x+x)*y;
x = (x-y)*(x+y)+_x;
y = tmp + _y;
if( std::fabs(y) > 2.0 || std::fabs(tmp) > 2.0 ) break;
}
if( i==inf )
return 0;
return i * 255 / (inf-1);
}



Kolejna wersja też minimalnie dłużej 14.55s:

static unsigned int computeColor( const double _x, const double _y, const unsigned
int inf ) { double x=0, y=0;
unsigned int i;
for( i=0 ; i<inf ; i++ ) {
const double tmp = x*x - y*y + _x;
y = 2.0 * x * y + _y;
if( tmp < -2 || tmp > +2 || y < -2 || y > +2 ) break;
x = tmp;
}
if( i==inf )
return 0;
return i * 255 / (inf-1);
}


> nie wiadomo jednak czy wersja z dwoma
> mul i czterema cmp (statystycznie szczesliwie mniej ) bylaby szybsza
> niz kernel z 3 mul i 1 cmp
> nalezaloby sprawdzic ale to musialbym
> znowu pogrzebac w asmie

Ja raczej nie napiszę w ASM, większość dawno temu zapomniałem :) Czy
mógłbyś podrzuć mi wersję tej procedury w asmie, tak żebym mógł ją
skompilować GCC64 bity? Czyli musiałby to być jakiś asembler osadzony.

Na razie u mnie najszybciej działa ta wersja:

static unsigned int computeColor( const double _x, const double _y, const unsigned
int inf ) {
double x=0, y=0;
unsigned int i;
for( i=0 ; i<inf ; i++ ) {
const double tmp = x*x - y*y + _x;
y = 2.0 * x * y + _y;
if( std::fabs(y) > 2.0 || std::fabs(tmp) > 2.0 ) break;
x = tmp;
}
if( i==inf )
return 0;
return i * 255 / (inf-1);
}

Z 61s udało się zejść do 14s, ale głównie przez zastosowanie OpenMP.

Pozdrawiam