सख्त अलियासिंग क्या है और हमें क्यों परवाह करनी चाहिए? भाग 1

(या विचित्र टाइपिंग, अस्पष्ट व्यवहार और संरेखण, हे भगवान!)

सभी को नमस्कार, कुछ हफ्तों में हम पाठ्यक्रम "सी ++ डेवलपर" पर एक नया धागा लॉन्च कर रहे हैं। यह आयोजन हमारी आज की सामग्री को समर्पित होगा।

सख्त अलियासिंग क्या है? पहले, हम वर्णन करते हैं कि अलियासिंग क्या है, और फिर हमें पता चलता है कि सख्ती क्या है।

C और C ++ में, एलियासिंग इस बात से संबंधित है कि हमें किस प्रकार के भावों को संग्रहीत मूल्यों तक पहुँचने की अनुमति है। C और C ++ दोनों में, मानक परिभाषित करता है कि कौन से प्रकार के लिए अभिव्यक्ति नामकरण मान्य हैं। कंपाइलर और ऑप्टिमाइज़र को यह मानने की अनुमति है कि हम सख्ती से अलियासिंग नियमों का पालन करते हैं, इसलिए यह शब्द सख्त अलियासिंग नियम है। यदि हम एक अमान्य प्रकार का उपयोग करके एक मूल्य तक पहुंचने की कोशिश करते हैं, तो इसे अपरिभाषित व्यवहार (यूबी) के रूप में वर्गीकृत किया जाता है। जब हमारे पास अनिश्चित व्यवहार होता है, तो सभी दांव बन जाते हैं, हमारे कार्यक्रम के परिणाम विश्वसनीय हो जाते हैं।

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



यह समझने के लिए कि हमें इसकी चिंता क्यों करनी चाहिए, हम उन समस्याओं पर चर्चा करेंगे जो कड़े अलियासिंग नियमों का उल्लंघन करते समय उत्पन्न होती हैं, प्रकार की चकाचौंध, क्योंकि इसका उपयोग अक्सर सख्त अलियासिंग नियमों में किया जाता है, साथ ही साथ एक वाक्य को सही ढंग से कैसे बनाया जाए। सजा को आसान बनाने और त्रुटियों की संभावना को कम करने के लिए C ++ 20 के साथ कुछ संभव सहायता। हम सख्त अलियासिंग नियमों के उल्लंघन का पता लगाने के लिए कुछ तरीकों पर विचार करके चर्चा को संक्षेप में प्रस्तुत करेंगे।

प्रारंभिक उदाहरण

आइए कुछ उदाहरणों पर एक नज़र डालते हैं, और फिर हम चर्चा कर सकते हैं कि मानक (नों) में वास्तव में क्या कहा गया है, कुछ अतिरिक्त उदाहरणों पर विचार करें, और फिर देखें कि हम सख्त चूक से कैसे बचें और उन उल्लंघनों की पहचान करें जिनसे हम चूक गए थे। यहाँ एक उदाहरण है जो आपको आश्चर्यचकित नहीं करना चाहिए:

int x = 10; int *ip = &x; std::cout << *ip << "\n"; *ip = 12; std::cout << x << "\n"; 

हमारे पास int * है जो इंट द्वारा कब्जा की गई मेमोरी की ओर इशारा करता है, और यह वैध एलियासिंग है। ऑप्टिमाइज़र को यह मान लेना चाहिए कि आईपी के माध्यम से असाइनमेंट x के कब्जे वाले मूल्य को अपडेट कर सकते हैं।

