GCC විසින් * a * a * a * a * a (a * a * a) * (a * a * a) ප්‍රශස්තිකරණය නොකරන්නේ ඇයි?

මම විද්‍යාත්මක යෙදුමක් මත සංඛ්‍යාත්මක ප්‍රශස්තිකරණයක් කරමි. මා දුටු එක් දෙයක් නම්, GCC විසින් ඇමතුම pow(a,2)සම්පාදනය කිරීමෙන් එය ප්‍රශස්ත කරනු ඇති a*aනමුත් ඇමතුම pow(a,6)ප්‍රශස්තිකරණය කර නොමැති අතර ඇත්ත වශයෙන්ම පුස්තකාල ක්‍රියාකාරිත්වය අමතනු ඇත pow, එමඟින් කාර්ය සාධනය බෙහෙවින් මන්දගාමී වේ. (ඊට වෙනස්ව, ක්‍රියාත්මක කළ හැකි ඉන්ටෙල් සී ++ සම්පාදකයicc පුස්තකාල ඇමතුම ඉවත් කරයි pow(a,6).)

මම කුතුහලයෙන් සිටිමි මම වෙනුවට විට බව ය pow(a,6)සමඟ a*a*a*a*a*a"ගල්ෆ් 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දක්වා අඩු කරයි .

සම්පාදකයින් මෙම ප්‍රශස්තිකරණ උපක්‍රමය හඳුනා නොගන්නේ ඇයි?

නිසා ඉපිලුම් ලක්ෂ්ය ගණිතය Associative නොවේ . පාවෙන ලක්ෂ්‍ය ගුණ කිරීමේ දී ඔබ ක්‍රියාකරන ආකාරය පිළිතුරේ සංඛ්‍යාත්මක නිරවද්‍යතාවයට බලපායි.

එහි ප්‍රති As ලයක් වශයෙන්, බොහෝ සම්පාදකයින් පාවෙන ලක්ෂ්‍ය ගණනය කිරීම් නැවත සකස් කිරීම පිළිබඳව ඉතා සාම්ප්‍රදායික වන අතර, පිළිතුර එලෙසම පවතිනු ඇති බවට ඔවුන්ට සහතික විය නොහැකි නම් හෝ සංඛ්‍යාත්මක නිරවද්‍යතාව ගැන ඔබ තැකීමක් නොකරයි. උදාහරණයක් ලෙස: ද -fassociative-mathවිකල්පය gcc ඉපිලුම් ලක්ෂ්ය reassociate කිරීමට ඉඩ සලසා දෙයි gcc කිරීම හෝ පවා -ffast-mathවේගය එරෙහිව නිරවද්යතාවය වඩාත් ආක්රමණශීලී එබැව්න් ගවේෂණශීලි ඉඩ සලසා දෙයි විකල්පය.

Lambdageek නිවැරදිව associativity ඉපිලුම් ලක්ෂ්ය සංඛ්යා සඳහා පැවැත්වීමට නැති නිසා, වන "ප්රශස්තිකරණය" බව පෙන්වා දෙයිa*a*a*a*a*aකිරීමට(a*a*a)*(a*a*a)වටිනාකම වෙනස් විය හැක. C99 විසින් එය තහනම් කර ඇත්තේ මේ නිසාය (පරිශීලකයා විසින් විශේෂයෙන් අවසර දී නොමැති නම්, සම්පාදක ධජය හෝ ප්‍රාග්මා හරහා). සාමාන්‍යයෙන් උපකල්පනය වන්නේ ක්‍රමලේඛකයා ඇය කළ දේ යම් හේතුවක් නිසා ලියා ඇති අතර සම්පාදකයා එයට ගරු කළ යුතු බවයි. ඔබට අවශ්‍ය(a*a*a)*(a*a*a)නම් එය ලියන්න.

