GCC neden * a * a * a * a * a ila (a * a * a) * (a * a * a) seviyesini optimize etmiyor?


Al─▒nan cevaba git


Bilimsel bir uygulamada baz─▒ say─▒sal optimizasyonlar yap─▒yorum. Fark etti─čim bir ┼čey, GCC'nin ├ža─čr─▒y─▒ pow(a,2) derleyerek optimize edece─či a*a , ancak ├ža─čr─▒n─▒n pow(a,6) optimize edilmedi─či ve asl─▒nda pow performans─▒ b├╝y├╝k ├Âl├ž├╝de yava┼člatan k├╝t├╝phane i┼člevini ├ža─č─▒raca─č─▒ . (Buna kar┼č─▒l─▒k, y├╝r├╝t├╝lebilir Intel C ++ Compiler , icc kitapl─▒k ├ža─čr─▒s─▒n─▒ ortadan kald─▒racakt─▒r pow(a,6) .)

Merak ediyorum pow(a,6) , a*a*a*a*a*a GCC 4.5.1 ve " -O3 -lm -funroll-loops -msse4 " se├ženekleri ile de─či┼čtirdi─čimde , 5 mulsd komut kullanmas─▒:

 movapd  %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
 

e─čer (a*a*a)*(a*a*a) yazarsam ├╝retecek

 movapd  %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm14, %xmm13
mulsd   %xmm13, %xmm13
 

├žarpma talimatlar─▒n─▒n say─▒s─▒n─▒ 3.'e d├╝┼č├╝ren icc benzer davran─▒┼ča sahiptir.

Derleyiciler bu optimizasyon numaras─▒n─▒ neden tan─▒m─▒yor?


2077





2011-06-21




Cevap say─▒s─▒n─▒ say: 12






├ç├╝nk├╝ Kayan Noktal─▒ Matematik ─░li┼čkisel de─čildir . ─░┼členenleri kayan nokta ├žarp─▒m─▒nda gruplama ┼čeklinin cevab─▒n say─▒sal do─črulu─ču ├╝zerinde etkisi vard─▒r.

Sonu├ž olarak, ├žo─ču derleyici, cevab─▒n ayn─▒ kalaca─č─▒ndan emin olmad─▒k├ža ya da say─▒sal do─črulukla ilgilenmedi─činizi s├Âylemedi─činiz s├╝rece kayan nokta hesaplamalar─▒n─▒ yeniden d├╝zenlemek konusunda ├žok tutucudur. ├ľrne─čin: se├ženek reassociate kayan nokta operasyonlar─▒na gcc verir gcc'nin, hatta h─▒z kar┼č─▒ hassasiyeti daha da agresif tradeoffs verir se├žene─či. -fassociative-math -ffast-math


2685







Lambdageek do─čru birle┼čebilirlik kayan noktal─▒ say─▒lar i├žin tutmaz ├ž├╝nk├╝ "optimizasyonu" i┼čaret a*a*a*a*a*a etmek (a*a*a)*(a*a*a) de─čerini de─či┼čtirebilir. Bu nedenle C99 taraf─▒ndan izin verilmez (kullan─▒c─▒ taraf─▒ndan ├Âzellikle derleyici bayra─č─▒ veya pragma taraf─▒ndan izin verilmedik├že). Genel olarak, varsay─▒m programc─▒n─▒n bir sebeple ne yapt─▒─č─▒n─▒ yazd─▒─č─▒ ve derleyicinin buna sayg─▒ duymas─▒ gerekti─čidir. ─░stersen, bunu (a*a*a)*(a*a*a) yaz.

