डेटा संरचना संरेखण

डेटा संरचना संरेखण वह तरीका है जिससे डेटा को स्मृति में व्यवस्थित और एक्सेस किया जाता है। इसमें तीन अलग-अलग लेकिन संबंधित मुद्दे शामिल हैं: डेटा संरेखण, डेटा संरचना पैडिंग और पैकिंग।

आधुनिक कंप्यूटर हार्डवेयर में सेंट्रल प्रोसेसिंग यूनिट डेटा को 'स्वाभाविक रूप से संरेखित' होने पर सबसे अधिक कुशलता से मेमोरी को पढ़ता और लिखता है, जिसका आम तौर पर मतलब है कि डेटा का मेमोरी एड्रेस डेटा आकार का एक गुणक है। उदाहरण के लिए, 32-बिट आर्किटेक्चर में, डेटा को संरेखित किया जा सकता है यदि डेटा को लगातार चार बाइट्स में संग्रहीत किया जाता है और पहला बाइट 4-बाइट सीमा पर स्थित होता है।

'डेटा संरेखण' तत्वों का उनके प्राकृतिक संरेखण के अनुसार संरेखण है। प्राकृतिक संरेखण सुनिश्चित करने के लिए, संरचना तत्वों के बीच या संरचना के अंतिम तत्व के बाद कुछ पैडिंग डालना आवश्यक हो सकता है। उदाहरण के लिए, एक 32-बिट मशीन पर, 32-बिट मान के बाद एक 16-बिट मान वाली डेटा संरचना में 16-बिट मान और 32-बिट मान के बीच संरेखित करने के लिए 16 बिट्स पैडिंग हो सकते हैं। 32-बिट सीमा पर 32-बिट मान। वैकल्पिक रूप से, कोई पैडिंग को छोड़ कर संरचना को 'पैक' कर सकता है, जिससे धीमी पहुंच हो सकती है, लेकिन तीन चौथाई मेमोरी का उपयोग करता है।

हालांकि डेटा संरचना संरेखण सभी आधुनिक कंप्यूटरों के लिए एक मूलभूत मुद्दा है, कई कंप्यूटर भाषाएं और कंप्यूटर भाषा कार्यान्वयन स्वचालित रूप से डेटा संरेखण को संभालते हैं। फोरट्रान, एडा (प्रोग्रामिंग भाषा), पी एल / मैं, पास्कल (प्रोग्रामिंग भाषा), निश्चित सी (प्रोग्रामिंग भाषा) और सी ++ कार्यान्वयन, डी (प्रोग्रामिंग भाषा), जंग (प्रोग्रामिंग भाषा), सी शार्प (प्रोग्रामिंग लैंग्वेज)|सी#, और सभा की भाषा डेटा स्ट्रक्चर पैडिंग के कम से कम आंशिक नियंत्रण की अनुमति देती है, जो कुछ विशेष परिस्थितियों में उपयोगी हो सकती है।

परिभाषाएँ

एक स्मृति पता a को n-बाइट संरेखित कहा जाता है जब a n का गुणक होता है (जहाँ n 2 की शक्ति है)। इस संदर्भ में, एक बाइट मेमोरी एक्सेस की सबसे छोटी इकाई है, यानी प्रत्येक मेमोरी एड्रेस एक अलग बाइट निर्दिष्ट करता है। एक एन-बाइट संरेखित पते में न्यूनतम होगा log₂(n) न्यूनतम-महत्वपूर्ण शून्य जब बाइनरी अंक प्रणाली में व्यक्त किया जाता है।

वैकल्पिक शब्द b-बिट संरेखित एक b/8 बाइट संरेखित पता निर्दिष्ट करता है (उदा. 64-बिट संरेखित 8 बाइट संरेखित है)।

जब एक्सेस किया जा रहा डेटा n बाइट लंबा होता है और डेटम पता n-बाइट संरेखित होता है, तो मेमोरी एक्सेस को संरेखित कहा जाता है। जब कोई मेमोरी एक्सेस संरेखित नहीं होती है, तो इसे गलत संरेखण कहा जाता है। ध्यान दें कि परिभाषा के अनुसार बाइट मेमोरी एक्सेस हमेशा संरेखित होते हैं।

