On 2 Lut, 20:55, Fil <f...@p...onet.pl> wrote:
> Jeszcze raz - ostatni test i podsumowanie:
> PASCAL wariant 1 kompilator DELPHI:  8,2s
> PASCAL wariant 2 kompilator DELPHI:  5,2s
> CPP    wariant 1 kompilator BUILDER: 4,5s
> CPP    wariant 2 kompilator BUILDER: 4,0s
> CPP    wariant 1 kompilator VISUAL:  1,4s
> CPP    wariant 2 kompilator VISUAL:  1,2s

A gdzie wariant z optymalizacja cache? Napisz z transpozycja
przez mnozeniem, powinno przyspieszyc 10 razy.
Pozdrawiam

do góry

> To tak, z tego co mi widomo, jak trochę się bawiłem w te sprawy, to:
>
> * dla C/C++ najlepszym (b. dobrze optymalizującym) kompilatorem był
> ten produkcji Intela;
> * z części obliczeniowej zrób bibliotekę dll;
> * tej biblioteki możesz użyć w czymkolwiek, np. w Delphi.

Tak właśnie chcę zrobić, ale nie jest to takie proste (wbrew pozorom). I
nie chodzi mi o tworzenie bibliotek i eksportowanie funkcji, klas i
takie tam... (to są banały), tylko muszę się zastanowić nad tym jak
poukładać wszystko do kupy od strony filozoficznej :). Mam sporo
komponentów powiązanych ze sobą zależnościami - całość stanowi dość
spory projekt.

Kompilatora Intela niestety nie mam. Pirat nie wchodzi w grę :). Free
for comercial nie widziałem na stronie Intela. Może w przyszłości - jak
zrobię te DLLki, to kupię kompilator i skompiluję je ponownie. Na razie
musi wystarczyć Visual.

Fil.

do góry

On 2 Lut, 22:40, Fil <f...@p...onet.pl> wrote:
> > To tak, z tego co mi widomo, jak trochę się bawiłem w te sprawy, to:
>
> >   * dla C/C++ najlepszym (b. dobrze optymalizującym) kompilatorem był
> > ten produkcji Intela;
> >   * z części obliczeniowej zrób bibliotekę dll;
> >   * tej biblioteki możesz użyć w czymkolwiek, np. w Delphi.
>
> Tak właśnie chcę zrobić, ale nie jest to takie proste (wbrew pozorom).
Naprawdę polecam optymalizacje cache, moze wtedy nie bedzie trzeba
kompilatora zmieniac i robienia dll. Przyklad wstepnej transpozycji
byl
podawany jakis czas temu na tej grupie.
Pozdrawiam

do góry

W dniu 2011-02-02 22:00, Mariusz Marszałkowski pisze:
> On 2 Lut, 20:55, Fil<f...@p...onet.pl> wrote:
>> Jeszcze raz - ostatni test i podsumowanie:
>> PASCAL wariant 1 kompilator DELPHI: 8,2s
>> PASCAL wariant 2 kompilator DELPHI: 5,2s
>> CPP wariant 1 kompilator BUILDER: 4,5s
>> CPP wariant 2 kompilator BUILDER: 4,0s
>> CPP wariant 1 kompilator VISUAL: 1,4s
>> CPP wariant 2 kompilator VISUAL: 1,2s
>
> A gdzie wariant z optymalizacja cache? Napisz z transpozycja
> przez mnozeniem, powinno przyspieszyc 10 razy.
> Pozdrawiam
Napisz lub daj namiar na info: co rozumiesz przez "optymalizację cache"
(Jakieś specjalne ustawienia kompilatora? Przeróbki w kodzie?)
Wariant 2 CPP kompilowany w Visual i Builder dotyczy przypadku, gdzie
tablica B jest transponowana wcześniej (przed mnożeniem).

> To jest raczej przypadkowy wynik, nie przejmowalbym sie takim
> jednym pomiarem. Napisz 10 procedur, skompiluj roznymi
> kompilatorami, uruchom kazda na 3-4 komputerach i wtedy
> mozna pokusic sie o jakies wnioski

