C ++ में फ़ंक्शन कॉल की विशेषताएं

बहुत पहले नहीं, मैंने एक शाश्वत विषय पर एक सहकर्मी के साथ एक और बातचीत की: "संदर्भ से, या मूल्य से।" परिणामस्वरूप, यह लेख उत्पन्न हुआ। इसमें, मैं इस और संबंधित विषयों पर अपने शोध के परिणाम प्रस्तुत करना चाहता हूं। अगला विचार किया जाएगा:

• रजिस्टरों और उनके उद्देश्य जब कार्यों को बुलाते हैं।
• सरल प्रकार और संरचनाओं का स्थानांतरण और वापसी।
• संदर्भ और मान से कैसे गुजरता है, यह कंपाइलर द्वारा फ़ंक्शन बॉडी के अनुकूलन को प्रभावित करता है।
• मल्टीपल फंक्शन कॉल्स में स्पेस का उपयोग कैसे किया जाता है।
• वर्चुअल कॉल का तंत्र।
• पूंछ कॉल और पुनरावृत्ति का अनुकूलन।
• संरचनाओं, सरणियों और वैक्टर का प्रारंभिककरण।

चेतावनी! लेख में बड़ी मात्रा में C ++ और कोडांतरक कोड (टिप्पणियों के साथ Intel ASM ), साथ ही प्रदर्शन रेटिंग के साथ कई तालिकाएं हैं। सब कुछ लिखा x86-64 सिस्टम वी एबीआई के लिए प्रासंगिक है, जिसका उपयोग सभी आधुनिक यूनिक्स ऑपरेटिंग सिस्टम में किया जाता है, उदाहरण के लिए, लिनक्स और मैकओएस।