එය ලිවීමට වේදනාවක් විය හැකියි. ඔබ භාවිතා කරන විට සම්පාදකයාට [ඔබ සලකන දේ] නිවැරදි දේ කළ නොහැක්කේ ඇයි pow(a,6)? මන්ද එය වැරදි දෙයකි. හොඳ ගණිත පුස්තකාලයක් ඇති වේදිකාවක, pow(a,6)හෝ a*a*a*a*a*aඊට වඩා සැලකිය යුතු තරම් නිවැරදි ය (a*a*a)*(a*a*a). සමහර දත්ත සැපයීම සඳහා, මම මගේ මැක් ප්‍රෝ හි කුඩා අත්හදා බැලීමක් කළෙමි, [1,2) අතර ඇති සියලුම තනි නිරවද්‍යතාවයෙන් යුත් පාවෙන අංක සඳහා ඩොලර් 6 ක් තක්සේරු කිරීමේ දරුණුතම දෝෂය මැනීම:

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) දෝෂ වැඩි කරන “ප්‍රශස්තිකරණය” නොකළ යුතුය .

ආන්තරික ගුණ කිරීමේ ගසක් ජනනය කළ යුතු __builtin_powi(x,n)විකල්පයක් ලෙස GCC සපයන බව සලකන්න 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

ෆෝට්රාන් (විද්‍යාත්මක පරිගණනය සඳහා නිර්මාණය කර ඇති) සතුව බල සැපයුම්කරුවෙකු සිටින අතර, මා දන්නා පරිදි ෆෝට්රාන් සම්පාදකයින් සාමාන්‍යයෙන් ඔබ විස්තර කරන දෙයට සමාන ආකාරයකින් පූර්ණ සංඛ්‍යා දක්වා ඉහළ නැංවීම ප්‍රශස්ත කරනු ඇත. 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).

මෙය බලතල ටයිප් කිරීම පහසු කරයි ( aපරෙන්ස් සමඟ තත්පර 6 ක් අක්ෂර වින්‍යාසය කිරීමට අවශ්‍ය නැත ), සහ ඔබට වන්දි ගෙවන සාරාංශය-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). මම මෙම විධානය සමඟ උත්සාහ කළෙමි:

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

