X86 डिस्सैस विश्लेषण के साथ जीसीसी न्यूनतम रननीय उदाहरण
आइए देखें कि जीसीसी स्वचालित रूप से उत्पन्न विधानसभा को देखकर हमारे लिए पूंछ कॉल अनुकूलन कैसे कर सकता है।
यह https://stackoverflow.com/a/9814654/895245 जैसे अन्य उत्तरों में उल्लिखित एक अत्यंत ठोस उदाहरण के रूप में काम करेगा कि अनुकूलन पुनरावर्ती फ़ंक्शन कॉल को लूप में बदल सकता है।
यह बदले में स्मृति को बचाता है और प्रदर्शन में सुधार करता है, क्योंकि मेमोरी एक्सेस अक्सर मुख्य चीज होती है जो आजकल कार्यक्रमों को धीमा कर देती है ।
इनपुट के रूप में, हम GCC को एक गैर-अनुकूलित भोले स्टैक आधारित फैक्टरियल देते हैं:
tail_call.c
#include <stdio.h>
#include <stdlib.h>
unsigned factorial(unsigned n) {
if (n == 1) {
return 1;
}
return n * factorial(n - 1);
}
int main(int argc, char **argv) {
int input;
if (argc > 1) {
input = strtoul(argv[1], NULL, 0);
} else {
input = 5;
}
printf("%u\n", factorial(input));
return EXIT_SUCCESS;
}
गिटहब ऊपर ।
संकलन और जुदाई:
gcc -O1 -foptimize-sibling-calls -ggdb3 -std=c99 -Wall -Wextra -Wpedantic \
-o tail_call.out tail_call.c
objdump -d tail_call.out
-foptimize-sibling-callsटेल कॉल के सामान्यीकरण का नाम कहां है man gcc:
-foptimize-sibling-calls
Optimize sibling and tail recursive calls.
Enabled at levels -O2, -O3, -Os.
जैसा कि उल्लेख किया गया है: मैं कैसे जांच करूं कि क्या gcc पूंछ-पुनरावृत्ति अनुकूलन कर रहा है?
मैं चुनता हूं -O1क्योंकि:
- अनुकूलन के साथ नहीं किया गया है
-O0। मुझे संदेह है कि ऐसा इसलिए है क्योंकि आवश्यक मध्यवर्ती रूपांतरण गायब हैं।
-O3 बहुत ही शिक्षाप्रद नहीं होगा कि ungodly कुशल कोड पैदा करता है, हालांकि यह भी पूंछ कॉल अनुकूलित है।
साथ डिस्सैडविस्म -fno-optimize-sibling-calls:
0000000000001145 <factorial>:
1145: 89 f8 mov %edi,%eax
1147: 83 ff 01 cmp $0x1,%edi
114a: 74 10 je 115c <factorial+0x17>
114c: 53 push %rbx
114d: 89 fb mov %edi,%ebx
114f: 8d 7f ff lea -0x1(%rdi),%edi
1152: e8 ee ff ff ff callq 1145 <factorial>
1157: 0f af c3 imul %ebx,%eax
115a: 5b pop %rbx
115b: c3 retq
115c: c3 retq
के साथ -foptimize-sibling-calls:
0000000000001145 <factorial>:
1145: b8 01 00 00 00 mov $0x1,%eax
114a: 83 ff 01 cmp $0x1,%edi
114d: 74 0e je 115d <factorial+0x18>
114f: 8d 57 ff lea -0x1(%rdi),%edx
1152: 0f af c7 imul %edi,%eax
1155: 89 d7 mov %edx,%edi
1157: 83 fa 01 cmp $0x1,%edx
115a: 75 f3 jne 114f <factorial+0xa>
115c: c3 retq
115d: 89 f8 mov %edi,%eax
115f: c3 retq
दोनों के बीच महत्वपूर्ण अंतर यह है कि:
का -fno-optimize-sibling-callsउपयोग करता है callq, जो विशिष्ट गैर-अनुकूलित फ़ंक्शन कॉल है।
यह निर्देश स्टैक पर वापसी पते को बढ़ाता है, इसलिए इसे बढ़ाता है।
इसके अलावा, यह संस्करण भी करता है push %rbx, जो स्टैक को धक्का देता %rbxहै ।
जीसीसी ऐसा इसलिए करता है क्योंकि यह स्टोर करता है edi, जो पहले फ़ंक्शन तर्क ( n) में ebx, फिर कॉल करता है factorial।
जीसीसी को ऐसा करने की आवश्यकता है क्योंकि यह एक और कॉल करने की तैयारी कर रहा है factorial, जो नए का उपयोग करेगा edi == n-1।
यह चुनता है ebxक्योंकि यह रजिस्टर कैली-सेव है: लिनेक्स x86-64 फ़ंक्शन कॉल के माध्यम से कौन से रजिस्टरों को संरक्षित किया जाता है, इसलिए उपकुल factorialइसे बदलने और खोने के लिए नहीं करता है n।
-foptimize-sibling-callsकिसी भी निर्देश है कि ढेर करने के लिए धक्का का उपयोग नहीं करता: यह केवल करता है gotoके भीतर कूदता factorialके निर्देश के साथ jeऔर jne।
इसलिए, यह संस्करण थोड़ी देर के लूप के बराबर है, बिना किसी फ़ंक्शन के। स्टैक का उपयोग स्थिर है।
उबंटू 18.10, जीसीसी 8.2 में परीक्षण किया गया।