X86-64 दस्तावेज़ के लिए सिस्टम V अनुप्रयोग बाइनरी इंटरफ़ेस से जानकारी ली गई थी। -O3 -std=c++1z -march=sandybridge 5.0.0 x86-64 झंडे के लिए प्राप्त हुए थे -O3 -std=c++1z -march=sandybridge (साइट https://godbolt.org का उपयोग करके)। Intel® Xeon® प्रोसेसर E5-2660 2.20GHz के लिए प्रदर्शन रेटिंग बनाई गई थी ।

सामग्री

• सामग्री
• रजिस्टर x86-64 में
• पासिंग पैरामीटर
• सरल उदाहरण
• लिंक द्वारा पास करें
  
  • प्रदर्शन की तुलना
• पारदर्शी संकेत
• पुन: उपयोग स्टैक
  
  • प्रदर्शन की तुलना
• वैकल्पिक टाइप करें
• आभासी कार्य
  
  • प्रदर्शन की तुलना
• टेल कॉल
• प्रारंभ
  
  • एक वस्तु
  • छोटा सरणी
  • बड़ी सरणी
  • गतिशील सरणी
  • प्रदर्शन की तुलना

रजिस्टर x86-64 में

सारा डाटा रैम में स्टोर होता है। इसके साथ काम को गति देने के लिए, बहुस्तरीय कैश का उपयोग किया जाता है। लेकिन डेटा को बदलने के लिए, एक तरह से या किसी अन्य, रजिस्टरों का उपयोग किया जाता है ( टिप्पणियों में चर्चा )। नीचे x86-64 वास्तुकला में सबसे अधिक उपयोग किए जाने वाले रजिस्टरों का बहुत संक्षिप्त विवरण है।

• 16 सामान्य-उद्देश्य रजिस्टर: rax, rbx, rcx, rdx, rbp, rsi, rdi, rsp और r8-r15 भी। उनमें से प्रत्येक का आकार 64 बिट्स (8 बाइट्स) है। निचले 32 बिट्स (4 बाइट्स) तक पहुंचने के लिए, उपसर्ग e r ( rax → eax ) के बजाय e । केवल गैर-वेक्टर पूर्णांक ऑपरेशन समर्थित हैं।
• rip (अनुदेश सूचक) अगले निष्पादित होने वाले अनुदेश को इंगित करता है। निर्देशों के साथ मेमोरी सेक्शन में पड़े विभिन्न स्थिर डेटा को rip सापेक्ष एक ऑफसेट पर पढ़ा जा सकता है।
• rsp (स्टैक पॉइंटर) स्टैक पर अंतिम आइटम को इंगित करता है। स्टैक निचले पतों की ओर बढ़ता है। स्टैक पर कुछ पुश करने से rsp मान कम हो जाता है।
• 16 SSE आकार में 128 बिट्स पंजीकृत करता है: xmm0 - xmm15 । यदि AVX मोड का समर्थन किया जाता है, तो वे ymm0 - ymm15 के निचले 128 बिट्स को संदर्भित करते हैं ymm0 - ymm15 जिनमें से प्रत्येक का आकार 256 बिट्स होता है। वेक्टर, या गैर-पूर्णांक संचालन के लिए, डेटा को पहले इन रजिस्टरों में लोड किया जाना चाहिए।

पासिंग पैरामीटर

यह खंड रजिस्टरों / स्टैक के तर्कों को वितरित करने के लिए एल्गोरिथम का कुछ संक्षिप्त और सरलीकृत विवरण प्रदान करता है। पूर्ण विवरण के लिए, पृष्ठ 17 "सिस्टम वी एबीआई" देखें।

हम वस्तुओं के कई वर्गों का परिचय देते हैं:

• INTEGER - सामान्य रजिस्टरों में रखे गए इंटीग्रल प्रकार। ये bool , char , int और इतने ही हैं।
• SSE फ्लोटिंग पॉइंट नंबर होते हैं जो वेक्टर रजिस्टर में फिट होते हैं। ये float और double ।
• मेमोरी - स्टैक से गुजरे ऑब्जेक्ट।

विवरण को एकजुट करने के लिए, __int128 और complex प्रकारों __int128 दो क्षेत्रों की संरचनाओं के रूप __int128 दर्शाया गया है:

 struct __int128 { int64 low, high; }; struct complexT { T real, imag; }; //  T - float,  double. 

शुरुआत में, प्रत्येक फ़ंक्शन तर्क को वर्गीकृत किया गया है:

1. यदि प्रकार 128 बिट्स से बड़ा है, या इसमें अविभाजित फ़ील्ड हैं, तो यह मेमोरी है ।
2. यदि कोई गैर-तुच्छ विध्वंसक, कॉपी कंस्ट्रक्टर, वर्चुअल तरीके, वर्चुअल बेस कक्षाएं हैं, तो इसे "पारदर्शी लिंक" के माध्यम से पारित किया जाता है। ऑब्जेक्ट को एक सूचक के साथ बदल दिया जाता है जो कि INTEGER प्रकार का होता है।
3. एग्रीगेट्स, और ये संरचनाएं और सरणियां हैं, 8 बाइट्स के टुकड़ों में विश्लेषण किया जाता है।
   
   1. यदि टुकड़ा में टाइप मेमोरी का क्षेत्र है, तो पूरा टुकड़ा मेमोरी है ।
   2. यदि किसी प्रकार का एक क्षेत्र INTEGER है , तो पूरा टुकड़ा INTEGER है ।
   3. अन्यथा, एसएसई का पूरा टुकड़ा।
4. यदि MEMORY का एक टुकड़ा है, तो संपूर्ण तर्क MEMORY है ।
5. long double और complex long double प्रकार x87 FPU रजिस्टरों के एक विशेष सेट का उपयोग करते हैं और मेमोरी प्रकार के होते हैं।
6. __m256 , __m128 और __float128 SSE प्रकार के हैं।

वर्गीकरण के बाद, सभी 8 बाइट विखंडू (एक चंक में संरचना के कई क्षेत्र हो सकते हैं, या सरणी तत्व) रजिस्टरों में वितरित किए जाते हैं:

1. मेमोरी को स्टैक के माध्यम से पारित किया जाता है।
2. INTEGER को उस क्रम में अगले मुफ्त रजिस्टर rdi, rsi, rdx, rcx, r8, r9 माध्यम से प्रेषित किया जाता है।
3. SSE को अगले मुफ्त रजिस्टर xmm0 - xmm7 माध्यम से प्रेषित किया जाता है।

तर्क को बाएं से दाएं माना जाता है। जिन तर्कों में पर्याप्त रजिस्टर नहीं थे, उन्हें स्टैक के माध्यम से पारित किया जाता है। यदि तर्क के किसी भी टुकड़े में एक रजिस्टर नहीं था, तो पूरे तर्क को स्टैक के माध्यम से पारित किया जाता है।

वापसी मान इस प्रकार हैं:

1. मेमोरी प्रकार स्टैक के माध्यम से लौटाए जाते हैं। इस पर जगह कॉलिंग फ़ंक्शन द्वारा प्रदान की जाती है और इसकी शुरुआत का पता rdi माध्यम से पारित किया जाता है जैसे कि यह फ़ंक्शन का पहला तर्क था। लौटने पर, इस पते को rax माध्यम से लौटाया जाना चाहिए। पहले मूल तर्क को पारित किया जाएगा, क्रमशः दूसरे के रूप में, और इसी तरह।
2. INTEGER चंक को अगले मुफ्त रजिस्टर rax, rdx माध्यम से लौटाया जाता है।
3. SSE chunk को अगले मुफ्त रजिस्टर xmm0, xmm1 माध्यम से लौटाया जाता है। इन रजिस्टरों का उपयोग मूल्यों को प्राप्त करने और लौटाने के लिए किया जाता है।

रजिस्टर पढ़ने के दौरान रजिस्टरों और उनके उद्देश्य के साथ एक पिवट टेबल बहुत उपयोगी है:

कॉलिंग फ़ंक्शन से संबंधित रजिस्टरों को या तो उपयोग नहीं किया जाना चाहिए, या उनके मूल्यों को कहीं संग्रहीत किया जाना चाहिए, उदाहरण के लिए, स्टैक पर, और फिर पुनर्स्थापित किया गया।

सरल उदाहरण

जब तक स्पष्ट रूप से अन्यथा नहीं कहा जाता है, तब तक उपयोग किए जाने वाले सभी फ़ंक्शन NOINLINE के रूप में चिह्नित किए गए थे। हम दिखाते हैं कि फ़ंक्शन बॉडी cpp फ़ाइल में स्थित है, और LTO अक्षम है। इसके अलावा, सभी फ़ंक्शन परिणामों को सभी कोड को हटाने से ऑप्टिमाइज़र को रोकने के लिए एक खाली NOINLINE फ़ंक्शन में स्थानांतरित किया जाता है।

 #define NOINLINE __attribute__((noinline)) #define INLINE static __attribute__((always_inline)) 

कुछ सरल पर विचार करें।

 double foo(int8_t a, int16_t b, int32_t c, int64_t d, float x, double y) { return a + b + c + d + x + y; } ... auto result = foo(1, 2, 3, 4, 5, 6); 

पैरामीटर इस तरह से पारित किए जाते हैं:

अधिक विस्तार से उत्पन्न कोड पर विचार करें।

 foo(signed char, short, int, long, float, double): add edi, esi #  a  b. add edi, edx #  c. movsxd rax, edi #    rax,    64    . add rax, rcx #  d. vcvtsi2ss xmm2, xmm2, rax #    float     xmm2. vaddss xmm0, xmm2, xmm0 #  x,  's'  vaddss    single precision. vcvtss2sd xmm0, xmm0, xmm0 #    double. vaddsd xmm0, xmm0, xmm1 #  y,  'd'  vaddsd    double precision. ret #       ,    ,    ,   rsp   8. .LCPI1_0: #    . .long 1084227584 # float 5 .LCPI1_1: .quad 4618441417868443648 # double 6 main: # @main sub rsp, 24 #     . vmovss xmm0, dword ptr [rip + .LCPI1_0] # xmm0 = mem[0],zero,zero,zero vmovsd xmm1, qword ptr [rip + .LCPI1_1] # xmm1 = mem[0],zero mov edi, 1 mov esi, 2 mov edx, 3 mov ecx, 4 call foo(signed char, short, int, long, float, double) # call      ,    rsp  8,      . vmovsd qword ptr [rsp + 16], xmm0 #     . 

यदि आप किसी फ़ंक्शन के लिए सरल प्रकार के पैरामीटर पास करते हैं, तो आपको कड़ी मेहनत करने की आवश्यकता है ताकि वे रजिस्टरों के माध्यम से पारित न हों।

समुच्चय के विभिन्न उदाहरणों पर विचार करें। एरे को कई क्षेत्रों के साथ संरचनाओं के रूप में माना जा सकता है।

 struct St { double a, b; }; double foo(St s) { return sa + sb; } ... St s{1, 2}; auto result = foo(s); 

ऐसा लगता है कि कुछ भी नहीं एक xmm बार में दो double को एक xmm रजिस्टर में धकेलने से रोकता है। लेकिन अफसोस, वितरण एल्गोरिथ्म केवल आठ-बाइट विखंडू पर चल रहा है।

 foo(St): # @foo(St) vaddsd xmm0, xmm0, xmm1 #     ,       . ret .LCPI1_0: .quad 4607182418800017408 # double 1 .LCPI1_1: .quad 4611686018427387904 # double 2 main: # @main sub rsp, 24 #   . vmovsd xmm0, qword ptr [rip + .LCPI1_0] # xmm0 = mem[0],zero vmovsd xmm1, qword ptr [rip + .LCPI1_1] # xmm1 = mem[0],zero call foo(St) vmovsd qword ptr [rsp + 16], xmm0 #  double    . 

यदि आप एक और double फ़ील्ड जोड़ते हैं, तो पूरे ढांचे को स्टैक के माध्यम से पारित किया जाएगा, क्योंकि इसका आकार 128 बाइट्स से अधिक होगा।

 struct St { double a, b, c; }; double foo(St s) { return sa + sb + sc; } ... St s{1, 2, 3}; auto result = foo(s); 

 foo(St): # @foo(St) #   ,    8 ,     .        ,         rsp+8. vmovsd xmm0, qword ptr [rsp + 8] # xmm0 = mem[0],zero vaddsd xmm0, xmm0, qword ptr [rsp + 16] vaddsd xmm0, xmm0, qword ptr [rsp + 24] ret .L_ZZ4mainE1s: .quad 4607182418800017408 # double 1 .quad 4611686018427387904 # double 2 .quad 4613937818241073152 # double 3 main: # @main sub rsp, 40 #    40 . #       ,    .      ,   mov       . mov rax, qword ptr [rip + .L_ZZ4mainE1s+16] #    '3'. mov qword ptr [rsp + 16], rax #  '3'  . vmovups xmm0, xmmword ptr [rip + .L_ZZ4mainE1s] #   xmm0  '1'  '2'. vmovups xmmword ptr [rsp], xmm0 #  '1'  '2  .    : 1 = *rsp , 2 = *(rsp+8), 3 = *(rsp+16). call foo(St) vmovsd qword ptr [rsp + 32], xmm0 #     double  . 

आइए देखें कि क्या होता है यदि हम uint64_t साथ double को प्रतिस्थापित करते हैं।

 struct St { uint64_t a, b; }; uint64_t foo(St s) { return sa + sb; } ... St s{1, 2}; auto result = foo(s); 

 foo(St): # @foo(St) lea rax, [rdi + rsi] ret main: # @main sub rsp, 24 mov edi, 1 mov esi, 2 call foo(St) mov qword ptr [rsp + 16], rax 

परिणाम काफ़ी अधिक कॉम्पैक्ट है। add बजाय अंतिम निर्देश का उपयोग क्यों किया जाता है, इसके बारे में अधिक जानकारी, उदाहरण के लिए, यहाँ पढ़ सकते हैं: https://stackoverflow.com/a/6328441/1418863

यदि आप एक और फ़ील्ड जोड़ते हैं, तो, जैसे कि double साथ उदाहरण में, संरचना को स्टैक के माध्यम से पारित किया जाएगा। कोड, वैसे, लगभग समान होगा, यहां तक ​​कि स्टैक पर लोड करना xmm रजिस्टरों के माध्यम से होगा।

कुछ अधिक दिलचस्प पर विचार करें।

 struct St { float a, b, c, d; }; St foo(St s1, St s2) { return {s1.a + s2.a, s1.b + s2.b, s1.c + s2.c, s1.d + s2.d}; } ... St s1{1, 2, 3, 4}, s2{5, 6, 7, 8}; auto result = foo(s1, s2); 

दो float फ़ील्ड प्रत्येक xmm रजिस्टर में धकेल दिए जाते हैं।

 foo(St, St): # @foo(St, St) #   vaddps    float . vaddps xmm0, xmm0, xmm2 vaddps xmm1, xmm1, xmm3 ret .LCPI1_0: .long 1065353216 # float 1 .long 1073741824 # float 2 .zero 4 .zero 4 #   LCPI1_1 - LCPI1_3. ... main: # @main sub rsp, 24 #  ,      . vmovapd xmm0, xmmword ptr [rip + .LCPI1_0] # xmm0 = <1,2,u,u> vmovapd xmm1, xmmword ptr [rip + .LCPI1_1] # xmm1 = <3,4,u,u> vmovaps xmm2, xmmword ptr [rip + .LCPI1_2] # xmm2 = <5,6,u,u> vmovaps xmm3, xmmword ptr [rip + .LCPI1_3] # xmm3 = <7,8,u,u> call foo(St, St) #        ,         . xmm   256 ,    128    a  b,   - c  d. vunpcklpd xmm0, xmm0, xmm1 # xmm0 = xmm0[0],xmm1[0] vmovupd xmmword ptr [rsp + 8], xmm0 

यदि संरचना में 4 नहीं था, लेकिन तीन फ़ील्ड हैं, तो फ़ंक्शन कोड समान होगा, सिवाय दूसरे vaddps निर्देश को vaddss साथ vaddss , जो रजिस्टर के पहले 64 बिट्स को जोड़ता है।

 struct St { int32_t a, b, c, d; }; St foo(St s1, St s2) { return {s1.a + s2.a, s1.b + s2.b, s1.c + s2.c, s1.d + s2.d}; } ... St s1{1, 2, 3, 4}, s2{5, 6, 7, 8}; auto result = foo(s1, s2); 

 foo(St, St): # @foo(St, St) lea eax, [rdx + rdi] movabs r8, -4294967296 # 0xFFFFFFFF00000000  . and rdi, r8 add rdi, rdx and rdi, r8 or rax, rdi lea edx, [rcx + rsi] #  ,   add. and rsi, r8 add rsi, rcx and rsi, r8 or rdx, rsi ret main: # @main sub rsp, 24 movabs rdi, 8589934593 #       . movabs rsi, 17179869187 movabs rdx, 25769803781 movabs rcx, 34359738375 call foo(St, St) mov qword ptr [rsp + 8], rax #    . mov qword ptr [rsp + 16], rdx 

बिट मैजिक फंक्शन के अंदर होता है, लेकिन सिद्धांत बहुत स्पष्ट है। 32 बिट संख्याओं की प्रत्येक जोड़ी को एक 64 बिट रजिस्टर में पैक किया जाता है। रिफंड उसी तरह से बनाया जाता है।

आइए देखें कि अगर हम फील्ड प्रकारों को मिलाना शुरू करते हैं तो क्या होता है, लेकिन 8 बाइट विखंडू में वे एक ही वर्ग के होते हैं।

 struct St { int32_t a, b; float c, d; }; St foo(St s1, St s2) { return {s1.a + s2.a, s1.b + s2.b, s1.c + s2.c, s1.d + s2.d}; } ... St s1{1, 2, 3, 4}, s2{5, 6, 7, 8}; auto result = foo(s1, s2); 

 foo(St, St): # @foo(St, St) lea eax, [rsi + rdi] #     . movabs rcx, -4294967296 and rdi, rcx add rdi, rsi and rdi, rcx or rax, rdi vaddps xmm0, xmm0, xmm1 #    . ret .LCPI1_0: .long 1077936128 # float 3 .long 1082130432 # float 4 .zero 4 .zero 4 ... main: # @main sub rsp, 24 vmovaps xmm0, xmmword ptr [rip + .LCPI1_0] # xmm0 = <3,4,u,u> vmovaps xmm1, xmmword ptr [rip + .LCPI1_1] # xmm1 = <7,8,u,u> movabs rdi, 8589934593 movabs rsi, 25769803781 call foo(St, St) mov qword ptr [rsp + 8], rax #    . vmovlps qword ptr [rsp + 16], xmm0 

लेकिन यह दिलचस्प नहीं है, क्योंकि प्रत्येक 8 बाइट चंक में खेतों के प्रकार समान हैं। खेतों को समेटना।

 struct St { int32_t a; float b; int32_t c; float d; }; St foo(St s1, St s2) { return {s1.a + s2.a, s1.b + s2.b, s1.c + s2.c, s1.d + s2.d}; } ... St s1{1, 2, 3, 4}, s2{5, 6, 7, 8}; auto result = foo(s1, s2); 

पैराग्राफ 3.2 देखें। चूँकि 8-बाइट वाले चंक में float और int दोनों होते हैं, इसलिए पूरा हिस्सा इंटेगर का होगा और इसे सामान्य रजिस्टरों में पास किया जाएगा।

 foo(St, St): # @foo(St, St) mov rax, rdx add edx, edi shr rdi, 32 vmovd xmm0, edi mov rdi, rcx add ecx, esi shr rsi, 32 vmovd xmm1, esi shr rax, 32 vmovd xmm2, eax vaddss xmm0, xmm0, xmm2 shr rdi, 32 vmovd xmm2, edi vaddss xmm1, xmm1, xmm2 vmovd eax, xmm0 shl rax, 32 or rdx, rax vmovd eax, xmm1 shl rax, 32 or rcx, rax mov rax, rdx mov rdx, rcx ret main: # @main sub rsp, 24 movabs rdi, 4611686018427387905 # 0x4000000000000001,   32   int,   - float. movabs rsi, 4647714815446351875 movabs rdx, 4665729213955833861 movabs rcx, 4683743612465315847 call foo(St, St) mov qword ptr [rsp + 8], rax #      64  . mov qword ptr [rsp + 16], rdx 

यहां आप float फ़ील्ड निकालने और परिणाम के साथ रजिस्टर में धकेलने के लिए 6 शिफ्ट ऑपरेशन देख सकते हैं। साथ ही किसी भी वेक्टर ऑपरेशन की अनुपस्थिति। सामान्य तौर पर, संरचना के 8 बाइट विखंडू के भीतर फील्ड प्रकारों के साथ हस्तक्षेप नहीं करना सबसे अच्छा है।

लिंक द्वारा पास करें

एक निरंतर संदर्भ के माध्यम से मापदंडों को पारित करना एक संकेतक को किसी वस्तु को पारित करने के समान है। यदि ऑब्जेक्ट रजिस्टरों में फिट नहीं होता है, तो इसे पारित किया जाता है और स्टैक के माध्यम से वापस किया जाता है। आइए देखें कि यह कैसे होता है। यथार्थवाद के लिए, त्रि-आयामी बिंदु के लिए संरचना पर विचार करें।

 struct Point3f { float x, y, z; }; struct Point3d { double x, y, z; }; Point3f scale(Point3f p) { return {px * 2, py * 2, pz * 2}; } Point3f scaleR(const Point3f& p) { return {px * 2, py * 2, pz * 2}; } Point3d scale(Point3d p) { return {px * 2, py * 2, pz * 2}; } Point3d scaleR(const Point3d& p) { return {px * 2, py * 2, pz * 2}; } 

फ़ंक्शन कोड की तुलना करें। ज्यादातर नए xmm रजिस्टरों का उपयोग किया जाएगा, इसलिए तर्क समझ में आता है।

 scale(Point3f): # @scale(Point3f) #     , x, y   xmm0, z - xmm1,     . vaddps xmm0, xmm0, xmm0 vaddss xmm1, xmm1, xmm1 ret scaleR(Point3f const&): # @scaleR(Point3f const&) #       rdi,     .      xmm0, xmm1. vmovsd xmm0, qword ptr [rdi] # xmm0 = mem[0],zero vaddps xmm0, xmm0, xmm0 vmovss xmm1, dword ptr [rdi + 8] # xmm1 = mem[0],zero,zero,zero vaddss xmm1, xmm1, xmm1 ret scale(Point3d): # @scale(Point3d) #   rdi  ,     .          [rsp+8, rsp+32).  [rsp, rsp+8)     . vmovapd xmm0, xmmword ptr [rsp + 8] vaddpd xmm0, xmm0, xmm0 vmovupd xmmword ptr [rdi], xmm0 vmovsd xmm0, qword ptr [rsp + 24] # xmm0 = mem[0],zero vaddsd xmm0, xmm0, xmm0 vmovsd qword ptr [rdi + 16], xmm0 mov rax, rdi #  ,    . ret scaleR(Point3d const&): # @scaleR(Point3d const&) #   ,      [rsp+8, rsp+32),   [rsi, rsi+24). vmovupd xmm0, xmmword ptr [rsi] vaddpd xmm0, xmm0, xmm0 vmovupd xmmword ptr [rdi], xmm0 vmovsd xmm0, qword ptr [rsi + 16] # xmm0 = mem[0],zero vaddsd xmm0, xmm0, xmm0 vmovsd qword ptr [rdi + 16], xmm0 mov rax, rdi ret 

अब आइए उस जगह को देखें जहां इन कार्यों को कहा जाता है।

 # scale(Point3f) main: # @main sub rsp, 24 #     . vmovaps xmm0, xmmword ptr [rip + .LCPI4_0] # xmm0 = <1,2,u,u> vmovss xmm1, dword ptr [rip + .LCPI4_1] # xmm1 = <3,u,u,u> call scale(Point3f) # scaleR(const Point3f&) main: # @main sub rsp, 24 #         rdi,     . mov edi, .L_ZZ4mainE1p # <1,2,3,u> call scaleR(Point3f const&) # scale(Point3d) main: # @main sub rsp, 64 #        . mov rax, qword ptr [rip + .L_ZZ4mainE1p+16] mov qword ptr [rsp + 16], rax vmovups xmm0, xmmword ptr [rip + .L_ZZ4mainE1p] vmovups xmmword ptr [rsp], xmm0 lea rbx, [rsp + 40] mov rdi, rbx #     [rsp+40, rsp+64). call scale(Point3d) .L_ZZ4mainE1p: .quad 4607182418800017408 # double 1 .quad 4611686018427387904 # double 2 .quad 4613937818241073152 # double 3 # scaleR(const Point3d&) main: # @main sub rsp, 64 #   . mov rax, qword ptr [rip + .L_ZZ4mainE1p+16] mov qword ptr [rsp + 32], rax vmovups xmm0, xmmword ptr [rip + .L_ZZ4mainE1p] vmovaps xmmword ptr [rsp + 16], xmm0 lea rbx, [rsp + 40] lea rsi, [rsp + 16] #     [rsp+16, rsp+40). mov rdi, rbx #     [rsp+40, rsp+64). call scaleR(Point3d const&) 

देखते हैं कि अगर हमारे पास कई क्षेत्र हैं, लेकिन संरचना अभी भी रजिस्टरों में फिट बैठती है। यहां मस्ती शुरू होती है।

 struct St { char d[16]; }; St foo(St s1, St s2) { //   s1  s2. St res; for(int i{}; i < 16; ++i) res.d[i] = s1.d[i] + s2.d[i]; return res; } 

एक फ़ंक्शन के लिए कोड जो मूल्य द्वारा तर्क लेता है।

 foo(St, St): # @foo(St, St) mov qword ptr [rsp - 16], rdi mov qword ptr [rsp - 8], rsi mov qword ptr [rsp - 32], rdx mov qword ptr [rsp - 24], rcx mov eax, edx add al, dil mov byte ptr [rsp - 48], al mov r8, rdi shr r8, 8 mov rax, rdx shr rax, 8 add al, r8b mov byte ptr [rsp - 47], al mov r8, rdi shr r8, 16 mov rax, rdx shr rax, 16 add al, r8b mov byte ptr [rsp - 46], al mov r8, rdi shr r8, 24 mov rax, rdx shr rax, 24 add al, r8b mov byte ptr [rsp - 45], al mov r8, rdi shr r8, 32 mov rax, rdx shr rax, 32 add al, r8b mov byte ptr [rsp - 44], al mov r8, rdi shr r8, 40 mov rax, rdx shr rax, 40 add al, r8b mov byte ptr [rsp - 43], al mov r8, rdi shr r8, 48 mov rax, rdx shr rax, 48 add al, r8b mov byte ptr [rsp - 42], al shr rdi, 56 shr rdx, 56 add dl, dil mov byte ptr [rsp - 41], dl mov eax, ecx add al, sil mov byte ptr [rsp - 40], al mov rax, rsi shr rax, 8 mov rdx, rcx shr rdx, 8 add dl, al mov byte ptr [rsp - 39], dl shr rsi, 16 shr rcx, 16 add cl, sil mov byte ptr [rsp - 38], cl mov al, byte ptr [rsp - 21] mov cl, byte ptr [rsp - 20] add al, byte ptr [rsp - 5] mov byte ptr [rsp - 37], al add cl, byte ptr [rsp - 4] mov byte ptr [rsp - 36], cl mov al, byte ptr [rsp - 19] mov cl, byte ptr [rsp - 18] add al, byte ptr [rsp - 3] mov byte ptr [rsp - 35], al add cl, byte ptr [rsp - 2] mov byte ptr [rsp - 34], cl mov al, byte ptr [rsp - 17] add al, byte ptr [rsp - 1] mov byte ptr [rsp - 33], al mov rax, qword ptr [rsp - 48] mov rdx, qword ptr [rsp - 40] ret 

हां, यहां सभी तर्कों को स्टैक पर कॉपी किया जाता है, जिसके बाद इसे निकाला जाता है और एक बार में एक बाइट जोड़ा जाता है। जैसा कि आप देख सकते हैं, फ़ंक्शन में बिल्कुल 16 निर्देश हैं। जीसीसी, इस उदाहरण में, एक बहुत अधिक कॉम्पैक्ट कोड का उत्पादन करता है, लेकिन स्टैक के माध्यम से नकल के साथ। क्या कुछ सुधारा जा सकता है? संदर्भ द्वारा संरचना पास करें।

 St fooR(const St& s1, const St& s2) { /*  . */ } 

 fooR(St const&, St const&): # @fooR(St const&, St const&) vmovdqu xmm0, xmmword ptr [rsi] vpaddb xmm0, xmm0, xmmword ptr [rdi] vmovdqa xmmword ptr [rsp - 24], xmm0 mov rax, qword ptr [rsp - 24] mov rdx, qword ptr [rsp - 16] ret 

अरे हाँ! यह बहुत बेहतर लग रहा है। हम एक बार में 16 एकल-बाइट तत्वों को xmm रजिस्टर में लोड कर सकते हैं और vpaddb कॉल कर vpaddb जो उन सभी को एक ऑपरेशन में vpaddb देगा। उसके बाद, परिणाम स्टैक के माध्यम से आउटपुट रजिस्टरों में कॉपी किया जाता है। आप सोच सकते हैं कि पहले तर्क को गैर-निरंतर संदर्भ के साथ बदलकर आप इस अंतिम ऑपरेशन से छुटकारा पा सकते हैं।

 void fooR1(St &s1, const St& s2) { for(int i{}; i < 16; ++i) s1.d[i] += s2.d[i]; } 

 fooR1(St&, St const&): # @fooR1(St&, St const&) mov al, byte ptr [rsi] add byte ptr [rdi], al mov al, byte ptr [rsi + 1] add byte ptr [rdi + 1], al mov al, byte ptr [rsi + 2] add byte ptr [rdi + 2], al mov al, byte ptr [rsi + 3] add byte ptr [rdi + 3], al mov al, byte ptr [rsi + 4] add byte ptr [rdi + 4], al mov al, byte ptr [rsi + 5] add byte ptr [rdi + 5], al mov al, byte ptr [rsi + 6] add byte ptr [rdi + 6], al mov al, byte ptr [rsi + 7] add byte ptr [rdi + 7], al mov al, byte ptr [rsi + 8] add byte ptr [rdi + 8], al mov al, byte ptr [rsi + 9] add byte ptr [rdi + 9], al mov al, byte ptr [rsi + 10] add byte ptr [rdi + 10], al mov al, byte ptr [rsi + 11] add byte ptr [rdi + 11], al mov al, byte ptr [rsi + 12] add byte ptr [rdi + 12], al mov al, byte ptr [rsi + 13] add byte ptr [rdi + 13], al mov al, byte ptr [rsi + 14] add byte ptr [rdi + 14], al mov al, byte ptr [rsi + 15] add byte ptr [rdi + 15], al ret 

लगता है कुछ गड़बड़ हो गई है। ऐसा इसलिए हुआ, क्योंकि डिफ़ॉल्ट रूप से, कंपाइलर बहुत सावधान है, और सुझाव देता है कि प्रोग्रामर आउट ऑफ सॉर्ट हो सकता है और ऐसा कुछ लिख सकता है:

 char buff[17]; fooR1(*reinterpret_cast<St*>(buff+1), reinterpret_cast<const St*>(buff)); 

इस मामले में, buff[i+1] += buff[i] गणना प्रत्येक पुनरावृत्ति पर की जाती है, यानी पॉइंटर अलियासिंग उपलब्ध है। , , , __restrict .

 void fooR2(St & __restrict s1, const St& s2) { /*  . */ } 

.

 fooR2(St&, St const&): # @fooR2(St&, St const&) vmovdqu xmm0, xmmword ptr [rdi] vpaddb xmm0, xmm0, xmmword ptr [rsi] vmovdqu xmmword ptr [rdi], xmm0 ret 

void fooR3(St &__restrict s1, St s2) , , St foo(St, St) .

, , void foo(char* __restrict s1, const char* s2, int size) , __restrict .

b a , , foo :

 St a, b; st(a, b); // st(St& a, St& b) { a = b = {}; }   . a = foo(a, b); a = foo(a, b); a = foo(a, b); a = foo(a, b); 

'no reuse' , . auto a2 = foo(a, b); auto a3 = foo(a2, b); । 'inline' , INLINE , NOINLINE .

fooR1 inline / fooR2 inline , , , , , foo inline / fooR inline , . , , .

, , .

 struct Point3f { float x, y, z; ~Point3f() {} }; Point3f scale(Point3f p) { return {px * 2, py * 2, pz * 2}; } 

rdi , . , rsi , .

 scale(Point3f): # @scale(Point3f) vmovss xmm0, dword ptr [rsi] # xmm0 = mem[0],zero,zero,zero vaddss xmm0, xmm0, xmm0 vmovss dword ptr [rdi], xmm0 vmovss xmm0, dword ptr [rsi + 4] # xmm0 = mem[0],zero,zero,zero vaddss xmm0, xmm0, xmm0 vmovss dword ptr [rdi + 4], xmm0 vmovss xmm0, dword ptr [rsi + 8] # xmm0 = mem[0],zero,zero,zero vaddss xmm0, xmm0, xmm0 vmovss dword ptr [rdi + 8], xmm0 mov rax, rdi ret 

, , ( ) . POD . Point3f scaleR(const Point3f&) . .

 Point3f p{1, 2, 3}; auto result = scale(p); sink(&result); 

 main: # @main push rbx sub rsp, 48 movabs rax, 4611686019492741120 #    . mov qword ptr [rsp + 16], rax mov dword ptr [rsp + 24], 1077936128 lea rbx, [rsp + 32] lea rsi, [rsp + 16] #    [rsp+16, rsp+28) mov rdi, rbx #    [rsp+32, rsp+44) call scale(Point3f) mov qword ptr [rsp + 8], rbx #  [rsp+8, rsp+16)    . lea rdi, [rsp + 8] call void sink<Point3f*>(Point3f* const&) xor eax, eax add rsp, 48 pop rbx ret #  . mov rdi, rax call _Unwind_Resume 

NOINLINE , .

 main: # @main push r14 push rbx sub rsp, 56 movabs rax, 4611686019492741120 #    [rsp, rsp+12).   p. mov qword ptr [rsp], rax mov dword ptr [rsp + 8], 1077936128 #    [rsp+24, rsp+36),    pTmp. mov eax, dword ptr [rsp + 8] mov dword ptr [rsp + 32], eax mov rax, qword ptr [rsp] mov qword ptr [rsp + 24], rax lea r14, [rsp + 40] lea rbx, [rsp + 24] mov rdi, r14 #    [rsp+40, rsp+52),  result. mov rsi, rbx #   -   pTmp. call scale(Point3f) mov rdi, rbx #    pTmp.    -  this. call Point3f::~Point3f() mov qword ptr [rsp + 16], r14 #  [rsp+16, rsp+24)     result.     sink. lea rdi, [rsp + 16] call void sink<Point3f*>(Point3f* const&) lea rdi, [rsp + 40] #    result. call Point3f::~Point3f() mov rdi, rsp #    p. call Point3f::~Point3f() xor eax, eax add rsp, 56 pop rbx pop r14 ret #  .           . mov rbx, rax lea rdi, [rsp + 40] #    result. call Point3f::~Point3f() mov rdi, rsp #    p. call Point3f::~Point3f() mov rdi, rbx call _Unwind_Resume 

p , .

, . .

 # Point3f result = scale(scale(Point3f{1, 2, 3})); sub rsp, 24 vmovaps xmm0, xmmword ptr [rip + .LCPI4_0] # xmm0 = <1,2,u,u> vmovss xmm1, dword ptr [rip + .LCPI4_1] # xmm1 = mem[0],zero,zero,zero #    xmm0, xmm1    ,    ,       ! call scale(Point3f) call scale(Point3f) vmovlps qword ptr [rsp + 8], xmm0 vmovss dword ptr [rsp + 16], xmm1 # Point3f result = scaleR(scaleR(Point3f{1, 2, 3})); sub rsp, 56 #       [rsp+24, rsp+36). movabs rax, 4611686019492741120 # 0x400000003F800000 = [2.0f, 1.0f] mov qword ptr [rsp + 24], rax mov dword ptr [rsp + 32], 1077936128 # 0x40400000 = 3.0f lea rdi, [rsp + 24] #      . call scaleR(Point3f const&) #    [rsp+8, rsp+20). vmovlps qword ptr [rsp + 8], xmm0 vmovss dword ptr [rsp + 16], xmm1 lea rdi, [rsp + 8] #       . call scaleR(Point3f const&) vmovlps qword ptr [rsp + 40], xmm0 vmovss dword ptr [rsp + 48], xmm1 

, , . , .

 # Point3d result = scale(scale(Point3d{1, 2, 3})); sub rsp, 112 #    [rsp, rsp+24). vmovaps xmm0, xmmword ptr [rip + .LCPI4_0] # xmm0 = [1.000000e+00,2.000000e+00] vmovaps xmmword ptr [rsp + 32], xmm0 movabs rax, 4613937818241073152 # 0x4008000000000000 = 3.0 mov qword ptr [rsp + 48], rax mov rax, qword ptr [rsp + 48] mov qword ptr [rsp + 16], rax vmovaps xmm0, xmmword ptr [rsp + 32] vmovups xmmword ptr [rsp], xmm0 #    [rsp+64, rsp+88). lea rdi, [rsp + 64] #  rdi     . call scale(Point3d) #        [rsp, rsp+24). mov rax, qword ptr [rsp + 80] #  z   z . mov qword ptr [rsp + 16], rax vmovups xmm0, xmmword ptr [rsp + 64] #  [x, y]   [x, y] . vmovups xmmword ptr [rsp], xmm0 #    [rsp+88, rsp+112). lea rbx, [rsp + 88] mov rdi, rbx call scale(Point3d) # Point3d result = scaleR(scaleR(Point3d{1, 2, 3})); sub rsp, 72 #    [rsp, rsp+24),   . vmovaps xmm0, xmmword ptr [rip + .LCPI4_0] vmovaps xmmword ptr [rsp], xmm0 movabs rax, 4613937818241073152 mov qword ptr [rsp + 16], rax lea r14, [rsp + 24] mov rsi, rsp #   -       [rsp, rsp+24). mov rdi, r14 #   -      [rsp+24, rsp+48). call scaleR(Point3d const&) lea rbx, [rsp + 48] mov rdi, rbx #      [rsp+48, rsp+72). mov rsi, r14 #       [rsp+24, rsp+48). call scaleR(Point3d const&) 

, , , , . – . . , , .

, . , . , , Point3f , Point3d – .

 //   data.cpp.  . Point3f pf() { return {1, 2, 3}; } Point3d pd() { return {1, 2, 3}; } 

Point3f struct Point3i { int32_t x, y, z; }; Point3d struct Point3ll { int64_t x, y, z; }; , . , , , 64 int, . , Point3f struct Point2ll { int64_t x, y; }; Point3d struct Point4ll { int64_t x, y, z, a; }; , -.

:

• . .
• , , .
• inline , . , , , . .

optional

std::optional , boost::optional , , "x86-64 clang (experimental concepts)" , , MSVC ,

 struct Point { float x, y; }; using OptPoint1 = optional<Point>; 

 struct OptPoint2 { float x, y; union { char _; bool d; }; //   std::optional. }; 

, OptPoint1 , OptPoint2 – .

 OptPoint1 foo(OptPoint1 s) { return Point{s->x + 1, s->y + 1}; } OptPoint2 foo(OptPoint2 s) { return {sx + 1, sy + 1, true}; } ... OptPoint1 s1{Point{1, 2}}; OptPoint2 s2{3, 4, true}; auto result1 = foo(s1); auto result2 = foo(s2); 

 .LCPI0_0: .long 1065353216 # float 1 foo(std::optional<Point>): # @foo(std::optional<Point>) vmovss xmm0, dword ptr [rip + .LCPI0_0] # xmm0 = mem[0],zero,zero,zero #  rsi       . vaddss xmm1, xmm0, dword ptr [rsi] #  x  ,  1. vaddss xmm0, xmm0, dword ptr [rsi + 4] #  y  ,  1. vmovss dword ptr [rdi], xmm1 #  x  , rdi      ,     . vmovss dword ptr [rdi + 4], xmm0 #  y  . mov byte ptr [rdi + 8], 1 #  optional::has_value(). mov rax, rdi #    . ret .LCPI1_0: .long 1065353216 # float 1 .long 1065353216 # float 1 .zero 4 .zero 4 foo(OptPoint2): # @foo(OptPoint2) vaddps xmm0, xmm0, xmmword ptr [rip + .LCPI1_0] #  [x, y] c [1, 1].  xmm0  . mov al, 1 #  d, al -   8   rax. ret .LCPI2_0: .long 1077936128 # float 3 .long 1082130432 # float 4 .zero 4 .zero 4 main: # @main push rbx sub rsp, 64 movabs rax, 4611686019492741120 # 0x400000003F800000  x  y. mov qword ptr [rsp + 32], rax #  x, y  . mov byte ptr [rsp + 40], 1 #  optional::has_value(). lea rbx, [rsp + 48] lea rsi, [rsp + 32] #    . mov rdi, rbx #    . call foo(std::optional<Point>) #     . vmovaps xmm0, xmmword ptr [rip + .LCPI2_0] # xmm0 = <3,4,u,u> mov edi, 1 #  bool d. call foo(OptPoint2) vmovlps qword ptr [rsp + 16], xmm0 #    . mov byte ptr [rsp + 24], al #  al      rax. 

, foo inline , .

  # OptPoint1 foo(OptPoint1)  OptPoint1 foo(const OptPoint1&) vmovss xmm0, dword ptr [rip + .LCPI0_0] # xmm0 = mem[0],zero,zero,zero vaddss xmm1, xmm0, dword ptr [rsp + 32] vaddss xmm0, xmm0, dword ptr [rsp + 36] vmovss dword ptr [rsp + 8], xmm1 vmovss dword ptr [rsp + 12], xmm0 mov byte ptr [rsp + 16], 1 # OptPoint2 foo(OptPoint2)  OptPoint2 foo(const OptPoint2&) vmovsd xmm0, qword ptr [rsp + 48] # xmm0 = mem[0],zero vaddps xmm0, xmm0, xmmword ptr [rip + .LCPI0_1] vmovlps qword ptr [rsp + 8], xmm0 mov byte ptr [rsp + 16], 1 

, , , .

: inline , std::optional .

, , . . , . , - , , , . .

 struct Fn { virtual ~Fn() noexcept = default; virtual int call(int x) const = 0; }; struct Add final : Fn { Add(int a) : a(a) {} int call(int x) const override { return a + x; } int a; }; NOINLINE bool isFixedPoint(const Fn& fn, int x) { return fn.call(x) == x; } int main() { Add add{32}; bool result = isFixedPoint(add, 10); } 

- .

 Add::call(int) const: # @Add::call(int) const #  rdi   this  ,   [rdi, rdi+8)      ,       . add esi, dword ptr [rdi + 8] mov eax, esi #    rax, eax     32 . ret #      Add.       16,   RTTI    . vtable for Add: .quad 0 .quad typeinfo for Add #   RTTI.  -8. .quad Fn::~Fn() # ,  0    . .quad Add::~Add() .quad Add::call(int) const # ,  16 . isFixedPoint(Fn const&, int): # @isFixedPoint(Fn const&, int) push rbx #         rbx,    ,    . mov ebx, esi #  32   . mov rax, qword ptr [rdi] #  rdi    -   Fn,         this . call qword ptr [rax + 16] #  Add::call. cmp eax, ebx #   call    rax,    ebx,      . sete al #     8   eax. pop rbx #   rbx. ret main: # @main sub rsp, 40 mov qword ptr [rsp + 24], vtable for Add+16 #          Add,    16  ,    , ,  .    RTTI    . mov dword ptr [rsp + 32], 32 #  add.a   . lea rdi, [rsp + 24] #      . mov esi, 10 #   . call isFixedPoint(Fn const&, int) mov byte ptr [rsp + 15], al #    . ... mov rdi, rax #  . call _Unwind_Resume mov rdi, rax call _Unwind_Resume 

protected , ( 34-37). NOINLINE , ( false ). NOINLINE , . .

 struct Add final { Add(int a) : a(a) {} NOINLINE int call(int x) const { return a + x; } int a; }; template<typename T> NOINLINE bool isFixedPoint(const T& fn, int x) { return fn.call(x) == x; } 

 Add::call(int) const: # @Add::call(int) const add esi, dword ptr [rdi] #    , this   rdi  ,        ,      . mov eax, esi ret bool isFixedPoint<Add>(Add const&, int): # @bool isFixedPoint<Add>(Add const&, int) push rbx mov ebx, esi # Add::call         ,   isFixedPoint. call Add::call(int) const cmp eax, ebx sete al pop rbx ret main: # @main sub rsp, 24 mov dword ptr [rsp + 8], 32 #  add.a. lea rdi, [rsp + 8] #    ,  rdi    add.a. mov esi, 10 call bool isFixedPoint<Add>(Add const&, int) mov byte ptr [rsp + 7], al ... ret 

, NOINLINE .

1000 Add isFixedPoint .

:

• .
• , .
• , , , inline. .
• inline . inline - cpp , NOINLINE .
• inline .

call , jmp .

. clang . , :

 double exp_by_squaring(double x, int n, double y = 1) { if (n < 0) return exp_by_squaring(1.0 / x, -n, y); if (n == 0) return y; if (n == 1) return x * y; if (n % 2 == 0) return exp_by_squaring(x * x, n / 2, y); return exp_by_squaring(x * x, (n - 1) / 2, x * y); } 

हमें मिलता है:

 .LCPI0_0: .quad 4607182418800017408 # double 1 exp_by_squaring(double, int, double): # @exp_by_squaring(double, int, double) vmovsd xmm2, qword ptr [rip + .LCPI0_0] # xmm2 = mem[0],zero vmovapd xmm3, xmm0 test edi, edi jns .LBB0_4 jmp .LBB0_3 .LBB0_9: # in Loop: Header=BB0_4 Depth=1 shr edi vmovapd xmm3, xmm0 test edi, edi jns .LBB0_4 .LBB0_3: # =>This Inner Loop Header: Depth=1 vdivsd xmm3, xmm2, xmm3 neg edi test edi, edi js .LBB0_3 .LBB0_4: # =>This Inner Loop Header: Depth=1 je .LBB0_7 cmp edi, 1 je .LBB0_6 vmulsd xmm0, xmm3, xmm3 test dil, 1 je .LBB0_9 lea eax, [rdi - 1] shr eax, 31 lea edi, [rdi + rax] add edi, -1 sar edi vmulsd xmm1, xmm3, xmm1 vmovapd xmm3, xmm0 test edi, edi jns .LBB0_4 jmp .LBB0_3 .LBB0_6: vmulsd xmm1, xmm3, xmm1 .LBB0_7: vmovapd xmm0, xmm1 ret 

, , . , , . ~10% .

. .

 int64_t sum(int64_t x, int64_t y) { return x + y; } int64_t add1(int64_t x) { return sum(x, 1); } int64_t add2(int64_t x) { return sum(1, x); } int64_t add3(int64_t x) { return sum(-1, x) + 2; } 

 sum(long, long): # @sum(long, long) lea rax, [rdi + rsi] ret add1(long): # @add1(long) mov esi, 1 #   . jmp sum(long, long) # TAILCALL add2(long): # @add2(long) mov rax, rdi #   . mov edi, 1 mov rsi, rax jmp sum(long, long) # TAILCALL add3(long): # @add3(long) push rax #  rax   . mov rax, rdi #  ,    add2,  . mov rdi, -1 mov rsi, rax call sum(long, long) add rax, 2 #  2    . pop rcx ret 

, , call , jmp . , , sum , , add .

, 10%.

:

• , .
• .

. 2D :

 struct Point { double x, y; }; struct ZeroPoint { double x{}, y{}; }; struct NanPoint { double x{quietNaN}, y{quietNaN}; }; 

Point . ZeroPoint . IEEE 754-1985:

The number zero is represented specially: sign = 0 for positive zero, 1 for negative zero; biased exponent = 0; fraction = 0;

memset . NanPoint numeric_limits<double>::quiet_NaN(); , .

 Point data; 

  sub rsp, 24 

- .

 ZeroPoint data; Point data{}; 

.

  sub rsp, 40 vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp + 16], xmm0 

. xmm0 . XOR vxorps . .

 NanPoint data; 

  sub rsp, 40 vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] vmovaps xmmword ptr [rsp + 16], xmm0 

, .

:

 static constexpr size_t smallSize = 8; static constexpr size_t bigSize = 321; extern size_t smallUnknownSize; // Also 8 extern size_t bigUnknownSize; // Also 321 

.

 array<Point, smallSize> data; 

– .

  sub rsp, 136 

, .

 array<ZeroPoint, smallSize> data; array<ZeroPoint, smallSize> data{}; array<Point, smallSize> data{}; 

.

  sub rsp, 192 vxorps ymm0, ymm0, ymm0 vmovaps ymmword ptr [rsp + 128], ymm0 vmovaps ymmword ptr [rsp + 96], ymm0 vmovaps ymmword ptr [rsp + 64], ymm0 vmovaps ymmword ptr [rsp + 32], ymm0 

256 , 2 .

 array<NanPoint, smallSize> data; array<NanPoint, smallSize> data{}; 

  sub rsp, 136 vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] vmovups xmmword ptr [rsp + 24], xmm0 vmovups xmmword ptr [rsp + 8], xmm0 vmovups xmmword ptr [rsp + 56], xmm0 vmovups xmmword ptr [rsp + 40], xmm0 vmovups xmmword ptr [rsp + 88], xmm0 vmovups xmmword ptr [rsp + 72], xmm0 vmovups xmmword ptr [rsp + 120], xmm0 vmovups xmmword ptr [rsp + 104], xmm0 

