W dniu środa, 4 grudnia 2013 22:09:28 UTC+1 użytkownik bartekltg napisał:
> W dniu 2013-12-04 20:05, firr pisze:
>
> >>
>
> >>
>
> >> [ciach]
>
> >>
>
> >>
>
> >>
>
> >> A co to za kloc?
>
> >>
>
> >> Dostałeś przecież _całą_ procedurę. Nic więcej nie trzeba.
>
> >>
>
> >
>
> > no to jest to samo tylka ta krotsza nadpisuje
>
> > ram dwa razy, moze te bylaby costam szybsza
>
>
>
> Ta funkcja przy dobrej optymalizacji w ogóle nie dotyka RAMu
>
> aż do ostatecznego zapisu.
>
>
>
>
>
> > (choc ciezko powiedziec - najlepiej by bylorozmawaic o procedurach w asmie ale
niestety
>
>
>
>
>
> A proszę, lekko zmodyfikowana wersja, kompiluje się w VS2010
>
> do ciut lepszego kodu. Miałem podać w c++, ale skoro chcesz w asm.
>
>
>
> Argumenty przychodzą w edx, r8d, r9d, wynik do pamięci pod
>
> adres trzymany w rcx (hmm)
>
>
>
> ciało funkcji:
>
>
>
> cmp edx, r8d
>
> jge SHORT $LN7@minmax3
>
> mov eax, edx //WTF
>
> mov edx, r8d //tu było swap(a,b)
>
> mov r8d, eax //czemu nie po prostu xchg?
>
> $LN7@minmax3:
>
> cmp r9d, edx
>
> jle SHORT $LN3@minmax3
>
> mov edx, r9d
>
>
>
> mov DWORD PTR [rcx+4], r8d
>
> mov rax, rcx
>
> mov DWORD PTR [rcx], edx
>
>
>
> > malo kto zna dzis asma na przyzwoitym poziomie)
>

to nie jest kompletna procedura, z tego co widze
ona tylko wyszukuje max przez dwa prownania
edx>r8d, edx>r9d
natomiast nie porownuje wogole r8d z r9d

takczyowak zachecam do kontunuowania watkow
asma bo warto pocwiczyc a jak niektorzy
zwracaja uwage optymalizacja staje sie coraz
wazniejsza w obecnej erze (gdy szybkosc kompow
prawie juz przestala wzrastac)

do góry