एक मेमोरी पॉइंटर जो n बाइट्स लंबे आदिम डेटा को संदर्भित करता है, उसे संरेखित कहा जाता है यदि उसे केवल उन पतों को शामिल करने की अनुमति है जो n-बाइट संरेखित हैं, अन्यथा इसे असंरेखित कहा जाता है। एक मेमोरी पॉइंटर जो एक डेटा समुच्चय (एक डेटा संरचना या सरणी) को संदर्भित करता है, को संरेखित किया जाता है यदि (और केवल अगर) कुल में प्रत्येक आदिम डेटा को संरेखित किया जाता है।

ध्यान दें कि ऊपर दी गई परिभाषाएं मानती हैं कि प्रत्येक आदिम डेटा दो बाइट्स की शक्ति है। जब यह मामला नहीं होता है (जैसा कि x86 पर 80-बिट फ़्लोटिंग-पॉइंट के साथ होता है) संदर्भ उन स्थितियों को प्रभावित करता है जहां डेटाम को संरेखित माना जाता है या नहीं।

डेटा संरचनाओं को स्टैक पर मेमोरी में एक स्थिर आकार के साथ संग्रहीत किया जा सकता है जिसे बाउंडेड या हीप पर डायनेमिक आकार के साथ अनबाउंड के रूप में जाना जाता है।

समस्याएं

CPU एक समय में एक मेमोरी शब्द द्वारा मेमोरी को एक्सेस करता है। जब तक मेमोरी शब्द का आकार कंप्यूटर द्वारा समर्थित सबसे बड़े आदिम डेटा प्रकार के रूप में कम से कम बड़ा होता है, तब तक संरेखित एक्सेस हमेशा एक मेमोरी शब्द तक पहुंचेंगे। यह गलत डेटा एक्सेस के लिए सही नहीं हो सकता है।

यदि डेटाम में उच्चतम और निम्नतम बाइट्स एक ही मेमोरी शब्द के भीतर नहीं हैं, तो कंप्यूटर को डेटाम एक्सेस को कई मेमोरी एक्सेस में विभाजित करना होगा। मेमोरी एक्सेस उत्पन्न करने और उन्हें समन्वयित करने के लिए इसके लिए बहुत जटिल सर्किट्री की आवश्यकता होती है। उस मामले को संभालने के लिए जहां मेमोरी शब्द अलग-अलग मेमोरी पेजों में हैं, प्रोसेसर को या तो यह सत्यापित करना होगा कि निर्देश निष्पादित करने से पहले दोनों पेज मौजूद हैं या अनुवाद लुकसाइड बफर मिस या निर्देश निष्पादन के दौरान किसी भी मेमोरी एक्सेस पर पृष्ठ दोष को संभालने में सक्षम होना चाहिए।

कुछ प्रोसेसर डिज़ाइन जानबूझकर इस तरह की जटिलता को पेश करने से बचते हैं, और इसके बजाय एक गलत मेमोरी एक्सेस की स्थिति में वैकल्पिक व्यवहार उत्पन्न करते हैं। उदाहरण के लिए, ARMv6 ISA से पहले ARM आर्किटेक्चर के कार्यान्वयन के लिए सभी मल्टी-बाइट लोड और स्टोर निर्देशों के लिए अनिवार्य संरेखित मेमोरी एक्सेस की आवश्यकता होती है। किस विशिष्ट निर्देश को जारी किया गया था, इस पर निर्भर करते हुए, गलत तरीके से एक्सेस करने के प्रयास का परिणाम अपमानजनक पते के कम से कम महत्वपूर्ण बिट्स को एक संरेखित एक्सेस (कभी-कभी अतिरिक्त चेतावनियों के साथ) में बदलना या मेमोरी प्रबंधन इकाई अपवाद को फेंकना हो सकता है (यदि एमएमयू हार्डवेयर मौजूद है), या चुपचाप अन्य संभावित अप्रत्याशित परिणाम प्राप्त करने के लिए। ARMv6 और बाद के आर्किटेक्चर कई परिस्थितियों में असंरेखित पहुंच का समर्थन करते हैं, लेकिन जरूरी नहीं कि सभी।

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

डेटा संरचना पैडिंग

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

