सी बनाम गो लूप्स और सरल गणित

जब मैं सी में प्रोग्रामिंग से थक गया, तो कई की तरह, मुझे गो में दिलचस्पी थी। यह कड़ाई से टाइप किया गया है, संकलित है, इसलिए काफी उत्पादक है। और फिर मैं यह जानना चाहता था कि गो के रचनाकारों को छोरों और संख्याओं के साथ अपने काम का अनुकूलन करने में कितनी उलझन थी।

शुरू करने के लिए, हम देखते हैं कि सी कैसे कर रहा है।

हम ऐसा सरल कोड लिखते हैं:

#include <stdint.h> #include <stdio.h> int main() { uint64_t i; uint64_t j = 0; for ( i = 10000000; i>0; i--) { j ^= i; } printf("%lu\n", j); return 0; } 

O2 के साथ संकलन, जुदा करें:

 564: 31 d2 xor %edx,%edx 566: b8 80 96 98 00 mov $0x989680,%eax 56b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) 570: 48 31 c2 xor %rax,%rdx 573: 48 83 e8 01 sub $0x1,%rax 577: 75 f7 jne 570 <main+0x10> 

हमें निष्पादन समय मिलता है:

वास्तविक 0m0,023s
उपयोगकर्ता 0m0,019s
sys 0m0,004s

ऐसा लगता है कि तेजी लाने के लिए कहीं नहीं है, लेकिन हमारे पास एक आधुनिक प्रोसेसर है, ऐसे ऑपरेशनों के लिए हमारे पास तेजी से रजिस्टर हैं। हम विकल्पों की कोशिश करते हैं gcc -mfpmath = sse -msse4.2 जिसका परिणाम समान है।
Add -O3 और चियर्स:

  57a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) 580: 83 c0 01 add $0x1,%eax 583: 66 0f ef c8 pxor %xmm0,%xmm1 587: 66 0f d4 c2 paddq %xmm2,%xmm0 58b: 3d 40 4b 4c 00 cmp $0x4c4b40,%eax 590: 75 ee jne 580 <main+0x20> 

यह देखा जा सकता है कि SSE2 कमांड और SSE रजिस्टर का उपयोग किया जाता है, और हमें एक ट्रिपल प्रदर्शन वृद्धि मिलती है:

असली 0m0,006s
उपयोगकर्ता 0m0,006s
sys 0m0,000s

गो पर भी:

 package main import "fmt" func main() { i := 0 j := 0 for i = 10000000; i>0; i-- { j ^= i } fmt.Println(j) } 

 0x000000000048211a <+42>: lea -0x1(%rax),%rdx 0x000000000048211e <+46>: xor %rax,%rcx 0x0000000000482121 <+49>: mov %rdx,%rax 0x0000000000482124 <+52>: test %rax,%rax 0x0000000000482127 <+55>: ja 0x48211a <main.main+42> 

समय जाना:
नियमित जाना:
असली 0m0,021
उपयोगकर्ता 0m0,018s
sys 0m0,004s

gccgo:
वास्तविक 0m0,058s
उपयोगकर्ता 0m0,036s
sys 0m0,014

प्रदर्शन, जैसा कि C और O2 के मामले में भी होता है, उसी परिणाम को आगे बढ़ाते हैं, लेकिन यह नियमित गो (1.10.4) संकलक की तुलना में अधिक समय तक काम करता है। इस तथ्य के कारण कि नियमित कंपाइलर पूरी तरह से थ्रेड के लॉन्च का अनुकूलन करता है (मेरे मामले में, 4 कोर पर 5 अतिरिक्त धागे बनाए गए थे), एप्लिकेशन तेजी से चलता है।

निष्कर्ष

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

 package main // +build amd64 import "fmt" func main() { var i float64 = 0 var j float64 = 0 for i = 10000000; i>0; i-- { j += i } fmt.Println(j) } 

0x0000000000484bbe <+46>: movsd 0x4252a(%rip),%xmm3 # 0x4c70f0 <$f64.3ff0000000000000>
0x0000000000484bc6 <+54>: movups %xmm0,%xmm4
0x0000000000484bc9 <+57>: subsd %xmm3,%xmm0
0x0000000000484bcd <+61>: addsd %xmm4,%xmm1
0x0000000000484bd1 <+65>: xorps %xmm2,%xmm2
0x0000000000484bd4 <+68>: ucomisd %xmm2,%xmm0
0x0000000000484bd8 <+72>: ja 0x484bbe <main.main+46>