W dniu czwartek, 5 grudnia 2013 01:48:57 UTC+1 użytkownik bartekltg napisał:
> W dniu 2013-12-04 23:16, Wojciech Muła pisze:
>
> > On Wednesday, December 4, 2013 10:09:28 PM UTC+1, bartekltg wrote:
>
> >> ciało funkcji:
>
> >> cmp edx, r8d
>
> >> jge SHORT $LN7@minmax3
>
> >> mov eax, edx //WTF
>
> >> mov edx, r8d //tu było swap(a,b)
>
> >> mov r8d, eax //czemu nie po prostu xchg?
>
> >>
>
> >> $LN7@minmax3:
>
> >>
>
> >> cmp r9d, edx
>
> >> jle SHORT $LN3@minmax3
>
> >> mov edx, r9d
>
> >> mov DWORD PTR [rcx+4], r8d
>
> >> mov rax, rcx
>
> >> mov DWORD PTR [rcx], edx
>
> >>
>
> >
>
> > Bez sensu te skoki. Porządny kompilator uprości to do przesłań
>
> > warunkowych, bo na nowszych architekturach będzie szybsze od skoków.
>
> >
>
> > Nieliniowa zmiana przepływu sterowania to złoooo! :)
>
>
>
> Nakarmiłem lepszy kompilator (gcc 4.8.1)
>
>
>
> funkcja:
>
> pair <int,int> minmax3 (int a, int b, int c)
>
> {
>
> if (a<b)
>
> swap(a,b);
>
> if (c>a)
>
> a=c;
>
> else if (c<b)
>
> b=c;
>
>
>
> return make_pair(a,b);
>
>
>
> }
>
>
>
> BTW, wie ktoś, jak uzyskiwać ładniejszy plik asm w gcc?
>
> W tej chwili dodaje -g -fverbose-asm -Wa,-adhls=test.s
>
>
>
>
>
> 872:../rozne2/main.cpp **** w = minmax3(a,b,c);
>
> 18998 008c 8B542430 movl 48(%rsp),%edx
>
> 18999 0090 8B44242C movl 44(%rsp),%eax
>
> 19001 0094 8B5C2440 movl 64(%rsp),%ebx
>
>
>
> 829:../rozne2/main.cpp **** if (a<b) swap(a,b);
>
> 19005 .loc 1 829 0
>
> 19006 0098 39C2 cmpl %eax,%edx
>
>
>
> 19007 009a 7F06 jg .L1161
>
> 19008 009c 89D1 movl %edx,%ecx
>
> 19009 009e 89C2 movl %eax,%edx
>
> 19010 .LVL1838:
>
> 19011 00a0 89C8 movl %ecx,%eax
>
> 19012 .LVL1839:
>
> 19013 .L1161:
>
> 831:../rozne2/main.cpp **** if (c>a)
>
> 19014 .loc 1 831 0
>
> 19015 00a2 39D3 cmpl %edx,%ebx
>
> 19016 00a4 7F07 jg .L1162
>
> 19017 00a6 39D8 cmpl %ebx,%eax
>
> 19018 00a8 0F4FC3 cmovg %ebx,%eax
>
> 19019 .LVL1840:
>
> 19020 00ab 89D3 movl %edx,%ebx
>
> 19021 .LVL1841:
>
> 19022 .L1162:
>
> ...
>
>
>
> cmov użył dopiero dla ostatniego warunku/przypisania.
>
>
>
> Wersja z poprzedneigo posta też używa tylko raz:
>
> w = minmax2(a,b,c);
>
> 18995 .loc 1 889 0
>
> 18996 0053 8B542430 movl 48(%rsp),%edx
>
> 18997 0057 8B44242C movl 44(%rsp),%eax
>
> 18998 .LVL1833:
>
> 18999 005b 8B5C2440 movl 64(%rsp),%ebx
>
> 19000 .LVL1834:
>
> 19001 .LBB13789:
>
> 19002 .LBB13790:
>
> 842:../rozne2/main.cpp **** if (a>b)
>
> 19003 .loc 1 842 0
>
> 19004 005f 39C2 cmpl %eax,%edx
>
> 19005 0061 7D06 jge .L1162
>
> 19006 0063 89D1 movl %edx,%ecx
>
> 19007 0065 89C2 movl %eax,%edx
>
> 19008 .LVL1835:
>
> 19009 0067 89C8 movl %ecx,%eax
>
> 19010 .LVL1836:
>
> 19011 .L1162:
>
> 853:../rozne2/main.cpp **** if (c>M)
>
> 19012 .loc 1 853 0
>
> 19013 0069 39D3 cmpl %edx,%ebx
>
> 19014 006b 7F07 jg .L1163
>
> 19015 006d 39D8 cmpl %ebx,%eax
>
> 19016 006f 0F4FC3 cmovg %ebx,%eax
>
> 19017 .LVL1837:
>
> 19018 0072 89D3 movl %edx,%ebx
>
>
>
> Nawet po zamianie
>
> if (c>M) M=c;
>
> else if (c<m) m=c;
>
> na
>
> if (c>M) M=c;
>
> if (c<m) m=c;
>
>
>
> Jednak te skoki nie są takie straszne, czy kompilator
>
> za głupi? cmov to chyba już pentium pro.
>
>
>
>
>
> I też używają trzech instrukcji i dodatkowego rejestru
>
> na swap. Czyżby jednak było to szybsze niż xchg?
>
> Internet twierdzi, że nie.
>
> A CMPXCHG?
>
>
>
a jaki ustawiasz docelowy procesor pod
kompilacje bo warto ustawic jawnie (najlepiej ze
dwa i porownac wyniki) xchg moze byc wolne
i para czy tam navet trojka movow moze byc szybsza
zalezy od procka

do góry