Wyniki nie do końca są przypadkowe (jak napisałeś w poście poniżej).
Owszem testowane na 1 komputerze, ale są uśrednione po kilkukrotnym
odpaleniu programów (wiele razy w ciągu max. jednej minuty).
Sześć procedur kompilowanych na trzech kompilatorach nie wystarczy? Test
na innych kompach zrobię jutro w pracy.

Pozdrawiam.
Fil.

do góry

On Wed, 02 Feb 2011 20:55:00 +0100 Fil <f...@p...onet.pl> wrote:

> Jeszcze raz - ostatni test i podsumowanie:
> PASCAL wariant 1 kompilator DELPHI: 8,2s
> PASCAL wariant 2 kompilator DELPHI: 5,2s
> CPP wariant 1 kompilator BUILDER: 4,5s
> CPP wariant 2 kompilator BUILDER: 4,0s
> CPP wariant 1 kompilator VISUAL: 1,4s
> CPP wariant 2 kompilator VISUAL: 1,2s
>
> I tyle w temacie :)

Pokaż zdisaemblowane procedury, bo teraz jest tylko zgadywanie,
co robi kompilator.

w.

do góry

W dniu 2011-02-02 23:09, Wojciech Muła pisze:
> On Wed, 02 Feb 2011 20:55:00 +0100 Fil<f...@p...onet.pl> wrote:
>
>> Jeszcze raz - ostatni test i podsumowanie:
>> PASCAL wariant 1 kompilator DELPHI: 8,2s
>> PASCAL wariant 2 kompilator DELPHI: 5,2s
>> CPP wariant 1 kompilator BUILDER: 4,5s
>> CPP wariant 2 kompilator BUILDER: 4,0s
>> CPP wariant 1 kompilator VISUAL: 1,4s
>> CPP wariant 2 kompilator VISUAL: 1,2s
>>
>> I tyle w temacie :)
>
> Pokaż zdisaemblowane procedury, bo teraz jest tylko zgadywanie,
> co robi kompilator.
>
> w.
>
Służę uprzejmie (dwa warianty wystarczą, aby porównać BCB i VISUALA):

CPP wariant 2 kompilator BUILDER (4,0s):
00402218 55 push ebp
00402219 8BEC mov ebp,esp
0040221B 83C4F0 add esp,-$10
0040221E 53 push ebx
0040221F 56 push esi
00402220 57 push edi
00402221 EB67 jmp $0040228a
00402223 8B4514 mov eax,[ebp+$14]
00402226 8945F0 mov [ebp-$10],eax
00402229 83451404 add dword ptr [ebp+$14],$04
0040222D 8B4D18 mov ecx,[ebp+$18]
00402230 8B551C mov edx,[ebp+$1c]
00402233 8B1A mov ebx,[edx]
00402235 83451C04 add dword ptr [ebp+$1c],$04
00402239 8B4510 mov eax,[ebp+$10]
0040223C 8945FC mov [ebp-$04],eax
0040223F EB3E jmp $0040227f
00402241 8B55F0 mov edx,[ebp-$10]
00402244 8B02 mov eax,[edx]
00402246 8B11 mov edx,[ecx]
00402248 83C104 add ecx,$04
0040224B 33F6 xor esi,esi
0040224D 8975F4 mov [ebp-$0c],esi
00402250 8975F8 mov [ebp-$08],esi
00402253 8B750C mov esi,[ebp+$0c]
00402256 EB10 jmp $00402268
00402258 DD00 fld qword ptr [eax]
0040225A DC0A fmul qword ptr [edx]
0040225C 83C208 add edx,$08
0040225F 83C008 add eax,$08
00402262 DC45F4 fadd qword ptr [ebp-$0c]
00402265 DD5DF4 fstp qword ptr [ebp-$0c]
00402268 8BFE mov edi,esi
0040226A 83C6FF add esi,-$01
0040226D 85FF test edi,edi
0040226F 75E7 jnz $00402258
00402271 8B45F4 mov eax,[ebp-$0c]
00402274 8903 mov [ebx],eax
00402276 8B45F8 mov eax,[ebp-$08]
00402279 894304 mov [ebx+$04],eax
0040227C 83C308 add ebx,$08
0040227F 8B55FC mov edx,[ebp-$04]
00402282 8345FCFF add dword ptr [ebp-$04],-$01
00402286 85D2 test edx,edx
00402288 75B7 jnz $00402241
0040228A 8B4D08 mov ecx,[ebp+$08]
0040228D 834508FF add dword ptr [ebp+$08],-$01
00402291 85C9 test ecx,ecx
00402293 758E jnz $00402223
00402295 5F pop edi
00402296 5E pop esi
00402297 5B pop ebx
00402298 8BE5 mov esp,ebp
0040229A 5D pop ebp
0040229B C3 ret

