🚀 go-pugleaf

tosamo napisał(a):
> Witam
> 
> Pisze sobie porgramik w masm32 (wersja 6.11 chyba). Do tej pory pisalem 
> glownie w c i pascalu wiec na poczatku
> program w asm wygladal jak dokladna kalka z jezykow wyzszego rzedu i dzialal 
> jakies 3 razy wolniej niz
> pascal i delphi. Potem zaczalem optymalizowac i wyszlo na to, ze kazda 
> optymalizacja zwalnia dzialanie programu
> o kilka(dziesiat) %.

 Optymalizacja numer 1: używaj najlepszych algorytmów/instrukcji,
funkcji in-line/makr, odwijaj pętle itp.

 Optymalizacja numer 2: w kompilatorze HLL włącz optymalizacje na
szybkość.

 Optymalizacja numer 3: jeśli obie powyższe dają niewystarczające
wyniki, sięgaj po assemblera.

> Na przyklad:
> 
> Czemu takie cos :
> 
>     mov edi,offset TABLICA
>     mov ecx,16
> sha1_processmessageblock4:
>     mov eax,dword ptr [edi-12]
>     xor eax,dword ptr [edi-32]
>     xor eax,dword ptr [edi-56]
>     xor eax,dword ptr [edi-64]
>     rol eax,1
>     stosd
>     ;
>     inc ecx
>     cmp ecx,80
>     jne sha1_processmessageblock4
> 
> Jest kilkukrotnie wolniejsze niz :
> 
>     mov edi,offset TABLICA
>     mov ecx,16
> sha1_processmessageblock4:
>     mov eax,ecx
>     shl eax,2
>     sub eax,12 ; 3 * 4
>     mov ebx,dword ptr [edi+eax]
>     sub eax,20 ; 5 * 4
>     xor ebx,dword ptr [edi+eax]
>     sub eax,24 ; 6 * 4
>     xor ebx,dword ptr [edi+eax]
>     sub eax,8 ; 2 * 4
>     xor ebx,dword ptr [edi+eax]
>     rol ebx,1
>     mov eax,ecx
>     shl eax,2
>     mov dword ptr [edi+eax],ebx
>     ;
>     inc ecx
>     cmp ecx,80
>     jne sha1_processmessageblock4

 Trudno powiedzieć. Możliwe, że przez stosd. Ja bym strzelał, że
wersja pierwsza powinna być szybsza. Może przebijasz cacheline. Może
operacje na EBX lubią tą przerwę, która tu mają a nie jak poprzednio:
co instrukcja o EAX, każda RMW.

> Albo czemu takie cos :
> 
>     mov esi,offset Buffers_ ; D
>     mov edi,offset Buffers__ ; E
>     std
>     movsd
>     movsd
>     ror DWORD PTR [esi],2
>     movsd
>     movsd
>     mov DWORD PTR [edi],eax
>     cld
> 
> Jest duzo wolniejsze niz :
> 
>     mov ebx,DWORD PTR [Buffers+12] ; E = D
>     mov DWORD PTR [Buffers+16],ebx
>     ;;
>     mov ebx,DWORD PTR [Buffers+8] ; D = C
>     mov DWORD PTR [Buffers+12],ebx
>     ;
>     mov ebx,DWORD PTR [Buffers+4] ; C = SHA1CircularShift(30,B)
>     ror ebx,2
>     mov DWORD PTR [Buffers+8],ebx
>     ;
>     mov ebx,DWORD PTR [Buffers] ; B = A
>     mov DWORD PTR [Buffers+4],ebx
>     ;
>     mov ebx,eax
>     mov DWORD PTR [Buffers],eax ; A = temp

 Też możliwe, że przez movsd. Ror na pamięci też nie wymiata, ale
przynajmniej jest Direct Path.
 Tą drugą wersję można jeszcze przyspieszyć moim zdaniem, używając
różnych rejestrów.

> Albo na przyklad mam cos takiego :
> 
>     mov al,byte ptr [esi+ecx]
>     mov byte ptr [edi+ebx],al
>     inc ecx
>     inc ebx
>     inc [Message_Block_Index]           << TO JEST WAZNE
>     ;
>     add [Length_Low],8
>     jnz sha1_input8 ;
>     inc [Length_High] ;
>     jnz sha1_input8
>     mov [Corrupted],1
> 
> Zmienna Message_Block_Index to zwykla zmienna DD w sekcji .data. Nie jest do 
> niczego juz potrzebna bo zamiast niej
> zapisuje dane w rejestrach. Usuwam ta linie i program zwalnia o 5% ! 
> Oczywiscie dziala bez zmiena tylko wolniej.

 Wstaw ze 5-10 NOPów, może pomoże. Chodzi o to, że poprzednie
instrukcje się muszą wykonać, nowe - zostać zdekodowane. Tak *mi* się
wydaje. Poza tym, należy unikać używania rejestrów cząstkowych o ile
się da. Należy rozdzielać instrukcje zależne.

> Oprocz tego na przyklad wielokrotne
> 
>     mov eax,edx
>     shl eax,2
>     mov eax,DWORD PTR [Word_+eax] ;
> 
> Dziala oczywiscie duzo szybciej niz proste
> 
>     mov esi,offset Word_
> 
> i potem juz tylko kilkadziesiat razy
> 
>     lodsd

 Instrukcje łańcuchowe są powolne.

> Czy ktos mi to wyjasni albo chociaz powie gdzie mozna jakies konkrety na ten 
> temat przeczytac ? 

 Ja swoje informacje biorę z podręczników optymalizacyjnych AMD:
http://www.amd.com/us-en/Processors/DevelopWithAMD/0,,30_2252_739_7044,00.html

 Niedawno jeden kolega na alt.pl.asm próbował łamać MD5. Może
połączycie siły? To, że w SHA1 i MD5 odkryto jakieś dziurki nie
oznacza od razu, że w jakimś rozsądnym czasie znajdziecie kolizje.

-- 
Pozdrawiam, Bogdan                                  (Linux i FreeDOS)
Kurs assemblera x86 (DOS i Linuks): http://rudy.mif.pg.gda.pl/~bogdro
Grupy dyskusyjne o asm:  pl.comp.lang.asm alt.pl.asm alt.pl.asm.win32
Prawdziwy, bezpieczny komunikator:                   www.JabberPL.org