>
> Jednak te skoki nie są takie straszne, czy kompilator
>
> za głupi? cmov to chyba już pentium pro.
>
>
>
>
>
> I też używają trzech instrukcji i dodatkowego rejestru
>
> na swap. Czyżby jednak było to szybsze niż xchg?
>
> Internet twierdzi, że nie.
>
> A CMPXCHG?
>

prawdopodobnie nie chodzi o ilosc cmp i movow
(oraz o to czy xcchg jest szybsze od movow bo
raczej na pewno jesli nie zostalo uzyte jest wolniejsze)
tylko o ilosc skokow, gdyby pisac moja rozwinieta
procedure w wersji 'bezposredniej' to byloby to
cos takiego

cmp a, b
jg n1
cmp a, c
jg n2
mov min, a
cmp b, c
jg n3
mov max, c
j exit
n3: mov max, b
j exit
n2:
mov min, c
mov max, b
j exit
n1:
cmp a, c
jl n4
mov max, a
cmp b, c
jl n5
mov min, c
j exit
n5: mov min, b
j exit
n4:
mov min, b
mov max, c
exit:

5 skokow warunkowych, 5 skokow
bezwarunkowych, czyli razem 10 skokow,
5 porownan, 10 movow,

co prawda chyba raczej powinno sie liczyc nie sumarycznie a po danej sciezce
wykonania ale
z tego co sie slyszy liczy sie tez chyba ilosc
missów, tak czy owak ten kod ktory zminimalizowal
ilosc skokow do 2 jak dla mnie akurat wyglada tutaj calkiem dobrze

ciekawe czy dalo by sie to recznie np z uzyciem
wlasnie bezifowców jeszcze to skompaktowac do jednego lub zero jumpow

do góry

W dniu czwartek, 5 grudnia 2013 09:15:51 UTC+1 użytkownik firr napisał:

> takczyowak zachecam do kontunuowania watkow
> asma bo warto pocwiczyc a jak niektorzy
> zwracaja uwage optymalizacja staje sie coraz
> wazniejsza w obecnej erze (gdy szybkosc kompow
> prawie juz przestala wzrastac)

to jak juz to wszystko pomierzysz, z checia
bym sie dowiedzial, jakiego rzedu wzrost (albo
spadek) szybkosci zanotowales, bo ja zyje w mniemaniu,
ze GCC wie lepiej ode mnie, jak zrobic, zeby kod
maszynowy dzialal wydajnie

do góry

W dniu czwartek, 5 grudnia 2013 10:23:09 UTC+1 użytkownik g...@g...com
napisał:
> W dniu czwartek, 5 grudnia 2013 09:15:51 UTC+1 użytkownik firr napisał:
>
>
>
> > takczyowak zachecam do kontunuowania watkow
>
> > asma bo warto pocwiczyc a jak niektorzy
>
> > zwracaja uwage optymalizacja staje sie coraz
>
> > wazniejsza w obecnej erze (gdy szybkosc kompow
>
> > prawie juz przestala wzrastac)
>
>
>
> to jak juz to wszystko pomierzysz, z checia
>
> bym sie dowiedzial, jakiego rzedu wzrost (albo
>
> spadek) szybkosci zanotowales, bo ja zyje w mniemaniu,
>
> ze GCC wie lepiej ode mnie, jak zrobic, zeby kod
>
> maszynowy dzialal wydajnie

przekonanie raczej błedne, w czesci przypadkow
gcc sobie pewnie dobrze radzi ale w czesci
nie i po prostu trzeba sie znac na sprawach
optymalizacji by przynajmniej probowac przyspieszyc program - dobre optymalizowanie
nieststy wymagaloby posiadania SSE w malym palcu i praktyki w kodowaniu w asmie
dluzszych kawalkow
a ja niestety z tym kiepsko stoje

do góry

W dniu czwartek, 5 grudnia 2013 10:44:09 UTC+1 użytkownik firr napisał:
> przekonanie raczej błedne, w czesci przypadkow
> gcc sobie pewnie dobrze radzi ale w czesci
> nie i po prostu trzeba sie znac na sprawach
> optymalizacji by przynajmniej probowac przyspieszyc program - dobre optymalizowanie