Gcc ධජ විශාල ප්‍රමාණයක් ඇති නමුත් කිසිවක් විසිතුරු නොවේ. ඔවුන් අදහස් කරන්නේ: stdin වෙතින් කියවන්න; O2 ප්‍රශස්තිකරණ මට්ටම භාවිතා කරන්න; ද්විමය වෙනුවට ප්‍රතිදාන එකලස් කිරීමේ භාෂා ලැයිස්තුගත කිරීම; ලැයිස්තුගත කිරීම ඉන්ටෙල් එකලස් කිරීමේ භාෂා සින්ටැක්ස් භාවිතා කළ යුතුය; ආදානය සී භාෂාවෙන් ඇත (සාමාන්‍යයෙන් භාෂාව ආදාන ගොනු දිගුවෙන් අනුමාන කෙරේ, නමුත් 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

මම උබුන්ටු ව්‍යුත්පන්නයක් වන ලිනක්ස් මින්ට් 16 පෙට්‍රා හි පද්ධති ජීසීසී භාවිතා කරමි. මෙන්න 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 = 1.2", "a * a * a" සහ ඒ හා සමාන C කේත වල "e" ඇඟවුම් ඔවුන් දකින්නේ නැත.

සී ප්‍රකාශනය a * a * a * a * a * a ඇත්ත වශයෙන්ම පරිපූර්ණ සංඛ්‍යා සමඟ ක්‍රියා නොකරයි යන අදහස බොහෝ ක්‍රමලේඛකයින් හඳුනාගෙන (ක්‍රියාත්මක කිරීමට හැකි නම්), GCC සම්පාදකයා “a * a ප්‍රශස්තිකරණය සඳහා නොමිලේ වේ. * a * a * a * a ”කියන්නට” t = (a * a); t * t * t ”සඳහා කුඩා ගුණනයක් අවශ්‍ය වේ. නමුත් අවාසනාවකට මෙන්, කේතය ලියන ක්‍රමලේඛකයා සිතන්නේ "a" යනු දෝෂයක් සහිත හෝ නැති අංකයක් යැයි GCC සම්පාදකයා නොදනී. එබැවින් GCC විසින් කරනු ලබන්නේ ප්‍රභව කේතය පෙනෙන ආකාරයට පමණි - මන්ද එය GCC සිය “පියවි ඇසින්” දකින බැවිනි.

... ඔබ වගේ ක්රමලේඛකයෙක් වන දේ දැන වරක් ඔබ , ඔබ සහ ගල්ෆ් කියන්න "හේයි, ගල්ෆ්, මම මා කරන්නේ මොකක්ද කියලා!" ඒ '-ffast-ගණිත "ස්විචය භාවිතා කළ හැකිය. මෙය * a * a * a * a * a වෙනත් පෙළ කැබැල්ලක් බවට පරිවර්තනය කිරීමට GCC ට ඉඩ දෙනු ඇත - එය * a * a * a * a * a ට වඩා වෙනස් ලෙස පෙනේ - නමුත් දෝෂ කාල පරතරය තුළ තවමත් සංඛ්‍යාවක් ගණනය කරයි a * a * a * a * a * a. මෙය හරි ය, මන්ද ඔබ වැඩ කරන්නේ පරමාදර්ශී සංඛ්‍යා සමඟ නොව කාල පරතරයන් සමඟ බව ඔබ දැනටමත් දන්නා බැවිනි.

පාවෙන ප්‍රකාශනවල හැකිලීම පිළිබඳව කිසිදු පෝස්ටරයක මෙතෙක් සඳහන් කර නොමැත (ISO C ප්‍රමිතිය, 6.5p8 සහ 7.12.2). FP_CONTRACTප්‍රාග්මාව සකසා ඇත්නම් ON, සම්පාදකයාට a*a*a*a*a*aතනි මෙහෙයුමක් වැනි ප්‍රකාශනයක් සලකා බැලීමට අවසර දෙනු ලැබේ . නිදසුනක් ලෙස, සම්පාදකයෙකු එය වේගවත් හා වඩා නිවැරදි අභ්‍යන්තර බල ශ්‍රිතයක් මගින් ප්‍රතිස්ථාපනය කළ හැකිය. ක්‍රමලේඛකයා විසින් හැසිරීම සෘජුවම ප්‍රභව කේතයෙන් පාලනය වන බැවින් මෙය විශේෂයෙන් සිත්ගන්නා සුළු වන අතර අවසාන පරිශීලකයා විසින් සපයනු ලබන සම්පාදක විකල්ප සමහර විට වැරදි ලෙස භාවිතා කළ හැකිය.

FP_CONTRACTප්‍රාග්මා හි පෙරනිමි තත්වය ක්‍රියාත්මක කිරීම-නිර්වචනය කර ඇති අතර එමඟින් සම්පාදකයෙකුට පෙරනිමියෙන් එවැනි ප්‍රශස්තිකරණයන් කිරීමට අවසර දෙනු ලැබේ. එබැවින් IEEE 754 රීති දැඩි ලෙස අනුගමනය කළ යුතු අතේ ගෙන යා හැකි කේතය එය පැහැදිලිවම සැකසිය යුතුය OFF.

සම්පාදකයෙකු මෙම ප්‍රායෝගිකයට සහය නොදක්වන්නේ නම්, සංවර්ධකයා විසින් එය සැකසීමට තෝරාගෙන තිබේ නම්, එවැනි ප්‍රශස්තිකරණයකින් වැළකී එය ගතානුගතික විය යුතුය OFF.

GCC මෙම ප්‍රායෝගිකයට සහය නොදක්වයි, නමුත් පෙරනිමි විකල්ප සමඟ එය එය යැයි උපකල්පනය කරයි ON; දෘඩාංග එෆ්එම්ඒ සමඟ ඉලක්ක සඳහා, යමෙකුට a*b+cඑෆ්මා (අ, ආ, සී) බවට පරිවර්තනය වීම වැළැක්වීමට අවශ්‍ය නම්, යමෙකුට (ප්‍රායෝගිකව -ffp-contract=offපැහැදිලිවම සැකසීමට OFF) හෝ -std=c99(සමහරුන්ට අනුකූල වන ලෙස ජීසීසීයට පැවසීමට ) වැනි විකල්පයක් සැපයිය යුතුය. සී සම්මත අනුවාදය, මෙහි C99, මේ අනුව ඉහත ඡේදය අනුගමනය කරන්න). අතීතයේ දී, දෙවන විකල්පය පරිවර්තනය වැළැක්වීම නොවේ, එයින් අදහස් වන්නේ GCC මෙම කරුණට අනුකූල නොවන බවයි: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37845

