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?

pzdr
bartekltg