CPP wariant 2 kompilator VISUAL (1,2s):
01111050 push ebp
01111051 mov ebp,esp
01111053 sub esp,0Ch
01111056 mov eax,dword ptr [ebp+0Ch]
01111059 fldz
0111105B push ebx
0111105C push esi
0111105D sub ecx,eax
0111105F push edi
01111060 mov dword ptr [N],7D0h
01111067 mov dword ptr [ebp-0Ch],ecx
0111106A jmp MulTab2+22h (1111072h)
0111106C mov eax,dword ptr [C]
0111106F mov ecx,dword ptr [ebp-0Ch]
01111072 mov edx,dword ptr [eax]
01111074 dec dword ptr [N]
01111077 mov esi,dword ptr [B]
0111107A mov edi,dword ptr [ecx+eax]
0111107D add ecx,eax
0111107F add eax,4
01111082 mov dword ptr [Cij],edx
01111085 mov dword ptr [C],eax
01111088 mov ebx,7D0h
0111108D mov edx,dword ptr [esi]
0111108F fld st(0)
01111091 dec ebx
01111092 add esi,4
01111095 mov eax,edi
01111097 mov ecx,12Ch
0111109C sub edx,edi
0111109E fld qword ptr [edx+eax]
011110A1 add eax,8
011110A4 dec ecx
011110A5 fmul qword ptr [eax-8]
011110A8 faddp st(1),st
011110AA jne MulTab2+4Eh (111109Eh)
011110AC mov eax,dword ptr [Cij]
011110AF fstp qword ptr [eax]
011110B1 add eax,8
011110B4 mov dword ptr [Cij],eax
011110B7 test ebx,ebx
011110B9 jne MulTab2+3Dh (111108Dh)
011110BB cmp dword ptr [N],ebx
011110BE jne MulTab2+1Ch (111106Ch)
011110C0 pop edi
011110C1 fstp st(0)
011110C3 pop esi
011110C4 pop ebx
011110C5 mov esp,ebp
011110C7 pop ebp
011110C8 ret

Miłej analizy :)
Fil.

do góry

Spostrzeżenia na pierwszy rzut oka:
Liczba instrukcji:
BUILDER: VISUAL:
jmp - 3szt. jmp - 1szt.
jnz - 3szt. jne - 3szt.
add - 10szt. sub, add, dec - 11szt.
fadd - 1szt. faddp - 1szt.
fstp - 1szt. fstp - 2szt.
fld - 1szt. fld - 2szt.
fmul - 1szt. fmul - 1szt.

Mniej instrukcji skoków na korzyść VISUALA.

do góry

On Wed, 02 Feb 2011 23:38:54 +0100 Fil <f...@p...onet.pl> wrote:

> [...]
> Miłej analizy :)

Widać, że w VC wszystkie indeksy/wskaźniki są trzymane w rejestrach
procesora - BCB ciągle odwołuje się do zmiennych lokalnych na stosie.

Druga słaba rzecz, to najbardziej zagnieżdżona pętla licząca iloczyn
skalarny. W VC wyniki pośrednie są akumulowane w rejestrze FPU i dopiero
po zakończeniu pętli zapisywane w pamięci. BCB zapisuje i odczytuje
wartość pośrednią z pamięci w każdym obiegu pętli.