.

 array<Point, bigSize> data; 

  sub rsp, 5144 

.

 array<ZeroPoint, bigSize> data; array<ZeroPoint, bigSize> data{}; array<Point, bigSize> data{}; 

  sub rsp, 5152 lea rbx, [rsp + 16] xor esi, esi mov edx, 5136 mov rdi, rbx call memset #  memset(rsp+16, 0, 5136). 

, memset . , , rdi, esi, edx . e d 32 64- .

 array<NanPoint, bigSize> data; 

  sub rsp, 5144 lea rax, [rsp + 8] lea rcx, [rsp + 5144] vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] #  . .LBB0_1: # =>This Inner Loop Header: Depth=1 vmovups xmmword ptr [rax], xmm0 vmovups xmmword ptr [rax + 16], xmm0 vmovups xmmword ptr [rax + 32], xmm0 add rax, 48 cmp rax, rcx jne .LBB0_1 

. , 321 3 . rax, rcx .

 array<NanPoint, bigSize> data{}; 

  sub rsp, 5152 lea rbx, [rsp + 16] xor esi, esi mov edx, 5136 mov rdi, rbx call memset #  memset(rsp+16, 0, 5136). lea rax, [rsp + 5152] vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] #  . .LBB0_1: # =>This Inner Loop Header: Depth=1 vmovups xmmword ptr [rbx], xmm0 vmovups xmmword ptr [rbx + 16], xmm0 vmovups xmmword ptr [rbx + 32], xmm0 add rbx, 48 cmp rbx, rax jne .LBB0_1 

