ทำไม GCC จึงไม่ปรับ a * a * a * a * a ถึง (a * a * a) * (a * a * a)?

ฉันกำลังทำการเพิ่มประสิทธิภาพเชิงตัวเลขในแอปพลิเคชันทางวิทยาศาสตร์ สิ่งหนึ่งที่ฉันสังเกตเห็นคือ GCC จะเพิ่มประสิทธิภาพการโทรpow(a,2)โดยรวบรวมมันเข้าไปa*aแต่การโทรpow(a,6)นั้นไม่ได้รับการปรับปรุงและจะเรียกฟังก์ชั่นห้องสมุดpowซึ่งทำให้ประสิทธิภาพช้าลงอย่างมาก (ตรงกันข้ามIntel C ++ Compiler ที่สามารถเรียกทำงานiccได้จะกำจัดการเรียกใช้ไลบรารีpow(a,6))

สิ่งที่ฉันอยากรู้คือเมื่อฉันแทนที่pow(a,6)ด้วยการa*a*a*a*a*aใช้ GCC 4.5.1 และตัวเลือก " -O3 -lm -funroll-loops -msse4" จะใช้ 5 mulsdคำสั่ง:

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

ในขณะที่ถ้าฉันเขียน(a*a*a)*(a*a*a)มันจะผลิต

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

ซึ่งลดจำนวนคำสั่งการคูณเป็น 3 iccมีพฤติกรรมที่คล้ายกัน

ทำไมคอมไพเลอร์ไม่รู้จักเคล็ดลับการเพิ่มประสิทธิภาพนี้

เพราะFloating Point คณิตศาสตร์ไม่ได้เชื่อมโยง วิธีที่คุณจัดกลุ่มตัวถูกดำเนินการในการคูณคะแนนแบบลอยมีผลต่อความแม่นยำเชิงตัวเลขของคำตอบ

ดังนั้นคอมไพเลอร์ส่วนใหญ่ค่อนข้างอนุรักษ์นิยมมากเกี่ยวกับการคำนวณการคำนวณจุดลอยตัวใหม่จนกว่าพวกเขาจะมั่นใจได้ว่าคำตอบจะยังคงเหมือนเดิมหรือถ้าคุณบอกพวกเขาว่าคุณไม่สนใจความถูกต้องเชิงตัวเลข ตัวอย่างเช่น: ตัวเลือกของ GCC GCC ซึ่งจะช่วยให้การดำเนินงาน reassociate จุดลอยหรือแม้กระทั่งตัวเลือกซึ่งจะช่วยให้เกิดความสมดุลแม้ก้าวร้าวมากขึ้นของความถูกต้องกับความเร็ว-fassociative-math-ffast-math

Lambdageekชี้ให้เห็นอย่างถูกต้องว่าเนื่องจากความสัมพันธ์ไม่ได้เก็บไว้สำหรับเลขทศนิยม, "การเพิ่มประสิทธิภาพ" ของa*a*a*a*a*aถึง(a*a*a)*(a*a*a)อาจเปลี่ยนค่า นี่คือเหตุผลที่มันไม่ได้รับอนุญาตจาก C99 (ยกเว้นกรณีที่ได้รับอนุญาตจากผู้ใช้ผ่านธงคอมไพเลอร์หรือ pragma) โดยทั่วไปแล้วสมมติฐานคือโปรแกรมเมอร์เขียนสิ่งที่เธอทำด้วยเหตุผลและคอมไพเลอร์ควรเคารพสิ่งนั้น ถ้าคุณต้องการ(a*a*a)*(a*a*a)เขียนว่า