Yine de yazmak i├žin ac─▒ olabilir; Derleyici neden kulland─▒─č─▒n─▒zda do─čru olan─▒ [[d├╝┼č├╝nd├╝─č├╝n├╝z├╝]] yapam─▒yor pow(a,6) ? ├ç├╝nk├╝ yap─▒lacak yanl─▒┼č ┼čey olurdu . ─░yi bir matematik k├╝t├╝phanesi olan bir platformda, pow(a,6) ya a*a*a*a*a*a da ya oldu─čundan daha kesindir (a*a*a)*(a*a*a) . Sadece baz─▒ verileri sa─člamak i├žin, Mac Pro'm ├╝zerinde k├╝├ž├╝k bir deney yapt─▒m, [1,2] aras─▒ndaki t├╝m tek duyarl─▒kl─▒ y├╝zer say─▒lar i├žin ^ 6'y─▒ de─čerlendirmedeki en b├╝y├╝k hatay─▒ ├Âl├žt├╝m:

 worst relative error using    powf(a, 6.f): 5.96e-08
worst relative error using (a*a*a)*(a*a*a): 2.94e-07
worst relative error using     a*a*a*a*a*a: 2.58e-07
 

pow ├çarpma a─čac─▒ yerine kullanmak , 4 fakt├Âre ba─čl─▒ hatay─▒ azalt─▒r . Derleyiciler, kullan─▒c─▒ taraf─▒ndan lisanslanmad─▒k├ža (├Ârne─čin ├╝zerinden -ffast-math ) hatay─▒ art─▒ran "optimizasyonlar" yapmamal─▒ (ve genellikle yapmamal─▒d─▒r ).

GCC'nin bir sat─▒r i├ži ├žarpma a─čac─▒ olu┼čturmas─▒ gereken __builtin_powi(x,n) bir alternatif olarak sundu─čunu unutmay─▒n pow( ) . Performans i├žin do─črulukla takas etmek istiyorsan─▒z ancak h─▒zl─▒ matemati─či etkinle┼čtirmek istemiyorsan─▒z bunu kullan─▒n.


642







Benzer bir durum: bir├žok derleyici olmaz optimize etmek a + b + c + d i├žin (a + b) + (c + d) (yani, belirli bir olarak de─čerlendirmek ve (bu ikinci salg─▒lama daha ard─▒┼č─▒k edilebildi─činden bir iyile┼čtirmedir) (((a + b) + c) + d) ). Bu da k├Â┼če davalar─▒ y├╝z├╝nden:

 float a = 1e35, b = 1e-5, c = -1e35, d = 1e-5;
printf("%e %e\n", a + b + c + d, (a + b) + (c + d));
 

Bu ├ž─▒k─▒┼člar 1.000000e-05 0.000000e+00


164







Fortran (bilimsel bilgi i┼člem i├žin tasarlanm─▒┼čt─▒r) yerle┼čik bir g├╝├ž operat├Âr├╝ne sahiptir ve bildi─čim kadar─▒yla Fortran derleyicileri, tan─▒mlad─▒─č─▒n─▒za benzer bir ┼čekilde tamsay─▒ g├╝├žlerine y├╝kselmeyi yayg─▒nla┼čt─▒racakt─▒r. C / C ++ ne yaz─▒k ki bir g├╝├ž operat├Âr├╝ne sahip de─čil, sadece k├╝t├╝phane fonksiyonuna sahip pow() . Bu, ak─▒ll─▒ derleyicilerin pow ├Âzel i┼člem g├Ârmesini ve ├Âzel durumlar i├žin daha h─▒zl─▒ bir ┼čekilde hesaplamas─▒n─▒ engellemez , ancak daha az s─▒kl─▒kla yap─▒yorlar ...

Birka├ž y─▒l ├Ânce tamsay─▒l─▒ g├╝├žleri en uygun ┼čekilde hesaplamay─▒ daha uygun hale getirmeye ├žal─▒┼č─▒yordum ve a┼ča─č─▒dakileri buldum. C ++ olsa da C ++ ve hala derleyicinin i┼čleri en iyi hale getirme / sat─▒r i├ži konusunda biraz ak─▒ll─▒ olmas─▒na ba─čl─▒. Neyse, pratikte faydal─▒ bulaca─č─▒n─▒ umuyorum:

 template<unsigned N> struct power_impl;

template<unsigned N> struct power_impl {
    template<typename T>
    static T calc(const T &x) {
        if (N%2 == 0)
            return power_impl<N/2>::calc(x*x);
        else if (N%3 == 0)
            return power_impl<N/3>::calc(x*x*x);
        return power_impl<N-1>::calc(x)*x;
    }
};