. , memset . , , . .

 vector<Point> data(smallSize); 

  sub rsp, 40 vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 mov edi, 128 call operator new(unsigned long) #  new(128). mov qword ptr [rsp], rax mov rcx, rax sub rcx, -128 mov qword ptr [rsp + 16], rcx vxorps xmm0, xmm0, xmm0 #     . vmovups xmmword ptr [rax + 16], xmm0 vmovups xmmword ptr [rax], xmm0 vmovups xmmword ptr [rax + 32], xmm0 vmovups xmmword ptr [rax + 48], xmm0 vmovups xmmword ptr [rax + 64], xmm0 vmovups xmmword ptr [rax + 80], xmm0 vmovups xmmword ptr [rax + 96], xmm0 vmovups xmmword ptr [rax + 112], xmm0 

new . , T{} , , . ZeroPoint NanPoint . :

 vector<Point> data(bigSize); 

 main: # @main push rbx sub rsp, 48 vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 mov edi, 5136 call operator new(unsigned long) #  new(5136). mov qword ptr [rsp], rax mov qword ptr [rsp + 8], rax mov rcx, rax add rcx, 5136 mov qword ptr [rsp + 16], rcx vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp + 32], xmm0 xor edx, edx #    . .LBB0_2: # =>This Inner Loop Header: Depth=1 vmovaps xmm0, xmmword ptr [rsp + 32] vmovups xmmword ptr [rax + rdx], xmm0 vmovaps xmm0, xmmword ptr [rsp + 32] vmovups xmmword ptr [rax + rdx + 16], xmm0 vmovaps xmm0, xmmword ptr [rsp + 32] vmovups xmmword ptr [rax + rdx + 32], xmm0 add rdx, 48 cmp rdx, 5136 jne .LBB0_2 mov qword ptr [rsp + 8], rcx mov rax, rsp 