ලැම්බඩගීක් පෙන්වා දුන් පරිදි, පාවෙන ගුණ කිරීම අනුබද්ධ නොවන අතර ඔබට අඩු නිරවද්‍යතාවයක් ලබා ගත හැකිය, නමුත් වඩා හොඳ නිරවද්‍යතාවයක් ලබා ගත් විට ඔබට ප්‍රශස්තකරණයට එරෙහිව තර්ක කළ හැකිය, මන්ද ඔබට නිශ්චිත යෙදුමක් අවශ්‍යය. උදාහරණයක් ලෙස ක්‍රීඩා සමාකරණ සේවාදායකයා / සේවාදායකයා තුළ, සෑම සේවාදායකයෙකුටම එකම ලෝකය අනුකරණය කළ යුතු අතර, ඔබට අවශ්‍ය පාවෙන ලක්ෂ්‍ය ගණනය කිරීම් නිර්ණායක වේ.

"පවු" වැනි පුස්තකාල කාර්යයන් සාමාන්‍යයෙන් අවම වශයෙන් හැකි අවම දෝෂයක් ලබා දීම සඳහා ප්‍රවේශමෙන් සකසා ඇත (සාමාන්‍ය අවස්ථාවෙහිදී). මෙය සාමාන්‍යයෙන් ස්ප්ලයින් සමඟ කාර්යයන් ආසන්න වශයෙන් සාක්ෂාත් කරගනු ලැබේ (පැස්කල්ගේ ප්‍රකාශයට අනුව වඩාත් පොදු ක්‍රියාත්මක කිරීම රෙමේස් ඇල්ගොරිතම භාවිතා කරන බව පෙනේ )

මූලික වශයෙන් පහත සඳහන් මෙහෙයුම:

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කාර්යය.

පොදුවේ ගත් කල, අත්තනෝමතික පාවෙන ලක්ෂ්‍ය අගයන් සඳහා "පවු" ඔබට අවසානයේ ලිවිය හැකි ඕනෑම කාර්යයකට වඩා හොඳ නිරවද්‍යතාවයක් ඇති බව ඔබ දනී, නමුත් සමහර විශේෂ අවස්ථා වලදී බහු ගුණ කිරීම්වලට වඩා හොඳ නිරවද්‍යතාවයක් සහ ක්‍රියාකාරීත්වයක් තිබිය හැකිය, එය වඩාත් සුදුසු දේ තෝරා ගැනීම සංවර්ධකයාගේ ය, අවසානයේදී කේතය අදහස් දැක්වීමෙන් වෙනත් කිසිවෙකු එම කේතය "ප්‍රශස්තිකරණය" නොකරයි.

ප්‍රශස්තිකරණය කිරීම සඳහා අර්ථවත් වන එකම දෙය (පුද්ගලික මතය සහ පෙනෙන පරිදි GCC හි තේරීමක් ඕනෑම විශේෂිත ප්‍රශස්තිකරණයක් හෝ සම්පාදක ධජයක්) “පවු (අ, 2)” වෙනුවට “අ * අ” ආදේශ කිරීම විය යුතුය. සම්පාදක වෙළෙන්දෙකු විසින් කළ යුතු එකම දෙය එයයි.