निम्न उदाहरण अलियासिंग दिखाता है, जो अपरिभाषित व्यवहार की ओर जाता है:

 int foo( float *f, int *i ) { *i = 1; *f = 0.f; return *i; } int main() { int x = 0; std::cout << x << "\n"; // Expect 0 x = foo(reinterpret_cast<float*>(&x), &x); std::cout << x << "\n"; // Expect 0? } 

फू फ़ंक्शन में, हम int * और float * लेते हैं। इस उदाहरण में, हम foo कहते हैं और दोनों मापदंडों को एक ही मेमोरी स्थान पर इंगित करने के लिए सेट करते हैं, जिसमें इस उदाहरण में एक इंट होता है। ध्यान दें कि reinterpret_cast कंपाइलर को अभिव्यक्ति का इलाज करने के लिए कहता है जैसे कि यह टेम्पलेट पैरामीटर द्वारा निर्दिष्ट प्रकार था। इस मामले में, हम उसे & x अभिव्यक्ति को संसाधित करने के लिए कहते हैं जैसे कि यह फ्लोट * का प्रकार था। हम उम्मीद कर सकते हैं कि दूसरी कौट का परिणाम 0 होगा, लेकिन जब ऑप्ट-ओ 2 और जीसीसी का उपयोग करके अनुकूलन सक्षम किया जाता है, और क्लैंग को निम्नलिखित परिणाम मिलेगा:
0
1

जो अप्रत्याशित, लेकिन पूरी तरह से सही हो सकता है, क्योंकि हमने अपरिभाषित व्यवहार का कारण बना। फ्लोट एक इंट ऑब्जेक्ट का वैध उपनाम नहीं हो सकता है। इसलिए, ऑप्टिमाइज़र मान सकता है कि डेरीफेरिंग के दौरान संग्रहीत 1 स्थिर रिटर्न मूल्य होगा, क्योंकि एफ के माध्यम से बचत करने से इंट ऑब्जेक्ट को सही ढंग से प्रभावित नहीं किया जा सकता है। कंपाइलर एक्सप्लोरर में कोड कनेक्ट करने से पता चलता है कि वास्तव में ऐसा ही होता है ( उदाहरण ):

 foo(float*, int*): # @foo(float*, int*) mov dword ptr [rsi], 1 mov dword ptr [rdi], 0 mov eax, 1 ret 

टाइप-बेस्ड अलियास एनालिसिस (TBAA) का उपयोग करने वाला एक ऑप्टिमाइज़र मानता है कि 1 को वापस कर दिया जाएगा, और सीधे ईएक्स रजिस्टर में निरंतर मान को स्थानांतरित करता है, जो रिटर्न वैल्यू को स्टोर करता है। TBAA लोडिंग और स्टोरेज को ऑप्टिमाइज़ करने के लिए एलियासिंग के लिए किस प्रकार की अनुमति है, इसके बारे में भाषा नियमों का उपयोग करता है। इस मामले में, TBAA जानता है कि फ्लोट इंट का एक उपनाम नहीं हो सकता है, और मैं अनुकूलन को मौत के लिए लोड करता है।

अब संदर्भ के लिए

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

C11 मानक क्या कहता है?

C11 मानक पैरा 7 के "6.5 भाव" खंड में निम्नलिखित कहता है:

ऑब्जेक्ट का अपना संग्रहीत मूल्य होना चाहिए, जिस तक पहुंच केवल लैवल्यू एक्सप्रेशन का उपयोग करके की जाती है, जिसमें निम्न में से एक प्रकार है: 88) - ऑब्जेक्ट के प्रभावी प्रकार के साथ संगत एक प्रकार,

 int x = 1; int *p = &x; printf("%d\n", *p); //* p   lvalue-  int,    int 

- वर्तमान प्रकार के ऑब्जेक्ट के साथ संगत एक प्रकार का एक योग्य संस्करण,

 int x = 1; const int *p = &x; printf("%d\n", *p); // * p   lvalue-  const int,    int 

- एक प्रकार जो एक योग्य प्रकार की वस्तु के अनुरूप संकेत के साथ या बिना एक प्रकार है,

 int x = 1; unsigned int *p = (unsigned int*)&x; printf("%u\n", *p ); // *p   lvalue-  unsigned int,      

Gcc / clang एक्सटेंशन के लिए Footnote 12 देखें , जो आपको अहस्ताक्षरित int * int * असाइन करने की अनुमति देता है, भले ही वे संगत प्रकार न हों।

- एक प्रकार जो वर्तमान प्रकार के ऑब्जेक्ट के एक योग्य संस्करण के अनुरूप एक संकेत के साथ या बिना एक प्रकार है,

 int x = 1; const unsigned int *p = (const unsigned int*)&x; printf("%u\n", *p ); // *p   lvalue-  const unsigned int,     ,        

- एक समग्र या संयुक्त प्रकार जिसमें इसके सदस्यों में से एक प्रकार शामिल है (सहित, पुनरावर्ती, एक उप-एकत्र या निहित संघ का सदस्य), या

 struct foo { int x; }; void foobar( struct foo *fp, int *ip );// struct foo -  ,   int   ,       *ip // foo f; foobar( &f, &f.x ); 

- चरित्र प्रकार।

 int x = 65; char *p = (char *)&x; printf("%c\n", *p ); // * p   lvalue-  char,    . //    -    . 

क्या सी ++ 17 ड्राफ्ट मानक कहते हैं

धारा 11 में सी ++ 17 परियोजना मानक [basic.lval] में कहा गया है: यदि कोई प्रोग्राम किसी वस्तु के संग्रहित मूल्य को निम्न प्रकारों के अलावा किसी अन्य वस्तु के माध्यम से प्राप्त करने का प्रयास करता है, तो व्यवहार अपरिभाषित है: 63 (11.1) एक गतिशील प्रकार की वस्तु है,

 void *p = malloc( sizeof(int) ); //   ,       int *ip = new (p) int{0}; // placement new      int std::cout << *ip << "\n"; // * ip   glvalue-  int,       

(११.२) - cv-qual (cv - const और वाष्पशील) किसी वस्तु के गतिशील प्रकार का संस्करण,

 int x = 1; const int *cip = &x; std::cout << *cip << "\n"; // * cip    glvalue  const int,   cv-    x 

(११.३) - किसी वस्तु के गतिशील प्रकार के समान (जैसा कि in.५ में परिभाषित है),

//