पैडिंग केवल तभी सम्मिलित की जाती है जब एक रिकॉर्ड (कंप्यूटर विज्ञान) सदस्य के बाद एक बड़ा संरेखण आवश्यकता वाला सदस्य या संरचना के अंत में होता है। संरचना में सदस्यों के क्रम को बदलकर, संरेखण बनाए रखने के लिए आवश्यक पैडिंग की मात्रा को बदलना संभव है। उदाहरण के लिए, यदि सदस्यों को अवरोही संरेखण आवश्यकताओं द्वारा क्रमबद्ध किया जाता है तो न्यूनतम पैडिंग की आवश्यकता होती है। आवश्यक पैडिंग की न्यूनतम मात्रा हमेशा संरचना में सबसे बड़े संरेखण से कम होती है। आवश्यक पैडिंग की अधिकतम मात्रा की गणना करना अधिक जटिल है, लेकिन हमेशा सभी सदस्यों के लिए संरेखण आवश्यकताओं के योग से कम होता है, जो संरचना सदस्यों के कम से कम संरेखित आधे के लिए संरेखण आवश्यकताओं के योग से दोगुना होता है।

हालांकि सी और सी ++ कंपाइलर को स्थान बचाने के लिए संरचना सदस्यों को पुन: व्यवस्थित करने की अनुमति नहीं देते हैं, अन्य भाषाएं हो सकती हैं। संरचना के सदस्यों को एक निश्चित स्तर के संरेखण में पैक करने के लिए अधिकांश सी और सी ++ कंपाइलर्स को बताना भी संभव है, उदा। पैक (2) का अर्थ है एक बाइट से बड़े डेटा सदस्यों को दो-बाइट सीमा तक संरेखित करना ताकि कोई भी पैडिंग सदस्य अधिकतम एक बाइट लंबा हो। इसी तरह, पीएल/आई में एक संरचना घोषित की जा सकती है UNALIGNED बिट स्ट्रिंग्स को छोड़कर सभी पैडिंग को खत्म करने के लिए।

ऐसी पैक्ड संरचनाओं का एक उपयोग स्मृति को संरक्षित करना है। उदाहरण के लिए, एक एकल बाइट (जैसे कि एक चार) और एक चार-बाइट पूर्णांक (जैसे कि uint32_t) वाली संरचना में पैडिंग के तीन अतिरिक्त बाइट की आवश्यकता होगी। ऐसी संरचनाओं की एक बड़ी सरणी 37.5% कम मेमोरी का उपयोग करती है यदि वे पैक की जाती हैं, हालांकि प्रत्येक संरचना तक पहुंचने में अधिक समय लग सकता है। इस समझौते को स्पेस-टाइम ट्रेडऑफ़ का एक रूप माना जा सकता है।

हालांकि पैक्ड संरचनाओं का उपयोग स्मृति स्थान (कम्प्यूटेशनल संसाधन) को संरक्षित करने के लिए सबसे अधिक बार किया जाता है, इसका उपयोग मानक प्रोटोकॉल का उपयोग करके ट्रांसमिशन के लिए डेटा संरचना को प्रारूपित करने के लिए भी किया जा सकता है। हालाँकि, इस उपयोग में, यह सुनिश्चित करने के लिए भी ध्यान रखा जाना चाहिए कि संरचना सदस्यों के मूल्यों को प्रोटोकॉल (अक्सर नेटवर्क बाइट क्रम ) द्वारा आवश्यक endianness के साथ संग्रहीत किया जाता है, जो मेजबान मशीन द्वारा मूल रूप से उपयोग किए जाने वाले एंडियननेस से भिन्न हो सकता है।

कंप्यूटिंग पैडिंग

निम्नलिखित सूत्र डेटा संरचना की शुरुआत को संरेखित करने के लिए आवश्यक पैडिंग बाइट्स की संख्या प्रदान करते हैं (जहाँ मॉड मोडुलो ऑपरेशन ऑपरेटर है):

पैडिंग = (संरेखित करें - (ऑफ़सेट मॉड संरेखित करें)) मॉड संरेखित करें
संरेखित = ऑफ़सेट + पैडिंग
        = ऑफ़सेट + ((संरेखित करें - (ऑफ़सेट मॉड संरेखित करें)) मॉड संरेखित करें)

