pentium3.rpm ??

[Paweł Sikora]

On Monday 15 of March 2004 12:58, Marcin Doliński wrote:
> W liście z pon, 15-03-2004, godz. 12:31, Paweł Sikora pisze:
> > jedni powiedza, ze warto, inni, ze zysk jest niemierzalny.
> > skro jednak taka opcja jest w kernelu, to chyba nie powstala
> > tylko dla sportu...
>
> Nie prawda. Były w sieci testy wydajności kernel 2.4 vs. 2.6 i
> optymalizacja per arch z prockami HT. W przypadku kernela 2.4
> -march=pentium4 tylko bruździ, w przypadku 2.6 daje dużo większą
> wydajność. Moja odpowiedź - warto.

ja ze swojej strony podam taki maly przyklad lepszego wykorzystania
procka do obliczen staloprzecinkowych. wezmy na warsztat zwykle
dodawanie liczb 64 bitowych, ktore sa coraz powszechniej wykorzystywane
zarowno w kernelu jak i w aplikacjach z userspace'u.

/jako model posluzyla mi arch. 32 bitowa i686 & PIII/

#ifndef VEC
typedef long long int i64;
#else
typedef int v2si __attribute__ ((mode(V2SI)));
typedef v2si i64;
#endif

i64 a, b, c[4];

inline i64 foo(const i64 a, const i64 b)
{
    return (a + b);
}

int main(int argc,char **argv)
{
    c[0] = foo(a, b);
    c[1] = foo(a, c[0]);
    c[2] = foo(b, c[0]);
    c[3] = foo(c[1], c[2]);
    return 0;
}

*** wariant 1 - i686 ***

# gcc -Wall -O2 z.c -s -S -march=i686 -fverbose-asm
      -fomit-frame-pointer -mregparm=3

foo:
        addl    4(%esp), %eax   # b, tmp61
        adcl    8(%esp), %edx   # b,
        ret
(...)
main:
        pushl   %ebp    #
        movl    %esp, %ebp      #,
        subl    $24, %esp       #,
        movl    %esi, -8(%ebp)  #,
        movl    a, %eax # a, a
        andl    $-16, %esp      #,
        movl    %edi, -4(%ebp)  #,
        movl    a+4, %edx       # a, a
        subl    $16, %esp       #,
        movl    %ebx, -12(%ebp) #,
        movl    b, %esi # b, b
        movl    b+4, %edi       # b, b
        movl    %eax, %ecx      # a, <anonymous>
        movl    %edx, %ebx      # a, <anonymous>
        addl    %esi, %ecx      # b, <anonymous>
        adcl    %edi, %ebx      # b, <anonymous>
        addl    %ecx, %eax      # <anonymous>, <anonymous>
        adcl    %ebx, %edx      # <anonymous>, <anonymous>
        addl    %ecx, %esi      # <anonymous>, <anonymous>
        adcl    %ebx, %edi      # <anonymous>, <anonymous>
        movl    %eax, c+8       # <anonymous>, c
        addl    %esi, %eax      # <anonymous>, <anonymous>
        movl    %edx, c+12      # <anonymous>, c
        adcl    %edi, %edx      # <anonymous>, <anonymous>
        movl    %ebx, c+4       # <anonymous>, c
        movl    -12(%ebp), %ebx #,
        movl    %esi, c+16      # <anonymous>, c
        movl    -8(%ebp), %esi  #,
        movl    %edi, c+20      # <anonymous>, c
        movl    -4(%ebp), %edi  #,
        movl    %eax, c+24      # <anonymous>, c
        xorl    %eax, %eax      # <result>
        movl    %ecx, c # <anonymous>, c
        movl    %edx, c+28      # <anonymous>, c
        movl    %ebp, %esp      #,
        popl    %ebp    #
        ret

*** wariant 2 - pentium 3 ***

# gcc -Wall -O2 z.c -s -S -march=pentium3 -fverbose-asm
      -fomit-frame-pointer -mregparm=3