(११.४) - एक प्रकार जो किसी वस्तु के गतिशील प्रकार के अनुरूप या उसके बिना एक प्रकार है,
// si ui ,
// godbolt (https://godbolt.org/g/KowGXB) , .

 signed int foo( signed int &si, unsigned int &ui ) { si = 1; ui = 2; return si; } 

(११.५) - एक प्रकार जो एक संकेत के साथ या बिना एक प्रकार का होता है, जो किसी वस्तु के गतिशील प्रकार के cv- योग्य संस्करण के अनुरूप होता है,

 signed int foo( const signed int &si1, int &si2); //  ,     

(११.६) - एक समग्र या संयुक्त प्रकार जिसमें इसके तत्वों या गैर-स्थैतिक डेटा तत्वों में से एक प्रकार शामिल है (सहित, पुनरावर्ती, एक तत्व या गैर-स्थैतिक डेटा तत्व एक उप-कुल या संघों से युक्त),

 struct foo { int x; }; 

// Compiler Explorer (https://godbolt.org/g/z2wJTC)

 int foobar( foo &fp, int &ip ) { fp.x = 1; ip = 2; return fp.x; } foo f; foobar( f, fx ); 

(११. () - एक प्रकार जो एक गतिशील वस्तु प्रकार का एक आधार वर्ग प्रकार (संभवतः cv- योग्य) है,

 struct foo { int x ; }; struct bar : public foo {}; int foobar( foo &f, bar &b ) { fx = 1; bx = 2; return fx; } 

(11.8) - char, unsigned char या std :: byte टाइप करें।

 int foo( std::byte &b, uint32_t &ui ) { b = static_cast<std::byte>('a'); ui = 0xFFFFFFFF; return std::to_integer<int>( b ); // b   glvalue-  std::byte,      uint32_t } 

यह ध्यान देने योग्य है कि signed char उपरोक्त सूची में शामिल नहीं है, यह सी से ध्यान देने योग्य अंतर है, जो चरित्र के प्रकार के बारे में बोलता है।

सूक्ष्म अंतर

इस प्रकार, हालांकि हम देख सकते हैं कि सी और सी ++ अलियासिंग के बारे में इसी तरह की बातें कहते हैं, कुछ अंतर हैं जिनसे हमें अवगत होना चाहिए। C ++ में एक मान्य या संगत प्रकार की C अवधारणा नहीं है, और C में एक गतिशील या समान प्रकार की C ++ अवधारणा नहीं है। हालाँकि, दोनों में लवल्यू और रिवेल्यू भाव हैं, लेकिन C ++ में ग्लव्यू, प्रील्यू, और ज़वल्यू भाव भी हैं। ये अंतर काफी हद तक इस लेख के दायरे से बाहर हैं, लेकिन एक दिलचस्प उदाहरण यह है कि मैलोडोक द्वारा उपयोग की जाने वाली मेमोरी से ऑब्जेक्ट कैसे बनाया जाए। सी में, हम एक वैध प्रकार सेट कर सकते हैं, उदाहरण के लिए, लैवल्यू या मेमसीपी के माध्यम से मेमोरी में लिखना।

 //     C,    C ++ void *p = malloc(sizeof(float)); float f = 1.0f; memcpy( p, &f, sizeof(float)); //   *p - float  C //  float *fp = p; *fp = 1.0f; //   *p - float  C 

इनमें से कोई भी तरीका C ++ में पर्याप्त नहीं है, जिसके लिए नए प्लेसमेंट की आवश्यकता है:

 float *fp = new (p) float{1.0f} ; //   *p  float 

क्या int8_t और uint8_t char प्रकार हैं?

सैद्धांतिक रूप से, न तो int8_t और न ही uint8_t को चार प्रकार का होना चाहिए, लेकिन व्यवहार में वे इस तरह से लागू होते हैं। यह महत्वपूर्ण है क्योंकि अगर वे वास्तव में चरित्र प्रकार हैं, तो वे भी चार प्रकार के उपनाम हैं। यदि आप इसके बारे में नहीं जानते हैं, तो इससे अप्रत्याशित प्रदर्शन में गिरावट आ सकती है । हम देखते हैं कि glibc typedef क्रमश: signed char और unsigned char लिए int8_t और uint8_t है।

इसे बदलना मुश्किल होगा, क्योंकि C ++ के लिए यह एक ABI गैप होगा। यह नाम विरूपण को बदल देगा और किसी भी एपीआई को उनके इंटरफ़ेस में किसी भी प्रकार का उपयोग करके तोड़ देगा।

पहले भाग का अंत। और हम कुछ दिनों में टाइपिंग और अलाइनमेंट की सजा के बारे में बात करेंगे।

अपनी टिप्पणियों को लिखें और खुले वेबिनार को याद न करें, जो 6 मार्च को रामबलर एंड कंपनी, दिमित्री शबॉर्डेव में प्रौद्योगिकी विकास के प्रमुख द्वारा आयोजित किया जाएगा।