उदाहरण के लिए, 4-बाइट संरेखित संरचना के लिए ऑफ़सेट 0x59d में जोड़ने के लिए पैडिंग 3 है। संरचना तब 0x5a0 पर शुरू होगी, जो कि 4 का गुणक है। हालाँकि, जब ऑफ़सेट का संरेखण पहले से ही संरेखित के बराबर है, दूसरा मोडुलो इन (संरेखित - (ऑफ़सेट मोड संरेखित)) मॉड संरेखण शून्य लौटाएगा, इसलिए मूल मान अपरिवर्तित छोड़ दिया गया है।

चूंकि संरेखण #परिभाषाओं द्वारा दो की शक्ति है, मोडुलो ऑपरेशन को बिटवाइज़ बूलियन और ऑपरेशन में कम किया जा सकता है।

निम्नलिखित सूत्र सही मान उत्पन्न करते हैं (जहाँ & एक बिटवाइज़ है AND और ~ बिटवाइज़ नहीं है) -- ऑफ़सेट प्रदान करना अहस्ताक्षरित है या सिस्टम दो पूरक अंकगणित का उपयोग करता है:

पैडिंग = (संरेखित करें - (ऑफ़सेट और (संरेखित करें - 1))) और (संरेखित करें - 1)
        = - ऑफसेट और (संरेखित - 1)
संरेखित = (ऑफ़सेट + (संरेखित - 1)) और ~ (संरेखित - 1)
        = (ऑफ़सेट + (संरेखित - 1)) और -संरेखित करें

== x86 == पर सी स्ट्रक्चर्स का विशिष्ट संरेखण

डेटा संरचना सदस्यों को मेमोरी में क्रमिक रूप से संग्रहीत किया जाता है ताकि नीचे की संरचना में, सदस्य डेटा1 हमेशा डेटा2 से पहले होगा; और Data2 हमेशा Data3 से पहले होगा:

struct MyData
{
    short Data1;
    short Data2;
    short Data3;
};

यदि टाइप शॉर्ट मेमोरी के दो बाइट में संग्रहीत है तो ऊपर दर्शाए गए डेटा संरचना का प्रत्येक सदस्य 2-बाइट संरेखित होगा। डेटा1 ऑफ़सेट 0 पर होगा, डेटा2 ऑफ़सेट 2 पर होगा, और डेटा3 ऑफ़सेट 4 पर होगा। इस संरचना का आकार 6 बाइट होगा।

संरचना के प्रत्येक सदस्य के प्रकार में आमतौर पर एक डिफ़ॉल्ट संरेखण होता है, जिसका अर्थ है कि यह, जब तक कि प्रोग्रामर द्वारा अन्यथा अनुरोध नहीं किया जाता है, पूर्व-निर्धारित सीमा पर संरेखित किया जाएगा। 32-बिट x86 के लिए संकलन करते समय निम्नलिखित विशिष्ट संरेखण माइक्रोसॉफ्ट (विजुअल सी ++), बोरलैंड /कोडगियर (सी ++ बिल्डर), डिजिटल मंगल (डीएमसी), और जीएनयू (जीएनयू कंपाइलर संग्रह) से कंपाइलर्स के लिए मान्य हैं:

• एक चार (एक बाइट) 1-बाइट संरेखित होगा।
• एक छोटा (दो बाइट) 2-बाइट संरेखित होगा।
• एक इंट (चार बाइट्स) 4-बाइट संरेखित होगा।
• एक लंबा (चार बाइट्स) 4-बाइट संरेखित होगा।
• एक फ्लोट (चार बाइट्स) 4-बाइट संरेखित होगा।
• एक डबल (आठ बाइट्स) विंडोज पर 8-बाइट संरेखित होगा और लिनक्स पर 4-बाइट संरेखित होगा (8-बाइट -मैलिग्न-डबल संकलन समय विकल्प के साथ)।
• एक लंबा लंबा (आठ बाइट) विंडोज पर 8-बाइट संरेखित होगा और लिनक्स पर 4-बाइट गठबंधन होगा (8-बाइट -मैलिग्न-डबल संकलन समय विकल्प के साथ)।
• एक लंबा डबल (सी++बिल्डर और डीएमसी के साथ दस बाइट, विज़ुअल सी++ के साथ आठ बाइट, जीसीसी के साथ बारह बाइट) सी++बिल्डर के साथ 8-बाइट संरेखित होगा, 2-बाइट डीएमसी के साथ संरेखित होगा, 8-बाइट संरेखित होगा दृश्य C++, और 4-बाइट GCC के साथ संरेखित।
• कोई सूचक (चार बाइट) 4-बाइट गठबंधन होगा। (उदाहरण: चार*, इंट*)