Więc jasne jest, że te wszystkie zbędne odwołania do pamięci są powodem
spowolnienia; kod numeryczny jest właściwie identyczny.

w.

do góry

On 2 Lut, 23:08, Fil <f...@p...onet.pl> wrote:
> W dniu 2011-02-02 22:00, Mariusz Marszałkowski pisze:> On 2 Lut, 20:55,
Fil<f...@p...onet.pl>  wrote:
> >> Jeszcze raz - ostatni test i podsumowanie:
> >> PASCAL wariant 1 kompilator DELPHI:  8,2s
> >> PASCAL wariant 2 kompilator DELPHI:  5,2s
> >> CPP    wariant 1 kompilator BUILDER: 4,5s
> >> CPP    wariant 2 kompilator BUILDER: 4,0s
> >> CPP    wariant 1 kompilator VISUAL:  1,4s
> >> CPP    wariant 2 kompilator VISUAL:  1,2s
>
> > A gdzie wariant z optymalizacja cache? Napisz z transpozycja
> > przez mnozeniem, powinno przyspieszyc 10 razy.
> > Pozdrawiam
>
> Napisz lub daj namiar na info: co rozumiesz przez "optymalizację cache"
Przeszukaj ta grupe, watek chyba zatytulowany: "matlab taki wydajny?"

> (Jakieś specjalne ustawienia kompilatora? Przeróbki w kodzie?)
Tak, bardzo prosta i skuteczna przerobka, transponowanie drugiej
macierzy przed mnozeniem.

> Wariant 2 CPP kompilowany w Visual i Builder dotyczy przypadku, gdzie
> tablica B jest transponowana wcześniej (przed mnożeniem).
Jesli jest transponowana to dlaczego iterujesz po pierwszym indeksie?
for (int k = 0; k < Q; ++k) C[i][j] += A[i][k] * B[k][j];
Powinno byc w obu macierzach po drugim:
for (int k = 0; k < Q; ++k) C[i][j] += A[i][k] * B[j][k];

> Wyniki nie do końca są przypadkowe (jak napisałeś w poście poniżej).
Wez dwa/trzy kompilatory C++ i Pascala i dwa/trzy komputery, wtedy
bedzie co porownywac. No i zoptymalizuj cache, bo teraz to w duzej
czesci testujemy dostep do RAM a nie wykonywanie instrukcji.

Pozdrawiam

do góry

Fil pisze:
> W dniu 2011-02-02 17:53, Tomasz Kaczanowski pisze:
>
>> Zapewne się nadaje, ogólnie jednak kompilatory Borlanda słabo
>> optymalizują - niezależnie od języka. Więc zależy od tego co chcemy
>> obliczać.
> Jak to zależy? Obliczenia to obliczenia. Zmiennoprzecinkowa arytmetyka:
> dodawanie, odejmowanie, mnożenie, itd. nic wyszukanego. Na tablicach
> danych - macierzach.

Znaczenie ma jaki kod wygeneruje. Zresztą chyba już to zauważyłeś, bo w
innym poście sam podajesz wyniki testu:

> Jeszcze raz - ostatni test i podsumowanie:
> PASCAL wariant 1 kompilator DELPHI: 8,2s
> PASCAL wariant 2 kompilator DELPHI: 5,2s
> CPP wariant 1 kompilator BUILDER: 4,5s
> CPP wariant 2 kompilator BUILDER: 4,0s
> CPP wariant 1 kompilator VISUAL: 1,4s
> CPP wariant 2 kompilator VISUAL: 1,2s

Zwróć uwagę na różnicę między Builderem i Visualem. Po prostu producent
Buildera i delphi stosuje bardzo stare metody optymalizacyjne, a
zmieniły się przez te parenaście lat i systemy i procesory. Czasami
Tobie wydaje się, że kolejność obliczeń nie ma znaczenia, a dla
procesora może mieć.


--
Kaczus
http://kaczus.republika.pl

do góry