นั่นอาจเป็นความเจ็บปวดที่จะเขียนแม้ว่า; ทำไมคอมไพเลอร์ไม่สามารถทำ [สิ่งที่คุณคิดว่าเป็น] สิ่งที่ถูกต้องเมื่อคุณใช้pow(a,6)? เพราะมันจะเป็นสิ่งที่ผิดที่ต้องทำ บนแพลตฟอร์มที่มีห้องสมุดคณิตศาสตร์ที่ดีpow(a,6)เป็นอย่างถูกต้องมากขึ้นกว่าหรือa*a*a*a*a*a (a*a*a)*(a*a*a)เพื่อให้ข้อมูลบางอย่างฉันทำการทดลองขนาดเล็กบน Mac Pro ของฉันวัดข้อผิดพลาดที่เลวร้ายที่สุดในการประเมิน ^ 6 สำหรับตัวเลขลอยตัวที่มีความแม่นยำเดี่ยวทั้งหมดระหว่าง [1,2):

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แทนของต้นไม้คูณช่วยลดข้อผิดพลาดผูกพันตามปัจจัย 4 คอมไพเลอร์ไม่ควร (และโดยทั่วไปจะไม่ทำ) "เพิ่มประสิทธิภาพ" ที่เพิ่มข้อผิดพลาดเว้นแต่ได้รับอนุญาตจากผู้ใช้ (เช่นผ่าน-ffast-math)

โปรดทราบว่า GCC __builtin_powi(x,n)เป็นทางเลือกpow( )ซึ่งควรสร้างแผนผังการคูณแบบอินไลน์ ใช้สิ่งนั้นหากคุณต้องการแลกเปลี่ยนความแม่นยำเพื่อประสิทธิภาพ แต่ไม่ต้องการเปิดใช้งานคณิตศาสตร์อย่างรวดเร็ว

อีกกรณีที่คล้ายกัน: คอมไพเลอร์ส่วนใหญ่จะไม่ปรับa + b + c + dให้เหมาะสม(a + b) + (c + d)(นี่คือการเพิ่มประสิทธิภาพเนื่องจากนิพจน์ที่สองสามารถไพพ์ไลน์ได้ดีกว่า) และประเมินตามที่กำหนด (เช่นเป็น(((a + b) + c) + d)) นี่ก็เป็นเพราะกรณีมุม:

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

ผลลัพธ์นี้ 1.000000e-05 0.000000e+00

Fortran (ออกแบบมาสำหรับการคำนวณทางวิทยาศาสตร์) มีตัวดำเนินการจ่ายไฟในตัวและเท่าที่ฉันรู้คอมไพเลอร์ Fortran โดยทั่วไปจะปรับการเพิ่มประสิทธิภาพให้เป็นจำนวนเต็มในแบบเดียวกับที่คุณอธิบาย C / C ++ pow()น่าเสียดายที่ไม่ได้มีผู้ประกอบการพลังงานเพียงฟังก์ชั่นห้องสมุด สิ่งนี้ไม่ได้ป้องกันคอมไพเลอร์สมาร์ทจากการปฏิบัติpowเป็นพิเศษและคำนวณมันในวิธีที่เร็วขึ้นสำหรับกรณีพิเศษ แต่ดูเหมือนว่าพวกเขาจะทำมันน้อยกว่าปกติ ...

หลายปีที่ผ่านมาฉันพยายามทำให้สะดวกยิ่งขึ้นในการคำนวณพลังงานจำนวนเต็มในวิธีที่ดีที่สุดและเกิดขึ้นกับสิ่งต่อไปนี้ มันคือ C ++ ไม่ใช่ C แม้ว่าและยังขึ้นอยู่กับคอมไพเลอร์ที่ค่อนข้างฉลาดเกี่ยวกับวิธีเพิ่มประสิทธิภาพ / อินไลน์สิ่งต่าง ๆ อย่างไรก็ตามหวังว่าคุณจะพบว่ามีประโยชน์ในทางปฏิบัติ:

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);
}

_{คำชี้แจงสำหรับคนที่อยากรู้อยากเห็น:สิ่งนี้ไม่ได้หาวิธีที่ดีที่สุดในการคำนวณพลัง แต่เนื่องจากการหาทางออกที่ดีที่สุดเป็นปัญหาที่สมบูรณ์แบบและนี่เป็นเพียงการทำเพื่อพลังขนาดเล็กเท่านั้น (เทียบกับการใช้pow) ไม่มีเหตุผลที่จะยุ่งยาก พร้อมรายละเอียด}