template<> struct power_impl<0> {
    template<typename T>
    static T calc(const T &) { return 1; }
};

template<unsigned N, typename T>
inline T power(const T &x) {
    return power_impl<N>::calc(x);
}
 

Merakl─▒ i├žin a├ž─▒klama: bu, g├╝├žleri hesaplaman─▒n en uygun yolunu bulamamaktad─▒r, ancak en uygun ├ž├Âz├╝m├╝ bulmak NP-tamamlanm─▒┼č bir sorun oldu─čundan ve bu sadece k├╝├ž├╝k g├╝├žler i├žin yapmaya de─čece─či i├žin (kullanmaktan ziyade pow ) detay ile.

O zaman sadece kullan power<6>(a) .

Bu, g├╝├žlerin a yaz─▒lmas─▒n─▒ kolayla┼čt─▒r─▒r (6 s'yi parens ile hecelemeye gerek yoktur ) ve telafi toplam─▒ -ffast-math gibi hassas bir ba─č─▒ml─▒l─▒─ča sahip olman─▒z gerekmeden bu t├╝r bir optimizasyona izin verir (i┼člemlerin s─▒ras─▒n─▒n gerekli oldu─ču bir ├Ârnek) .http://en.wikipedia.org/wiki/Kahan_summation_algorithm

Muhtemelen bunun C ++ oldu─čunu unutabilir ve yaln─▒zca C program─▒nda kullanabilirsiniz (e─čer bir C ++ derleyicisiyle derlenirse).

Umar─▒m bu yararl─▒ olabilir.

D├ťZENLE:

Derleyicimden ald─▒─č─▒m ┼čey bu:

i├žin a*a*a*a*a*a ,

     movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
 

i├žin (a*a*a)*(a*a*a) ,

     movapd  %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm1, %xmm0
    mulsd   %xmm0, %xmm0
 

i├žin power<6>(a) ,

     mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
 

79







GCC asl─▒nda optimize etmez a*a*a*a*a*a etmek (a*a*a)*(a*a*a) bir tamsay─▒ oldu─čunda. Bu komutla denedim:

 $ echo 'int f(int x) { return x*x*x*x*x*x; }' | gcc -o - -O2 -S -masm=intel -x c -
 

├çok fazla gcc bayra─č─▒ var, ancak s├╝sl├╝ bir ┼čey yok. Yani: stdin'den oku; O2 optimizasyon seviyesini kullan─▒n; ─░kili yerine ├ž─▒kt─▒ derleme dili listesi; giri┼č, Intel derleme dili s├Âzdizimini kullanmal─▒d─▒r; giri┼č C dilinde (genellikle dil giri┼č dosyas─▒ uzant─▒s─▒ndan ├ž─▒kar, ancak stdin'den okurken dosya uzant─▒s─▒ yoktur); ve stdout'a yaz.

─░┼čte ├ž─▒kt─▒n─▒n ├Ânemli k─▒sm─▒. Assembly dilinde neler olup bitti─čini g├Âsteren baz─▒ yorumlar ile a├ž─▒klam─▒┼čt─▒m:

 ; x is in edi to begin with.  eax will be used as a temporary register.
mov  eax, edi  ; temp = x
imul eax, edi  ; temp = x * temp
imul eax, edi  ; temp = x * temp
imul eax, eax  ; temp = temp * temp
 

Bir Ubuntu t├╝revi olan Linux Mint 16 Petra'daki GCC sistemini kullan─▒yorum. ─░┼čte gcc versiyonu:

 $ gcc --version
gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
 

Di─čer posterlerin belirtti─či gibi, kayan noktalarda bu se├ženek m├╝mk├╝n de─čildir, ├ž├╝nk├╝ kayan nokta aritmeti─či ili┼čkilendirici de─čildir.


58