මෙම නඩුව කිසිසේත්ම ප්‍රශස්ත වේ යැයි මම බලාපොරොත්තු නොවෙමි. ප්‍රකාශනයක සම්පූර්ණ ක්‍රියාකාරකම් ඉවත් කිරීම සඳහා නැවත සංවිධානය කළ හැකි උප ප්‍රකාශන අඩංගු වන විට එය බොහෝ විට විය නොහැක. සම්පාදක ලේඛකයින් කලාතුරකින් හමු වූ අද්දර නඩුවක් ආවරණය කරනවාට වඩා සැලකිය යුතු දියුණුවක් ඇති කිරීමට ඉඩ ඇති ප්‍රදේශවල ඔවුන්ගේ කාලය ආයෝජනය කරනු ඇතැයි මම අපේක්ෂා කරමි.

නිසි සම්පාදක ස්විචයන් සමඟ මෙම ප්‍රකාශනය සැබවින්ම ප්‍රශස්තිකරණය කළ හැකි බව අනෙක් පිළිතුරු වලින් දැන ගැනීම මා පුදුමයට පත් කළෙමි. එක්කෝ ප්‍රශස්තිකරණය සුළුපටු ය, නැතහොත් එය වඩාත් පොදු ප්‍රශස්තිකරණයේ අද්දර නඩුවකි, නැතහොත් සම්පාදක ලේඛකයින් අතිශයින් ගැඹුරු ය.

ඔබ මෙහි කළ පරිදි සම්පාදකයාට ඉඟි ලබා දීමේ කිසිදු වරදක් නැත. ක්ෂුද්‍ර ප්‍රශස්තිකරණ ක්‍රියාවලියේ සාමාන්‍ය හා අපේක්ෂිත කොටස වන්නේ ප්‍රකාශ සහ ප්‍රකාශන නැවත සකස් කිරීම මගින් ඒවා ගෙන එන්නේ කුමන වෙනස්කම්ද යන්නයි.

නොගැලපෙන ප්‍රති results ල ලබා දීම සඳහා ප්‍රකාශන දෙක සලකා බැලීමේදී සම්පාදකයා සාධාරණීකරණය කළ හැකි වුවද (නිසි ස්විචයකින් තොරව), එම සීමාවට ඔබ බැඳී සිටිය යුතු නැත. වෙනස ඇදහිය නොහැකි තරම් කුඩා වනු ඇත - කොතරම්ද යත් වෙනස ඔබට වැදගත් නම්, ඔබ මුලින්ම සම්මත පාවෙන ලක්ෂ්‍ය අංක ගණිතය භාවිතා නොකළ යුතුය.

මෙම ප්‍රශ්නයට දැනටමත් හොඳ පිළිතුරු කිහිපයක් ඇත, නමුත් සම්පූර්ණත්වය සඳහා මට පෙන්වා දීමට අවශ්‍ය වූයේ සී ප්‍රමිතියේ අදාළ කොටස 5.1.2.2.3 / 15 (එය 1.9 / 9 වගන්තියට සමාන වේ සී ++ 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 උල්ලං lates නය කරයි, නමුත් එයට ධජය අවශ්‍ය වේ.

අදහස් දැක්වීමේදී පීටර් කෝඩ්ස් පෙන්වා දුන් පරිදි අත්සන් කළ පූර්ණ සංඛ්‍යා වලට මෙම ප්‍රශස්තිකරණය කළ හැක්කේ -funsafe-math-optimizationsඑය පිටාර ගැලීමක් නොමැති විට හරියටම රඳවා තබාගෙන ඇති නිසා සහ පිටාර ගැලීමක් තිබේ නම් ඔබට නිර්වචනය නොකළ හැසිරීමක් ලැබෙනු ඇත. ඉතින් ඔබට ලැබෙනවා

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

සාධාරණයි -O. අත්සන් නොකළ පූර්ණ සංඛ්‍යා සඳහා, ඒවා 2 හි මෝඩ් බලයන් වැඩ කරන බැවින් එය වඩාත් පහසු වන අතර එමඟින් පිටාර ගැලීමකදී පවා නිදහසේ නැවත සකස් කළ හැකිය.