32-बिट सिस्टम की तुलना में LP64 64-बिट सिस्टम के संरेखण में केवल उल्लेखनीय अंतर हैं:

• एक लंबा (आठ बाइट) 8-बाइट संरेखित होगा।
• एक डबल (आठ बाइट) 8-बाइट संरेखित होगा।
• एक लंबा लंबा (आठ बाइट) 8-बाइट संरेखित होगा।
• एक लंबा डबल (विजुअल सी++ के साथ आठ बाइट, जीसीसी के साथ सोलह बाइट) विजुअल सी++ के साथ 8-बाइट एलाइन और जीसीसी के साथ 16-बाइट एलाइन होगा।
• कोई भी सूचक (आठ बाइट) 8-बाइट संरेखित होगा।

कुछ डेटा प्रकार कार्यान्वयन पर निर्भर हैं।

यहाँ विभिन्न प्रकार के सदस्यों के साथ एक संरचना है, संकलन से पहले कुल 8 बाइट्स:

struct MixedData
{
    char Data1;
    short Data2;
    int Data3;
    char Data4;
};

संकलन के बाद डेटा संरचना को इसके प्रत्येक सदस्य के लिए उचित संरेखण सुनिश्चित करने के लिए पैडिंग बाइट्स के साथ पूरक किया जाएगा:

struct MixedData  /* After compilation in 32-bit x86 machine */
{
    char Data1; /* 1 byte */
    char Padding1[1]; /* 1 byte for the following 'short' to be aligned on a 2 byte boundary
assuming that the address where structure begins is an even number */
    short Data2; /* 2 bytes */
    int Data3;  /* 4 bytes - largest structure member */
    char Data4; /* 1 byte */
    char Padding2[3]; /* 3 bytes to make total size of the structure 12 bytes */
};

संरचना का संकलित आकार अब 12 बाइट है। यह ध्यान रखना महत्वपूर्ण है कि अंतिम सदस्य आवश्यक बाइट्स की संख्या के साथ गद्देदार है ताकि संरचना का कुल आकार इस मामले में किसी भी संरचना सदस्य (संरेखण (int) के सबसे बड़े संरेखण का गुणक होना चाहिए, जो = 4 पर linux-32bit/gcc).

इस मामले में संरचना को 12 बाइट्स (संरेखण (इंट) × 3) के आकार में पैड करने के लिए अंतिम सदस्य में 3 बाइट्स जोड़े जाते हैं।

struct FinalPad {
  float x;
  char n[1];
};

इस उदाहरण में संरचना का कुल आकार sizeof(FinalPad) == 8, 5 नहीं (ताकि आकार 4 का गुणक हो (फ्लोट का संरेखण))।

struct FinalPadShort {
  short s;
  char n[3];
};