├ç├╝nk├╝ 32 bit kayan noktal─▒ say─▒ - 1.024 gibi - 1.024 de─čildir. Bir bilgisayarda, 1.024 bir aral─▒kt─▒r: "e" bir hatay─▒ temsil eder (1.024-e) ila (1.024 + e). Baz─▒ insanlar bunu fark edemez ve ayr─▒ca * a * a'da, bu say─▒lara herhangi bir hata yapmadan rastgele kesinlikli say─▒lar─▒n ├žarp─▒m─▒na kar┼č─▒l─▒k geldi─čine inan─▒r. Baz─▒ insanlar─▒n bunu ger├žekle┼čtirememelerinin nedeni, belki de ilkokullarda uygulad─▒klar─▒ matematik hesaplamalar─▒d─▒r: sadece ek numaralar olmadan ideal say─▒larla ├žal─▒┼čmak ve ├žarpma i┼člemi yaparken basit├že "e" yi g├Ârmezden gelmenin do─čru oldu─čuna inanmak. "Float a = 1.2", "a * a * a" ve benzeri C kodlar─▒nda "e" harfini g├Ârmezler.

Programc─▒lar─▒n ├žo─čunlu─ču C ifadesinin a * a * a * a * a * a'n─▒n asl─▒nda ideal say─▒larla ├žal─▒┼čmad─▒─č─▒ fikrini kabul ederse (ve uygulayabiliyorsa), GCC derleyicisi "a * a'y─▒ optimize etmek i├žin BEDAVA olur. * a * a * a * a "i├žine" t = (a * a); t * t * t "ki bu, daha az say─▒da ├žarpma gerektirir. Ancak ne yaz─▒k ki, GCC derleyicisi kodu yazan programc─▒n─▒n ÔÇťaÔÇŁ n─▒n hata olan veya olmayan bir say─▒ oldu─čunu d├╝┼č├╝nd├╝─č├╝n├╝ bilmiyor. Ve b├Âylece GCC sadece kaynak kodun neye benzedi─čini yapar - ├ž├╝nk├╝ GCC'nin "├ž─▒plak g├Âz├╝" ile g├Ârd├╝─č├╝ ┼čey budur.

... ne t├╝r bir programc─▒ oldu─čunuzu ├Â─črendikten sonra, "-ffast-math" anahtar─▒n─▒ GCC'ye "Hey, GCC, ne yapt─▒─č─▒m─▒ biliyorum!" diyerek kullanabilirsiniz. Bu, GCC'nin * a * a * a * a * a * a * a * a'y─▒ farkl─▒ bir metin par├žas─▒na d├Ân├╝┼čt├╝rmesini sa─člar - a * a * a * a * a * a - den farkl─▒ g├Âr├╝n├╝yor ancak yine de hata aral─▒─č─▒nda bir say─▒ hesapl─▒yor a * a * a * a * a * a. Bu tamam, ├ž├╝nk├╝ zaten ideal say─▒larla de─čil aral─▒klarla ├žal─▒┼čt─▒─č─▒n─▒z─▒ biliyorsunuz.


51


2011-06-23





Hen├╝z hi├žbir poster, y├╝zer ifadelerin daralmas─▒ndan bahsetmemi┼čtir (ISO C standard─▒, 6.5p8 ve 7.12.2). E─čer FP_CONTRACT pragma ayarlan─▒rsa ON , derleyicinin a*a*a*a*a*a tek bir yuvarlama ile tam olarak de─čerlendirilmi┼č gibi tek bir i┼člem gibi bir ifadeye bakmas─▒na izin verilir . ├ľrne─čin, bir derleyici bunu hem daha h─▒zl─▒ hem de daha do─čru olan dahili bir g├╝├ž i┼člevi ile de─či┼čtirebilir. Bu, davran─▒┼č, programc─▒ taraf─▒ndan do─črudan kaynak kodunda k─▒smen kontrol edildi─činden, son kullan─▒c─▒ taraf─▒ndan sa─članan derleyici se├ženekleri bazen yanl─▒┼č kullan─▒labildi─činden, ├Âzellikle ilgin├žtir.

