(सत्य) या (?;) के लिए और अधिक तेज़ क्या है?

विभिन्न लेखकों के कच्चे माल में मैंने सतत चक्र के विभिन्न संस्करणों को देखा। सबसे अधिक बार मैं निम्नलिखित मिला:

while (true) { ... } 

और

 for (;;) { ... } 

चूंकि सभी ने मूल के रूप में "अपने शाश्वत चक्र" का बचाव किया था, इसलिए मैंने इसका पता लगाने का फैसला किया। सबसे इष्टतम कोड कौन लिखता है।

मैंने 2 स्रोत कोड लिखे:

while.c:

 #include <stdio.h> int main (int argc, char* argv[]) { while(1){ printf("1\n"); } } 

for.c:

 #include <stdio.h> int main (int argc, char* argv[]) { for(;;){ printf("1\n"); } } 

उन्हें एकत्र किया:

 $ gcc -O3 while.c -o while.o3 $ gcc -O2 while.c -o while.o2 $ gcc -O1 while.c -o while.o1 $ gcc -O3 for.c -o for.o3 $ gcc -O2 for.c -o for.o2 $ gcc -O1 for.c -o for.o1 

और असंतुष्ट। कोडांतरक सूचियों को पढ़ने के लिए कौन बहुत आलसी है - आप पृष्ठ को नीचे स्क्रॉल कर सकते हैं। वास्तव में लिस्टिंग:

 $ objdump -d ./while.o3 ... 0000000000400430 <main>: 400430: 48 83 ec 08 sub $0x8,%rsp 400434: 0f 1f 40 00 nopl 0x0(%rax) 400438: bf d4 05 40 00 mov $0x4005d4,%edi 40043d: e8 be ff ff ff callq 400400 <puts@plt> 400442: eb f4 jmp 400438 <main+0x8> ... $ objdump -d ./while.o2 ... 0000000000400430 <main>: 400430: 48 83 ec 08 sub $0x8,%rsp 400434: 0f 1f 40 00 nopl 0x0(%rax) 400438: bf d4 05 40 00 mov $0x4005d4,%edi 40043d: e8 be ff ff ff callq 400400 <puts@plt> 400442: eb f4 jmp 400438 <main+0x8> ... $ objdump -d ./while.o1 ... 000000000040051c <main>: 40051c: 48 83 ec 08 sub $0x8,%rsp 400520: bf d4 05 40 00 mov $0x4005d4,%edi 400525: e8 d6 fe ff ff callq 400400 <puts@plt> 40052a: eb f4 jmp 400520 <main+0x4> ... $ objdump -d ./for.o1 ... 000000000040051c <main>: 40051c: 48 83 ec 08 sub $0x8,%rsp 400520: bf d4 05 40 00 mov $0x4005d4,%edi 400525: e8 d6 fe ff ff callq 400400 <puts@plt> 40052a: eb f4 jmp 400520 <main+0x4> ... $ objdump -d ./for.o2 ... 0000000000400430 <main>: 400430: 48 83 ec 08 sub $0x8,%rsp 400434: 0f 1f 40 00 nopl 0x0(%rax) 400438: bf d4 05 40 00 mov $0x4005d4,%edi 40043d: e8 be ff ff ff callq 400400 <puts@plt> 400442: eb f4 jmp 400438 <main+0x8> ... $ objdump -d ./for.o3 0000000000400430 <main>: 400430: 48 83 ec 08 sub $0x8,%rsp 400434: 0f 1f 40 00 nopl 0x0(%rax) 400438: bf d4 05 40 00 mov $0x4005d4,%edi 40043d: e8 be ff ff ff callq 400400 <puts@plt> 400442: eb f4 jmp 400438 <main+0x8> 

हम उंगलियों पर जुदा होते हैं

विभिन्न ऑप्टिमाइज़ेशन ने (सच्चे) लूप के कार्यान्वयन को प्रभावित नहीं किया - वह हमेशा 3 कमांड चलाता था: mov, callq और jmp। इसके अलावा, अनुकूलन ने इसके कार्यान्वयन को प्रभावित नहीं किया - यह भी हमेशा 3 कमांडों से था: mov, callq, jmp। खुद के बीच में mov, callq और jmp अलग नहीं थे। सभी 6 मामलों में बाइट्स में निर्देशों की लंबाई अपरिवर्तित है।

-O1 और -O2 / -O3 jmp कार्यान्वयन के बीच मुख्य + 4 पर मामूली अंतर है और मुख्य + 8 पर नहीं, लेकिन यह देखते हुए कि यह एक स्थैतिक पता है (asm कोड से देखा गया) इसे भी कोई फर्क नहीं पड़ता है प्रदर्शन ... हालाँकि ... क्या होगा यदि मेमोरी पेज अलग हैं, क्योंकि जहाँ तक मुझे x86 (और amd64) में अलग-अलग मेमोरी पेजों के बीच इशारों के लिए पता है, अतिरिक्त प्रयासों की आवश्यकता है!

हम सीखते हैं:
400438/4096 = 97.763183594
400520/4096 = 97.783203125

ले गए। मेमोरी पेज एक है। हां, यह वर्चुअल एड्रेस ऑफ़ द वर्चुअल एड्रेस ऑफ़ द प्रोसेस का 97 वां पेज है। लेकिन हमें इसकी जरूरत भी है।

परिणाम

जबकि (सत्य) और (;;) एक दूसरे के साथ और किसी भी -Ox अनुकूलन के साथ प्रदर्शन में समान हैं। इसलिए यदि आपसे पूछा जाए कि उनमें से कौन सा तेज है - यह कहने के लिए स्वतंत्र महसूस करें कि "के लिए (?)" - 8 अक्षर "जबकि (सच्चा)" से तेज लिखने के लिए - 12 वर्ण।

उन लोगों के लिए जो यह विश्वास नहीं करते कि बिना -ओएक्स के यह समान होगा:

 $ gcc while.c -o while.noO $ objdump -d while.noO ... 40052b: bf e4 05 40 00 mov $0x4005e4,%edi 400530: e8 cb fe ff ff callq 400400 <puts@plt> 400535: eb f4 jmp 40052b <main+0xf> ... $ gcc for.c -o for.noO $ objdump -d for.noO ... 40052b: bf e4 05 40 00 mov $0x4005e4,%edi 400530: e8 cb fe ff ff callq 400400 <puts@plt> 400535: eb f4 jmp 40052b <main+0xf> ... 

पुनश्च , यह सब संकलक पर सच होगा "gcc संस्करण 4.7.2 (डेबियन 4.7.2-5)"