> nieststy wymagaloby posiadania SSE w malym palcu i praktyki w kodowaniu w asmie
dluzszych kawalkow
> a ja niestety z tym kiepsko stoje

Ja bym raczej powiedzial, ze dobre optymalizowanie
to przede wszystkim posiadanie profilera w malym
palcu, no bo jak inaczej stwierdzic, co nalezy
optymalizowac?

do góry

moj sposob optymalizowania polega na
przepisywaniu i sprawdzaniu czy przyspieszylo,
nieststy nie mam wygodnego srodowiska do
pracy z asmem i to jest ból

ciekawe czy jak ktos chcialby pisac winapowskie
kody w c z wygodnym asemblerem inline to jakie
kompilatory wchodzą w gre ...

do góry

Użytkownik "firr" <p...@g...com> napisał w wiadomości
news:0cb36877-1c9f-4c62-bfa9-682139e521c6@googlegrou
ps.com...
moj sposob optymalizowania polega na
przepisywaniu i sprawdzaniu czy przyspieszylo,
nieststy nie mam wygodnego srodowiska do
pracy z asmem i to jest ból

ciekawe czy jak ktos chcialby pisac winapowskie
kody w c z wygodnym asemblerem inline to jakie
kompilatory wchodzą w gre ...
==============
może Ci sie spodoba ?

http://www.agner.org/optimize/

http://www.agner.org/optimize/optimizing_assembly.pd
f

tylko trzeba troche poczytać :))))

do góry

>
> co prawda chyba raczej powinno sie liczyc nie sumarycznie a po danej sciezce
wykonania ale
>
> z tego co sie slyszy liczy sie tez chyba ilosc
>
> missów, tak czy owak ten kod ktory zminimalizowal
>
> ilosc skokow do 2 jak dla mnie akurat wyglada tutaj calkiem dobrze
>
>
>
> ciekawe czy dalo by sie to recznie np z uzyciem
>
> wlasnie bezifowców jeszcze to skompaktowac do jednego lub zero jumpow


ten kod wlasnie jest dosyc zoptymalizowany

//input ints eax ebx edx
// output eax: min, ebx:- max

cmp edx, eax
jg L1
swap edx, eax //here three movs for swap (*)
L1:
cmp ebx, edx
jg L2
cmp eax, ebx
cmovg eax, ebx
mov ebx, edx
L2:

sprawdzilem i sie zgadza, jest to dosyc
pouczajace jako przyklad jak mozna optymalizowac
takie coc

co do wersji z samych cmovow to ktos podal
przyklad

void compute_min_max(int &min, int &max, int x, int y, int z) {
min = x < y ? x : y;
max = x > y ? x : y;
min = min < z ? min : z;
max = max > z ? max : z;
}

It produces this assembly code (clang-500.2.76 with -O3):

.globl __Z15compute_min_maxRiS_iii
.align 4, 0x90
__Z15compute_min_maxRiS_iii: ## @_Z15compute_min_maxRiS_iii
.cfi_startproc
## BB#0:
pushq %rbp
Ltmp2:
.cfi_def_cfa_offset 16
Ltmp3:
.cfi_offset %rbp, -16
movq %rsp, %rbp
Ltmp4:
.cfi_def_cfa_register %rbp
cmpl %ecx, %edx
movl %ecx, %eax
cmovlel %edx, %eax
movl %eax, (%rdi)
cmovgel %edx, %ecx
movl %ecx, (%rsi)
movl (%rdi), %eax
cmpl %r8d, %eax
cmovgl %r8d, %eax
movl %eax, (%rdi)
movl (%rsi), %eax
cmpl %r8d, %eax
cmovgel %eax, %r8d
movl %r8d, (%rsi)
popq %rbp
ret
.cfi_endproc

ciezko powiedziec bez testu ktora wersja szybsza
- na razie nie moge przetestowac moze kiedys posniej

do góry

wogole jakbybyly odpowiednie instrukcje
to w asmie mogloby to byc zrobione trzema
ew jedna instrukcja (sort eax, edx /
sort eax, ebx, edx)
takie instrukcje wydaje mi sie powinny
byc chyba wprowadzane

do góry