FP_CONTRACT Pragman─▒n varsay─▒lan durumu uygulama taraf─▒ndan tan─▒mlanm─▒┼čt─▒r, b├Âylece bir derleyicinin varsay─▒lan olarak bu t├╝r optimizasyonlar─▒ yapmas─▒na izin verilir. Bu nedenle, IEEE 754 kurallar─▒n─▒ kesinlikle uygulaman─▒z gereken ta┼č─▒nabilir kod a├ž─▒k├ža ayarlaman─▒z gerekir OFF .

Bir derleyici bu pragmay─▒ desteklemiyorsa, geli┼čtiricinin ayarlamay─▒ se├žti─či durumlarda b├Âyle bir optimizasyondan ka├ž─▒narak muhafazakar olmal─▒d─▒r OFF .

GCC bu pragmay─▒ desteklemiyor, ancak varsay─▒lan se├ženeklerle, ├Âyle oldu─čunu varsay─▒yor ON ; bu nedenle, bir donan─▒m FMA's─▒ olan hedefler i├žin, e─čer biri a*b+c fma (a, b, c) 'ye d├Ân├╝┼č├╝m├╝ ├Ânlemek istiyorsa, (pragmay─▒ -ffp-contract=off a├ž─▒k├ža ayarlamak i├žin OFF ) veya -std=c99 (GCCÔÇÖnin C standart s├╝r├╝m, burada C99, bu nedenle yukar─▒daki paragraf─▒ izleyin). Ge├žmi┼čte, ikinci se├ženek d├Ân├╝┼č├╝m├╝ engellemiyordu; bu, GCC'nin bu noktada uymad─▒─č─▒ anlam─▒na geliyordu: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37845


32







Lambdageek'in y├╝zd├╝rme ├žarp─▒m─▒n─▒n ili┼čkisel olmad─▒─č─▒n─▒ ve daha az do─čruluk elde edebilece─čini belirtti─či gibi, daha iyi bir do─čruluk elde etti─činizde, deterministik bir uygulama istedi─činiz i├žin optimizasyona kar┼č─▒ ├ž─▒kabilirsiniz. ├ľrne─čin, oyun sim├╝lasyonu istemcisinde / sunucusunda, her m├╝┼čterinin ayn─▒ d├╝nyay─▒ sim├╝le etmesi gerekti─či yerde, kayan nokta hesaplar─▒n─▒n deterministik olmas─▒n─▒ istersiniz.


28







Bu davan─▒n optimize edilmesini beklemiyordum. Bir ifadenin, t├╝m i┼člemleri kald─▒rmak i├žin yeniden toplanabilen alt ifadeler i├žerdi─či yerlerde ├žok s─▒k olamaz. Derleyici yazarlar─▒n zamanlar─▒n─▒, nadiren kar┼č─▒la┼č─▒lan bir son durumu ele almak yerine, dikkate de─čer geli┼čmelere neden olacak alanlara yat─▒rmalar─▒n─▒ beklerdim.

Di─čer cevaplardan bu ifadenin ger├žekten uygun derleyici anahtarlar─▒ ile optimize edilebilece─čini ├Â─črendi─čimde ┼ča┼č─▒rd─▒m. Optimizasyon ├Ânemsizdir veya ├žok daha yayg─▒n bir optimizasyonun son halidir veya derleyici yazarlar─▒ son derece kapsaml─▒d─▒r.

Burada yapt─▒─č─▒n─▒z gibi derleyiciye ipucu vermede yanl─▒┼č bir ┼čey yoktur. Hangi farkl─▒l─▒klar─▒ getireceklerini g├Ârmek i├žin ifadeleri ve ifadeleri yeniden d├╝zenlemek, mikro optimizasyon i┼čleminin normal ve beklenen bir par├žas─▒d─▒r.

Derleyici tutars─▒z sonu├žlar (uygun anahtarlar olmadan) sunmak i├žin iki ifadeyi g├Âz ├Ân├╝nde bulundurarak hakl─▒ g├Âr├╝nse de, bu k─▒s─▒tlamaya ba─čl─▒ kalman─▒za gerek yoktur. Fark inan─▒lmaz derecede k├╝├ž├╝k olacak - o kadar ki fark sizin i├žin ├Ânemliyse, ilk ├Ânce standart kayan nokta aritmetik kullanmaman─▒z gerekir.