power<6>(a)แล้วก็ใช้มันเป็น

สิ่งนี้ทำให้ง่ายต่อการพิมพ์พลัง (ไม่จำเป็นต้องสะกดคำ 6 as ด้วย parens) และช่วยให้คุณมีการเพิ่มประสิทธิภาพแบบนี้โดยไม่ต้องใช้-ffast-mathในกรณีที่คุณมีสิ่งที่ต้องอาศัยความแม่นยำเช่นการสรุปผลรวม (ตัวอย่างที่จำเป็น .

คุณอาจลืมได้ว่านี่คือ C ++ และใช้ในโปรแกรม C (ถ้าคอมไพล์ด้วยคอมไพเลอร์ C ++)

หวังว่ามันจะมีประโยชน์

แก้ไข:

นี่คือสิ่งที่ฉันได้รับจากคอมไพเลอร์ของฉัน:

สำหรับa*a*a*a*a*a,

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

สำหรับ(a*a*a)*(a*a*a),

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

สำหรับpower<6>(a),

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

GCC จะปรับa*a*a*a*a*aให้เหมาะสมจริง ๆ(a*a*a)*(a*a*a)เมื่อ a เป็นจำนวนเต็ม ฉันลองด้วยคำสั่งนี้:

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

มีธง gcc มากมาย แต่ไม่มีอะไรแฟนซี พวกเขาหมายถึง: อ่านจาก stdin; ใช้ระดับการเพิ่มประสิทธิภาพ O2; รายการภาษาแอสเซมบลีเอาท์พุทแทนไบนารี รายการควรใช้ไวยากรณ์ภาษาแอสเซมบลีของ Intel อินพุตเป็นภาษา C (โดยปกติภาษาจะอนุมานจากนามสกุลไฟล์อินพุต แต่ไม่มีนามสกุลไฟล์เมื่ออ่านจาก stdin); และเขียนถึง stdout

นี่คือส่วนสำคัญของผลลัพธ์ ฉันได้ใส่คำอธิบายประกอบไว้ด้วยความคิดเห็นที่บ่งบอกว่าเกิดอะไรขึ้นในภาษาแอสเซมบลี:

; 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

ฉันใช้ระบบ GCC บน Linux Mint 16 Petra ซึ่งเป็นอนุพันธ์ของ Ubuntu นี่คือรุ่น gcc:

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

ดังที่ผู้โพสต์คนอื่น ๆ ได้ระบุไว้ตัวเลือกนี้ไม่สามารถทำได้ในจุดลอยตัวเนื่องจากเลขคณิตจุดลอยตัวนั้นไม่ได้เชื่อมโยงกัน

เพราะตัวเลขทศนิยม 32 บิต - เช่น 1.024 - ไม่ใช่ 1.024 ในคอมพิวเตอร์ 1.024 คือช่วงเวลา: จาก (1.024-e) ถึง (1.024 + e) ​​โดยที่ "e" หมายถึงข้อผิดพลาด บางคนไม่เข้าใจสิ่งนี้และเชื่อว่า * ใน * a หมายถึงการคูณจำนวนที่มีความแม่นยำโดยไม่มีข้อผิดพลาดใด ๆ สาเหตุที่บางคนล้มเหลวในการตระหนักถึงสิ่งนี้อาจเป็นเพราะการคำนวณทางคณิตศาสตร์ที่พวกเขาใช้ในโรงเรียนประถมศึกษา: การทำงานกับตัวเลขในอุดมคติโดยไม่มีข้อผิดพลาดติดอยู่และเชื่อว่ามันเป็นเรื่องปกติ พวกเขาไม่เห็น "e" โดยนัยใน "float a = 1.2", "a * a * a" และรหัส C ที่คล้ายกัน

หากโปรแกรมเมอร์ส่วนใหญ่รู้จัก (และสามารถใช้งานได้) ความคิดที่ว่าการแสดงออกของ C * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * a * a * a * a "พูด" t = (a * a); t * t * t "ซึ่งต้องการการคูณที่น้อยกว่า แต่น่าเสียดายที่คอมไพเลอร์ GCC ไม่ทราบว่าโปรแกรมเมอร์ที่เขียนโค้ดคิดว่า "a" เป็นตัวเลขที่มีหรือไม่มีข้อผิดพลาด ดังนั้น GCC จะทำในสิ่งที่ซอร์สโค้ดมีลักษณะเท่านั้น - เพราะนั่นคือสิ่งที่ GCC เห็นด้วย "ตาเปล่า"

... เมื่อคุณรู้ว่าคุณเป็นโปรแกรมเมอร์ประเภทใดคุณสามารถใช้สวิตช์ "-ffast-math" เพื่อบอก GCC ว่า "เฮ้ GCC ฉันรู้ว่าฉันกำลังทำอะไรอยู่!" วิธีนี้จะช่วยให้ GCC แปลง * a * a * a * a เป็นข้อความอื่นได้ - มันดูแตกต่างจาก * a * a * a * a * a - a แต่ยังคงคำนวณตัวเลขภายในช่วงข้อผิดพลาดของ A * A * A * A * ที่ * ไม่เป็นไรเพราะคุณรู้อยู่แล้วว่าคุณกำลังทำงานกับช่วงเวลาไม่ใช่ตัวเลขในอุดมคติ

ยังไม่มีผู้โพสต์ที่กล่าวถึงการหดตัวของนิพจน์ลอยตัว (มาตรฐาน ISO C, 6.5p8 และ 7.12.2) หากว่าFP_CONTRACTตั้งค่า pragma ไว้ONคอมไพเลอร์จะได้รับอนุญาตให้พิจารณานิพจน์เช่นa*a*a*a*a*aการดำเนินการเดียวราวกับว่าประเมินด้วยการปัดเศษเพียงครั้งเดียว ตัวอย่างเช่นคอมไพเลอร์อาจแทนที่ด้วยฟังก์ชันพลังงานภายในที่ทั้งเร็วขึ้นและแม่นยำยิ่งขึ้น สิ่งนี้น่าสนใจเป็นพิเศษเนื่องจากพฤติกรรมถูกควบคุมโดยโปรแกรมเมอร์บางส่วนโดยตรงในซอร์สโค้ดในขณะที่บางครั้งตัวเลือกคอมไพเลอร์จากผู้ใช้อาจถูกใช้อย่างไม่ถูกต้อง

สถานะเริ่มต้นของ FP_CONTRACT pragma ถูกกำหนดโดยการนำไปใช้งานเพื่อให้คอมไพเลอร์ได้รับอนุญาตให้ทำการปรับแต่งเช่นนี้ให้เป็นค่าเริ่มต้น ดังนั้นรหัสพกพาที่ต้องปฏิบัติตามกฎ IEEE 754 อย่างเคร่งครัดควรตั้งเป็นOFFกฎควรกำหนดอย่างชัดเจนว่ามัน

ถ้าคอมไพเลอร์ไม่สนับสนุน pragma OFFนี้มันจะต้องเป็นแบบอนุรักษ์นิยมโดยการหลีกเลี่ยงการเพิ่มประสิทธิภาพดังกล่าวในกรณีที่นักพัฒนาที่ได้เลือกที่จะตั้งค่าให้

GCC ไม่สนับสนุน pragma นี้ แต่มีตัวเลือกเริ่มต้นที่จะอนุมานว่ามันจะON; ดังนั้นสำหรับเป้าหมายที่มีฮาร์ดแวร์ FMA หากต้องการป้องกันการแปลงa*b+cเป็น fma (a, b, c) เราจำเป็นต้องจัดเตรียมตัวเลือกเช่น-ffp-contract=off(เพื่อกำหนด pragma ให้ชัดเจนOFF) หรือ-std=c99(เพื่อบอก GCC ให้สอดคล้องกับบางอย่าง รุ่นมาตรฐาน C ที่นี่ C99 จึงเป็นไปตามย่อหน้าด้านบน) ในอดีตตัวเลือกหลังไม่ได้ป้องกันการเปลี่ยนแปลงซึ่งหมายความว่า GCC ไม่สอดคล้องกับประเด็นนี้: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37845

Lambdageek ชี้ให้เห็นว่าการคูณแบบลอยนั้นไม่ได้เชื่อมโยงกันและคุณจะได้รับความแม่นยำน้อยลง แต่เมื่อได้รับความแม่นยำที่ดีกว่าคุณสามารถโต้แย้งการปรับให้เหมาะสมเพราะคุณต้องการแอปพลิเคชันที่กำหนดค่าได้ ตัวอย่างเช่นในไคลเอนต์การจำลองเกม / เซิร์ฟเวอร์ที่ไคลเอนต์ทุกคนต้องจำลองโลกเดียวกันที่คุณต้องการให้การคำนวณจุดลอยตัวเป็นที่แน่นอน

ฟังก์ชันไลบรารีเช่น "pow" มักถูกสร้างขึ้นอย่างระมัดระวังเพื่อให้ได้ข้อผิดพลาดน้อยที่สุด (ในกรณีทั่วไป) นี่คือความสำเร็จโดยประมาณฟังก์ชั่นที่มีเส้นโค้ง (ตามความคิดเห็นของปาสคาลการใช้งานทั่วไปที่ดูเหมือนจะใช้อัลกอริทึม Remez )

การดำเนินงานพื้นฐานดังต่อไปนี้:

pow(x,y);

มีข้อผิดพลาดโดยธรรมชาติที่มีขนาดใกล้เคียงกับข้อผิดพลาดในการคูณหรือการหารเดี่ยวใด ๆขนาดเดียวกับข้อผิดพลาดในการคูณเดียวหรือแบ่ง

ในขณะที่การดำเนินการดังต่อไปนี้:

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

มีข้อผิดพลาดโดยธรรมชาติที่มากกว่า5 เท่าของข้อผิดพลาดของการคูณเดียวหรือการหาร (เพราะคุณรวม 5 การคูณ)

คอมไพเลอร์ควรจะระมัดระวังกับชนิดของการปรับให้เหมาะสมที่สุดที่กำลังทำอยู่:

1. ถ้าการเพิ่มประสิทธิภาพpow(a,6)ให้กับa*a*a*a*a*aมันอาจจะปรับปรุงประสิทธิภาพการทำงาน แต่ลดความถูกต้องสำหรับตัวเลขทศนิยม
2. หากการปรับa*a*a*a*a*a ให้เหมาะสมpow(a,6)อาจลดความถูกต้องได้จริงเพราะ "a" เป็นค่าพิเศษบางอย่างที่ช่วยให้การคูณไม่มีข้อผิดพลาด (กำลัง 2 หรือจำนวนเต็มเล็กน้อย)
3. หากปรับpow(a,6)ให้เหมาะสม(a*a*a)*(a*a*a)หรือ(a*a)*(a*a)*(a*a)ยังคงมีการสูญเสียความถูกต้องเมื่อเทียบกับpowฟังก์ชั่น

โดยทั่วไปแล้วคุณรู้ว่าสำหรับจุดลอยตัวตามอำเภอใจ "pow" มีความแม่นยำที่ดีกว่าฟังก์ชั่นใด ๆ ที่คุณสามารถเขียนได้ในที่สุด แต่ในบางกรณีพิเศษหลายการคูณอาจมีความแม่นยำและประสิทธิภาพที่ดีขึ้น ในที่สุดการแสดงความคิดเห็นรหัสเพื่อให้ไม่มีใครจะ "เพิ่มประสิทธิภาพ" รหัสนั้น

สิ่งเดียวที่สมเหตุสมผล (ความเห็นส่วนตัวและเห็นได้ชัดว่าเป็นทางเลือกใน GCC ที่ไม่มีการเพิ่มประสิทธิภาพหรือการตั้งค่าสถานะคอมไพเลอร์ใด ๆ ) เพื่อปรับให้เหมาะสมควรแทนที่ "pow (a, 2)" ด้วย "a * a" นั่นเป็นเพียงสิ่งเดียวที่ผู้จำหน่ายคอมไพเลอร์ควรทำ

ฉันไม่คาดหวังว่ากรณีนี้จะได้รับการเพิ่มประสิทธิภาพเลย ไม่บ่อยนักที่นิพจน์มีนิพจน์ย่อยที่สามารถจัดกลุ่มใหม่เพื่อลบการดำเนินการทั้งหมด ฉันคาดว่าผู้เขียนคอมไพเลอร์จะลงทุนเวลาของพวกเขาในพื้นที่ซึ่งมีแนวโน้มที่จะส่งผลให้มีการปรับปรุงที่เห็นได้ชัดเจนแทนที่จะครอบคลุมกรณีขอบไม่ค่อยพบ

ฉันรู้สึกประหลาดใจที่ได้เรียนรู้จากคำตอบอื่น ๆ ที่การแสดงออกนี้สามารถปรับให้เหมาะสมกับสวิตช์คอมไพเลอร์ที่เหมาะสม การปรับให้เหมาะสมนั้นไม่สำคัญหรือเป็นกรณีของการเพิ่มประสิทธิภาพที่พบได้ทั่วไปมากขึ้นหรือผู้เขียนคอมไพเลอร์นั้นละเอียดมาก

ไม่มีอะไรผิดปกติกับการให้คำแนะนำแก่คอมไพเลอร์ในขณะที่คุณทำที่นี่ เป็นส่วนปกติและเป็นที่คาดหวังของกระบวนการเพิ่มประสิทธิภาพขนาดเล็กเพื่อจัดเรียงข้อความและสำนวนใหม่เพื่อดูว่าพวกเขาจะนำความแตกต่างมาใช้อย่างไร

ในขณะที่คอมไพเลอร์อาจมีเหตุผลในการพิจารณาสองนิพจน์เพื่อให้ผลลัพธ์ที่ไม่สอดคล้องกัน (ไม่มีสวิตช์ที่เหมาะสม) คุณไม่จำเป็นต้องผูกพันตามข้อ จำกัด ดังกล่าว ความแตกต่างจะเล็กอย่างไม่น่าเชื่อ - มากจนถ้าความแตกต่างสำคัญกับคุณคุณไม่ควรใช้เลขคณิตจุดลอยตัวมาตรฐานในตอนแรก

มีคำตอบที่ดีอยู่เล็กน้อยสำหรับคำถามนี้ แต่เพื่อความสมบูรณ์ฉันต้องการชี้ให้เห็นว่าส่วนที่บังคับใช้ของมาตรฐาน C คือ 5.1.2.2.3 / 15 (ซึ่งเหมือนกับมาตรา 1.9 / 9 ใน มาตรฐาน C ++ 11) ส่วนนี้ระบุว่าโอเปอเรเตอร์สามารถจัดกลุ่มใหม่ได้หากมีการเชื่อมโยงหรือสับเปลี่ยนจริงๆ

gcc จริง ๆ แล้วสามารถทำการเพิ่มประสิทธิภาพนี้ได้แม้จะเป็นเลขทศนิยมก็ตาม ตัวอย่างเช่น,

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

กลายเป็น

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

-O -funsafe-math-optimizationsกับ การเรียงลำดับใหม่นี้ละเมิด IEEE-754 ดังนั้นจึงจำเป็นต้องมีการตั้งค่าสถานะ

เลขจำนวนเต็มที่ลงนามตามที่ Peter Cordes ชี้ให้เห็นในความคิดเห็นสามารถทำการเพิ่มประสิทธิภาพนี้ได้โดยไม่ต้อง-funsafe-math-optimizationsมีการเก็บรักษาอย่างแน่นอนเมื่อไม่มีการล้นและหากมีการล้นคุณจะได้รับพฤติกรรมที่ไม่ได้กำหนด ดังนั้นคุณจะได้รับ

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

-Oมีเพียง สำหรับเลขจำนวนเต็มที่ไม่ได้ลงนามมันง่ายยิ่งกว่าเพราะมันทำงานกับ mod mod ที่ 2 และสามารถจัดลำดับใหม่ได้อย่างอิสระแม้ในหน้าล้น