foo:
        addl    4(%esp), %eax   # b, tmp61
        adcl    8(%esp), %edx   # b,
        ret
(...)
main:
        pushl   %ebp    #
        movl    %esp, %ebp      #,
        subl    $24, %esp       #,
        movl    %esi, -8(%ebp)  #,
        movl    a, %eax # a, a
        andl    $-16, %esp      #,
        movl    %edi, -4(%ebp)  #,
        movl    a+4, %edx       # a, a
        subl    $16, %esp       #,
        movl    %ebx, -12(%ebp) #,
        movl    b, %esi # b, b
        movl    b+4, %edi       # b, b
        movl    %eax, %ecx      # a, <anonymous>
        movl    %edx, %ebx      # a, <anonymous>
        addl    %esi, %ecx      # b, <anonymous>
        adcl    %edi, %ebx      # b, <anonymous>
        addl    %ecx, %eax      # <anonymous>, <anonymous>
        adcl    %ebx, %edx      # <anonymous>, <anonymous>
        addl    %ecx, %esi      # <anonymous>, <anonymous>
        adcl    %ebx, %edi      # <anonymous>, <anonymous>
        movl    %eax, c+8       # <anonymous>, c
        addl    %esi, %eax      # <anonymous>, <anonymous>
        movl    %edx, c+12      # <anonymous>, c
        adcl    %edi, %edx      # <anonymous>, <anonymous>
        movl    %ebx, c+4       # <anonymous>, c
        movl    -12(%ebp), %ebx #,
        movl    %esi, c+16      # <anonymous>, c
        movl    -8(%ebp), %esi  #,
        movl    %edi, c+20      # <anonymous>, c
        movl    -4(%ebp), %edi  #,
        movl    %eax, c+24      # <anonymous>, c
        xorl    %eax, %eax      # <result>
        movl    %ecx, c # <anonymous>, c
        movl    %edx, c+28      # <anonymous>, c
        movl    %ebp, %esp      #,
        popl    %ebp    #
        ret

jak widac powyzej roznica miedzy i686, a p3 zadna.
gcc wygenerowal nam mase 2 taktowych instrukcji mov,add,sub,xor.
niby to szybkie, ale jednak sporo tego jest.

no to jeszcze jedna kompilacja:

*** wariant 2 - pentium 3 +MMX ***

# gcc -Wall -O2 z.c -s -S -march=pentium3 -fverbose-asm
      -fomit-frame-pointer -mregparm=3 -DVEC

foo:
        paddd   %mm1, %mm0      # b, tmp61
        movq    %mm0, (%eax)    # tmp61, <result>
        ret
(...)
main:
        pushl   %ebp    #
        xorl    %eax, %eax      # <result>
        movl    %esp, %ebp      #,
        subl    $8, %esp        #,
        andl    $-16, %esp      #,
        subl    $16, %esp       #,
        movq    a, %mm0 # a, a
        movq    b, %mm2 # b, b
        movq    %mm0, %mm1      # a, <anonymous>
        paddd   %mm2, %mm1      # b, <anonymous>
        paddd   %mm1, %mm0      # <anonymous>, <anonymous>
        movq    %mm0, c+8       # <anonymous>, c
        paddd   %mm1, %mm2      # <anonymous>, <anonymous>
        paddd   %mm2, %mm0      # <anonymous>, <anonymous>
        movq    %mm1, c # <anonymous>, c
        movq    %mm2, c+16      # <anonymous>, c
        movq    %mm0, c+24      # <anonymous>, c
        leave
        ret

i co otrzymalismy?
duzo mniej instrukcji, ktore na dodatek wykonuja sie w jednym cyklu zegara.
lekko liczac dostalismy 2-krotne przyspiesznie i mniejszy kod
wynikowy na prostej arytmetyce.

-- 
If you think of MS-DOS as mono, and Windows as stereo,
  then Linux is Dolby Digital and all the music is free...