28







"Pow" gibi k├╝t├╝phane fonksiyonlar─▒, genellikle asgari hatay─▒ (genel durumda) elde etmek i├žin ├Âzenle olu┼čturulur. Bu genellikle spline'larla yakla┼č─▒k fonksiyonlara ula┼č─▒r (Pascal'─▒n yorumuna g├Âre en yayg─▒n uygulama Remez algoritmas─▒n─▒ kullan─▒yor gibi g├Âr├╝n├╝yor )

temelde a┼ča─č─▒daki i┼člem:

 pow(x,y);
 

Herhangi bir tek ├žarpma veya b├Âlmedeki hata ile yakla┼č─▒k olarak ayn─▒ b├╝y├╝kl├╝kte bir do─čal hataya sahiptir .

A┼ča─č─▒daki i┼člem s─▒ras─▒nda:

 float a=someValue;
float b=a*a*a*a*a*a;
 

Tek bir ├žarpma veya b├Âlme hatas─▒n─▒n 5 kat─▒ndan daha b├╝y├╝k do─čal bir hataya sahiptir (├ž├╝nk├╝ 5 ├žarp─▒m─▒ birle┼čtiriyorsunuzdur).

Derleyici yapt─▒─č─▒ optimizasyon t├╝r├╝ne ├žok dikkat etmelidir:

  1. optimize e─čer pow(a,6) i├žin a*a*a*a*a*a o olabilir performans─▒n─▒ art─▒rmak, ancak b├╝y├╝k ├Âl├ž├╝de kayan nokta say─▒lar─▒ i├žin do─črulu─čunu azaltabilir.
  2. optimize e─čer a*a*a*a*a*a i├žin pow(a,6) o asl─▒nda do─črulu─čunu d├╝┼č├╝rebilir "a" hatas─▒ (2'nin kuvvetlerine veya baz─▒ k├╝├ž├╝k tamsay─▒ say─▒) olmadan ├žarpma verir baz─▒ ├Âzel de─čeri oldu─čundan
  3. i┼člevine g├Âre optimize pow(a,6) etmek (a*a*a)*(a*a*a) veya optimizasyon yapmak (a*a)*(a*a)*(a*a) hala do─čruluk kayb─▒ olabilir pow .

Genel olarak, rastgele kayan nokta de─čerleri i├žin "pow" in sonunda yazabildi─činiz herhangi bir fonksiyondan daha iyi bir do─črulu─ča sahip oldu─čunu biliyorsunuzdur, ancak baz─▒ ├Âzel durumlarda ├žoklu ├žarpmalar─▒n daha iyi do─čruluk ve performansa sahip olabilece─či, geli┼čtiricinin daha uygun olan─▒ se├žti─či, sonunda kodun yorumlanmas─▒, b├Âylece ba┼čka hi├ž kimse bu kodu "optimize etmeyecek".

Optimize etmek i├žin mant─▒kl─▒ olan (ki┼čisel g├Âr├╝┼č ve g├Âr├╝n├╝┼če g├Âre GCC'de bir se├žim, belirli bir optimizasyon veya derleyici bayra─č─▒n─▒n bulunmas─▒) tek ┼čey "pow (a, 2)" yerine "a * a" kullanmak olmal─▒d─▒r. Bir derleyici sat─▒c─▒s─▒n─▒n yapmas─▒ gereken tek mant─▒kl─▒ ┼čey bu olurdu.


28







Bu soruya zaten birka├ž iyi cevap var, ancak tamaml─▒k u─čruna, C standard─▒n─▒n uygulanabilir b├Âl├╝m├╝n├╝n 5.1.2.2.3 / 15 oldu─čunu belirtmek istedim (bu, C ++ 11 standard─▒). Bu b├Âl├╝m, operat├Ârlerin yaln─▒zca ger├žekten birle┼čtirici veya de─či┼čtirici olmalar─▒ durumunda yeniden toplanabilece─čini belirtir.


21







gcc asl─▒nda kayan nokta say─▒lar─▒ i├žin bile bu optimizasyonu yapabilir. ├ľrne─čin,

 double foo(double a) {
  return a*a*a*a*a*a;
}
 

olur

 foo(double):
    mulsd   %xmm0, %xmm0
    movapd  %xmm0, %xmm1
    mulsd   %xmm0, %xmm1
    mulsd   %xmm1, %xmm0
    ret
 

ile -O -funsafe-math-optimizations . Bu yeniden s─▒ralama IEEE-754'├╝ ihlal ediyor olsa da bayra─č─▒n─▒ gerektiriyor.

Peter Cordes'in bir yorumunda i┼čaret etti─či gibi, i┼čaretlenmi┼č tamsay─▒lar, bu optimizasyonu -funsafe-math-optimizations tam olarak ta┼čma olmad─▒─č─▒nda ve ta┼čma varsa tan─▒ms─▒z davran─▒┼člarla kar┼č─▒ kar┼č─▒ya kald─▒─č─▒ i├žin yapabilir. Yani olsun

 foo(long):
    movq    %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rdi, %rax
    imulq   %rax, %rax
    ret
 

Sadece ile -O . ─░mzas─▒z tamsay─▒lar i├žin, 2 mod g├╝c├╝ kulland─▒klar─▒ i├žin daha da kolayd─▒r ve ta┼čma kar┼č─▒s─▒nda bile serbest├že yeniden s─▒ralanabilir.


12



─░lgili yay─▒nlar


H─▒z yerine boyut i├žin optimize ediyorsam neden GCC% 15-20 daha h─▒zl─▒ kod ├╝retiyor?

GCC neden tamsay─▒l─▒ b├Âlme i┼čleminde garip bir say─▒ ile ├žarp─▒m─▒ kullan─▒yor?

GCC neden hemen hemen ayn─▒ C kodu i├žin bu kadar farkl─▒ bir montaj ├╝retiyor?

╬Ť-calculus optimal de─čerlendiricileri neden b├╝y├╝k mod├╝ler ├╝stelleri form├╝ls├╝z olarak hesaplayabiliyor?

Clang neden x * 1.0'─▒ optimize etmiyor ama x + 0.0 de─čil?

Gcc'nin C'deki baz─▒ ifadeleri optimize etmesi nas─▒l ├Ânlenir?

Ka├ž tane GCC optimizasyon seviyesi var?

Gcc neden arg├╝manlar─▒n arg├╝mans─▒z olarak tan─▒mlanm─▒┼č bir fonksiyona ge├žirilmesine izin veriyor?

Neden memcmp (a, b, 4) sadece bazen bir uint32 kar┼č─▒la┼čt─▒rmas─▒ i├žin optimize edilmi┼čtir?

Tampon ta┼čmas─▒n─▒ etkinle┼čtirmek i├žin gcc derleyici optimizasyonunu nas─▒l devre d─▒┼č─▒ b─▒rak─▒l─▒r

Etiketle ilgili di─čer sorular [gcc]


Bir URLÔÇÖnin farkl─▒ taray─▒c─▒lardaki maksimum uzunlu─ču nedir?

JQuery ile bir onay kutusu i├žin "kontrol" ayarland─▒?

Uzak bir etiket nas─▒l silinir?

SerialVersionUID nedir ve neden kullanmal─▒y─▒m?

Harf b├╝y├╝kl├╝─č├╝ne duyars─▒z 'Contains (string)'

Git'i kullanarak bir etiketi uzak bir havuza nas─▒l iter?

Java'da bir dize de─čerinden enum de─čeri nas─▒l al─▒n─▒r?

Bir kullan─▒c─▒ bir liste ├Â─česi ├╝zerine geldi─činde imleci bir el yap─▒n

C++ 11 standart bir bellek modeli tan─▒tt─▒. Bunun anlam─▒ ne? Ve C++ programlamay─▒ nas─▒l etkileyecek?

Yeni sat─▒r veya bo┼čluk olmadan nas─▒l yazd─▒r─▒l─▒r?