, . NanPoint .

 vector<NanPoint> data(bigSize); 

 main: # @main push rbx sub rsp, 32 vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 mov edi, 5136 call operator new(unsigned long) #  new(5136). mov qword ptr [rsp], rax mov qword ptr [rsp + 8], rax mov rcx, rax add rcx, 5136 mov qword ptr [rsp + 16], rcx xor edx, edx vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] #    NAN. .LBB0_2: # =>This Inner Loop Header: Depth=1 vmovups xmmword ptr [rax + rdx], xmm0 vmovups xmmword ptr [rax + rdx + 16], xmm0 vmovups xmmword ptr [rax + rdx + 32], xmm0 add rdx, 48 cmp rdx, 5136 jne .LBB0_2 mov qword ptr [rsp + 8], rcx mov rax, rsp 

A ZeroPoint .

 vector<ZeroPoint> data(bigSize); 

  sub rsp, 32 vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 mov edi, 5136 call operator new(unsigned long) #  new(5136). mov qword ptr [rsp], rax mov rbx, rax add rbx, 5136 mov qword ptr [rsp + 16], rbx xor esi, esi mov edx, 5136 mov rdi, rax call memset #  memset(&data, 0, 5136). 

memset . , , memset Point . , , bigUnknownSize .

 vector<NanPoint> data(bigUnknownSize); 

  sub rsp, 32 mov rbx, qword ptr [rip + bigUnknownSize] vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 test rbx, rbx #  bigUnknownSize == 0,   new. je .LBB0_1 mov rax, rbx shr rax, 60 jne .LBB0_3 mov rdi, rbx shl rdi, 4 #   16    4. call operator new(unsigned long) #  new(bigUnknownSize*16). jmp .LBB0_6 .LBB0_1: xor eax, eax .LBB0_6: mov rcx, rbx shl rcx, 4 add rcx, rax mov qword ptr [rsp], rax mov qword ptr [rsp + 8], rax mov qword ptr [rsp + 16], rcx test rbx, rbx #  bigUnknownSize == 0,   . je .LBB0_14 lea rdx, [rbx - 1] mov rsi, rbx and rsi, 7 je .LBB0_10 neg rsi vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] #   0-7 . .LBB0_9: # =>This Inner Loop Header: Depth=1 vmovups xmmword ptr [rax], xmm0 dec rbx add rax, 16 inc rsi jne .LBB0_9 .LBB0_10: cmp rdx, 7 jb .LBB0_13 vmovaps xmm0, xmmword ptr [rip + .LCPI0_0] # xmm0 = [nan,nan] #      8. .LBB0_12: # =>This Inner Loop Header: Depth=1 vmovups xmmword ptr [rax], xmm0 vmovups xmmword ptr [rax + 16], xmm0 vmovups xmmword ptr [rax + 32], xmm0 vmovups xmmword ptr [rax + 48], xmm0 vmovups xmmword ptr [rax + 64], xmm0 vmovups xmmword ptr [rax + 80], xmm0 vmovups xmmword ptr [rax + 96], xmm0 vmovups xmmword ptr [rax + 112], xmm0 sub rax, -128 add rbx, -8 jne .LBB0_12 .LBB0_13: mov rax, rcx .LBB0_14: mov qword ptr [rsp + 8], rax mov rax, rsp 