इस उदाहरण में संरचना का कुल आकार sizeof(FinalPadShort) == 6, 5 नहीं (8 भी नहीं) (ताकि आकार 2 का गुणक हो (संरेखण (छोटा) = 2 linux-32bit/gcc पर)।

संरचना के सदस्यों को पुनर्क्रमित करके या संरचना के सदस्यों के संकलक के संरेखण (या "पैकिंग") को बदलकर उनके लिए आवश्यक स्मृति (या मौजूदा प्रारूप के अनुरूप) को कम करने के लिए संरचनाओं के संरेखण को बदलना संभव है।

struct MixedData  /* after reordering */
{
    char Data1;
    char Data4;   /* reordered */
    short Data2;
    int Data3;
};

संरचना का संकलित आकार अब 8 बाइट्स के पूर्व-संकलित आकार से मेल खाता है। ध्यान दें कि Padding1[1] द्वारा प्रतिस्थापित किया गया है (और इस प्रकार हटा दिया गया है)। Data4 और Padding2[3] अब आवश्यक नहीं है क्योंकि संरचना पहले से ही एक लंबे शब्द के आकार के अनुरूप है।

लागू करने का वैकल्पिक तरीका MixedData संरचना को एक बाइट सीमा से संरेखित करने से प्री-प्रोसेसर को संरचना सदस्यों के पूर्व-निर्धारित संरेखण को त्यागने का कारण होगा और इस प्रकार कोई पैडिंग बाइट नहीं डाला जाएगा।

जबकि संरचना सदस्यों के संरेखण को परिभाषित करने का कोई मानक तरीका नहीं है, कुछ कंपाइलर उपयोग करते हैं #pragma स्रोत फ़ाइलों के अंदर पैकिंग निर्दिष्ट करने के निर्देश। यहाँ एक उदाहरण है:

#pragma pack(push)  /* push current alignment to stack */
#pragma pack(1)     /* set alignment to 1 byte boundary */

struct MyPackedData
{
    char Data1;
    long Data2;
    char Data3;
};

#pragma pack(pop)   /* restore original alignment from stack */

इस संरचना का 32-बिट सिस्टम पर 6 बाइट्स का संकलित आकार होगा। उपरोक्त निर्देश Microsoft के कंपाइलर्स में उपलब्ध हैं, बोरलैंड, जीएनयू, गंभीर प्रयास।

एक और उदाहरण:

struct MyPackedData
{
    char Data1;
    long Data2;
    char Data3;
} __attribute__((packed));

डिफ़ॉल्ट पैकिंग और #pragma pack

कुछ Microsoft कंपाइलर्स पर, विशेष रूप से RISC प्रोसेसर के लिए, प्रोजेक्ट डिफॉल्ट पैकिंग (/Zp निर्देश) और के बीच एक अप्रत्याशित संबंध है #pragma pack निर्देश। वह #pragma pack निर्देश का उपयोग केवल प्रोजेक्ट डिफ़ॉल्ट पैकिंग से संरचना के पैकिंग आकार को कम करने के लिए किया जा सकता है। इससे लाइब्रेरी हेडर के साथ इंटरऑपरेबिलिटी समस्याएं होती हैं जो उदाहरण के लिए उपयोग करती हैं, #pragma pack(8), यदि प्रोजेक्ट पैकिंग इससे छोटी है। इस कारण से, प्रोजेक्ट पैकिंग को 8 बाइट्स के डिफ़ॉल्ट के अलावा किसी अन्य मान पर सेट करने से यह टूट जाएगा #pragma pack लाइब्रेरी हेडर में उपयोग किए गए निर्देश और परिणामस्वरूप संरचनाओं के बीच बाइनरी असंगतताएं होती हैं। x86 के लिए संकलन करते समय यह सीमा मौजूद नहीं है।

कैश लाइनों से जुड़ी मेमोरी आवंटित करना

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

#include <stdlib.h>
double *foo(void) {
   double *var;//create array of size 10
   int     ok;

   ok = posix_memalign((void**)&var, 64, 10*sizeof(double));

   if (ok != 0)
     return NULL;

   return var;
}

संरेखण आवश्यकताओं का हार्डवेयर महत्व

संरेखण चिंताएं सी संरचना की तुलना में बहुत बड़े क्षेत्रों को प्रभावित कर सकती हैं जब उद्देश्य हार्डवेयर सीपीयू कैश # एड्रेस ट्रांसलेशन मैकेनिज्म (पीसीआई रीमैपिंग, मेमोरी मैनेजमेंट यूनिट का संचालन) के माध्यम से उस क्षेत्र की कुशल मैपिंग है।

उदाहरण के लिए, एक 32-बिट ऑपरेटिंग सिस्टम पर, एक 4 kibibit (4096 बाइट) पृष्ठ केवल एक मनमाना 4 कीबी डेटा का हिस्सा नहीं है। इसके बजाय, यह आमतौर पर स्मृति का एक क्षेत्र होता है जो 4 KiB सीमा पर संरेखित होता है। ऐसा इसलिए है क्योंकि पृष्ठ-आकार की सीमा पर एक पृष्ठ को संरेखित करने से हार्डवेयर को जटिल अंकगणित करने के बजाय पते में उच्च बिट्स को प्रतिस्थापित करके एक भौतिक पते पर एक आभासी पता मिलता है।

उदाहरण: मान लें कि हमारे पास भौतिक पते 0x12345000 पर आभासी पते 0x2CFC7000 की TLB मैपिंग है। (ध्यान दें कि ये दोनों पते 4 KiB सीमाओं पर संरेखित हैं।) आभासी पते va=0x2CFC7ABC पर स्थित डेटा तक पहुँचने के लिए 0x2CFC7 से 0x12345 के TLB रिज़ॉल्यूशन को pa=0x12345ABC तक भौतिक पहुँच जारी करने का कारण बनता है। यहाँ, 20/12-बिट विभाजन सौभाग्य से 5/3 अंकों पर हेक्साडेसिमल प्रतिनिधित्व विभाजन से मेल खाता है। हार्डवेयर भौतिक पते के पहले 20 बिट्स (0x12345) और वर्चुअल एड्रेस (0xABC) के अंतिम 12 बिट्स को जोड़कर इस अनुवाद को कार्यान्वित कर सकता है। इसे वस्तुतः अनुक्रमित (एबीसी) भौतिक रूप से टैग (12345) के रूप में भी जाना जाता है।

आकार 2 के डेटा का एक ब्लॉक⁽ⁿ⁺¹⁾ - 1 में हमेशा आकार 2 का एक सब-ब्लॉक होता हैⁿ 2 पर संरेखितⁿ बाइट्स।

यह कैसे एक गतिशील आवंटक है जिसे संरेखण का कोई ज्ञान नहीं है, इसका उपयोग अंतरिक्ष हानि में कारक दो की कीमत पर संरेखित बफ़र्स प्रदान करने के लिए किया जा सकता है।

// Example: get 4096 bytes aligned on a 4096 byte buffer with malloc()

// unaligned pointer to large area
void *up = malloc((1 << 13) - 1);
// well-aligned pointer to 4 KiB
void *ap = aligntonext(up, 12);

जहाँ aligntonext(p, r) एक संरेखित वेतन वृद्धि जोड़कर काम करता है, फिर p के कम से कम महत्वपूर्ण बिट्स को साफ़ करता है। एक संभावित कार्यान्वयन है

// Assume `uint32_t p, bits;` for readability
#define alignto(p, bits)      (((p) >> bits) << bits)
#define aligntonext(p, bits)  alignto(((p) + (1 << bits) - 1), bits)

अग्रिम पठन

• Bryant, Randal E.; David, O'Hallaron (2003). Computer Systems: A Programmer's Perspective (2003 ed.). Upper Saddle River, New Jersey, USA: Pearson Education. ISBN 0-13-034074-X.
• "1. Introduction: Segment Alignment". 8086 Family Utilities - User's Guide for 8080/8085-Based Development Systems (PDF). Revision E (A620/5821 6K DD ed.). Santa Clara, California, USA: Intel Corporation. May 1982 [1980, 1978]. pp. 1-6, 3-5. Order Number: 9800639-04. Archived (PDF) from the original on 2020-02-29. Retrieved 2020-02-29. […] A segment can have one (and in the case of the inpage attribute, two) of five alignment attributes: […] Byte, which means a segment can be located at any address. […] Word, which means a segment can only be located at an address that is a multiple of two, starting from address 0H. […] Paragraph, which means a segment can only be located at an address that is a multiple of 16, starting from address 0. […] Page, which means a segment can only be located at an address that is a multiple of 256, starting from address 0. […] Inpage, which means a segment can be located at whichever of the preceding attributes apply plus must be located so that it does not cross a page boundary […] The alignment codes are: […] B - byte […] W - word […] G - paragraph […] xR - inpage […] P - page […] A - absolute […] the x in the inpage alignment code can be any other alignment code. […] a segment can have the inpage attribute, meaning it must reside within a 256 byte page and can have the word attribute, meaning it must reside on an even numbered byte. […]

बाहरी संबंध

• IBM developerWorks article on data alignment
• Article on data alignment and performance
• MSDN article on data alignment
• Article on data alignment and data portability
• Byte Alignment and Ordering
• Stack Alignment in 64-bit Calling Conventions - discusses stack alignment for x86-64 calling conventions
• The Lost Art of Structure Packing by Eric S. Raymond