. , LBB0_9 , 8. 8 .

, Point , ZeroPoint memset :

 vector<ZeroPoint> data(bigUnknownSize); 

  sub rsp, 40 mov rbx, qword ptr [rip + bigUnknownSize] vxorps xmm0, xmm0, xmm0 vmovaps xmmword ptr [rsp], xmm0 mov qword ptr [rsp + 16], 0 test rbx, rbx #  bigUnknownSize == 0,   new. je .LBB0_1 mov rax, rbx shr rax, 60 jne .LBB0_3 mov rdi, rbx shl rdi, 4 call operator new(unsigned long) #  new(bigUnknownSize*16). jmp .LBB0_6 .LBB0_1: xor eax, eax .LBB0_6: mov rdx, rbx shl rdx, 4 lea r14, [rax + rdx] mov qword ptr [rsp], rax mov qword ptr [rsp + 8], rax mov qword ptr [rsp + 16], r14 test rbx, rbx #  bigUnknownSize == 0,   memset. je .LBB0_8 xor esi, esi mov rdi, rax call memset #  memset(&data, 0, bigUnknownSize*16). mov rax, r14 .LBB0_8: mov qword ptr [rsp + 8], rax mov rax, rsp 

,

 vector<NanPoint> data; data.resize(bigUnknownSize); 

250 , . operator new , .

.

:

• .
• .
• memset , .
• .
• , . .
• . .
• , . .