शब्द सम्बोधन (वर्ड एड्रेसिंग)

कंप्यूटर आर्किटेक्चर में, वर्ड एड्रेसिंग का मतलब है कि कंप्यूटर पर मेमोरी के एड्रेस विशिष्ट रूप से मेमोरी के वर्ड (कंप्यूटर आर्किटेक्चर) की पहचान करते हैं। यह आमतौर पर [[बाइट एड्रेसिंग]] के विपरीत प्रयोग किया जाता है, जहां पते विशिष्ट रूप से बाइट की पहचान करते हैंs. Almost all modern computer architectures use byte addressing, and word addressing is largely only of historical interest. A computer that uses word addressing is sometimes called a word machine.

मूल बातें
एक कंप्यूटर पर विचार करें जो 524,288 (219) मेमोरी के बिट। यदि उस मेमोरी को बाइट-एड्रेसेबल फ्लैट एड्रेस स्पेस में 8-बिट बाइट्स का उपयोग करके व्यवस्थित किया जाता है, तो 65,536 (216) मान्य पते, 0 से 65,535 तक, प्रत्येक एक स्वतंत्र 8 बिट्स मेमोरी को दर्शाता है। यदि इसके बजाय इसे 32-बिट शब्दों का उपयोग करके एक शब्द-पता योग्य फ्लैट पता स्थान में व्यवस्थित किया जाता है, तो 16,384 (214) वैध पते, 0 से 16,383 तक, प्रत्येक एक स्वतंत्र 32 बिट्स को दर्शाता है।

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

आभासी मेमोरी द्वारा किया गया एड्रेस ट्रांसलेशन अक्सर एड्रेस स्पेस की संरचना और चौड़ाई को प्रभावित करता है, लेकिन यह एमएयू को नहीं बदलता है।

विभिन्न न्यूनतम पता योग्य इकाइयों का व्यापार-नापसंद
मेमोरी की न्यूनतम एड्रेसेबल यूनिट के आकार में जटिल ट्रेड-ऑफ हो सकते हैं। एक बड़े एमएयू का उपयोग करने से समान मात्रा में स्मृति को एक छोटे पते से कवर किया जा सकता है, जो किसी प्रोग्राम की स्मृति आवश्यकताओं को काफी हद तक कम कर सकता है। हालाँकि, एक छोटे MAU का उपयोग करने से डेटा के छोटे आइटम के साथ कुशलता से काम करना आसान हो जाता है।

मान लीजिए कि कोई प्रोग्राम ज्योतिषीय चिह्नों में से किसी एक को संग्रहित करना चाहता है। एक सिंगल साइन को 4 बिट में स्टोर किया जा सकता है। यदि कोई साइन अपने स्वयं के एमएयू में संग्रहीत है, तो बाइट एड्रेसिंग (50% दक्षता) के साथ 4 बिट्स बर्बाद हो जाएंगे, जबकि 28 बिट्स 32-बिट वर्ड एड्रेसिंग (12.5% ​​दक्षता) के साथ बर्बाद हो जाएंगे। यदि किसी चिह्न को अन्य डेटा के साथ MAU में पैक किया जाता है, तो इसे पढ़ना और लिखना अपेक्षाकृत अधिक महंगा हो सकता है। उदाहरण के लिए, एक एमएयू में एक नया संकेत लिखने के लिए जिसमें अन्य डेटा पैक किया गया है, कंप्यूटर को एमएयू के वर्तमान मूल्य को पढ़ना चाहिए, केवल उचित बिट्स को ओवरराइट करना चाहिए और फिर नए मूल्य को वापस स्टोर करना चाहिए। यह विशेष रूप से महंगा होगा यदि कार्यक्रम के लिए अन्य थ्रेड्स को एमएयू में अन्य डेटा को समवर्ती रूप से संशोधित करने की अनुमति देना आवश्यक है।

एक अधिक सामान्य उदाहरण एक स्ट्रिंग (कंप्यूटर विज्ञान) है। UTF-8 और ASCII स्टोर स्ट्रिंग्स जैसे सामान्य स्ट्रिंग प्रारूप 8-बिट कोड बिंदुओं के अनुक्रम के रूप में। बाइट एड्रेसिंग के साथ, प्रत्येक कोड बिंदु को बिना किसी ओवरहेड के स्वतंत्र रूप से पता योग्य एमएयू में रखा जा सकता है। 32-बिट वर्ड एड्रेसिंग के साथ, प्रत्येक कोड बिंदु को एक अलग MAU में रखने से मेमोरी का उपयोग 300% बढ़ जाएगा, जो उन प्रोग्रामों के लिए व्यवहार्य नहीं है जो बड़ी मात्रा में टेक्स्ट के साथ काम करते हैं। आसन्न कोड बिंदुओं को एक शब्द में पैक करने से इस लागत से बचा जाता है। हालांकि, पाठ के साथ काम करने के लिए कई एल्गोरिदम स्वतंत्र रूप से कोड बिंदुओं को संबोधित करने में सक्षम होना पसंद करते हैं; पैक्ड कोड बिंदुओं के साथ ऐसा करने के लिए, एल्गोरिथम को एक विस्तृत पते का उपयोग करना चाहिए जो शब्द के भीतर वर्ण के ऑफ़सेट को भी संग्रहीत करता है। यदि इस विस्तृत पते को प्रोग्राम की मेमोरी में कहीं और संग्रहीत करने की आवश्यकता है, तो इसके लिए सामान्य पते की तुलना में अधिक मेमोरी की आवश्यकता हो सकती है।

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

मान लीजिए कि, यदि प्रोग्राम में सभी पते 32-बिट हैं, तो यह वेब पेज लगभग 10 गीगाबाइट मेमोरी घेरता है।


 * यदि वेब ब्राउज़र 32-बिट पतों और बाइट-एड्रेसेबल मेमोरी वाले कंप्यूटर पर चल रहा है, तो पता स्थान 4 गीगाबाइट मेमोरी को कवर करेगा, जो कि अपर्याप्त है। ब्राउज़र या तो इस पृष्ठ को प्रदर्शित करने में असमर्थ होगा, या उसे अवसरवादी रूप से कुछ डेटा को धीमे भंडारण में स्थानांतरित करने में सक्षम होने की आवश्यकता होगी, जो इसके प्रदर्शन को काफी हद तक प्रभावित करेगा।
 * यदि वेब ब्राउज़र 64-बिट पतों और बाइट-एड्रेसेबल मेमोरी वाले कंप्यूटर पर चल रहा है, तो बड़े पतों को स्टोर करने के लिए इसे काफी अधिक मेमोरी की आवश्यकता होगी। सटीक ओवरहेड इस बात पर निर्भर करेगा कि 10 गीगाबाइट्स में से कितना सरल डेटा है और कितना ऑब्जेक्ट-जैसा और संदर्भों के साथ घना है, लेकिन कुल 14 गीगाबाइट्स के लिए 40% का आंकड़ा असंभव नहीं है। बेशक, यह 64-बिट एड्रेस स्पेस की क्षमताओं के भीतर है। हालांकि, ब्राउज़र आम तौर पर खराब स्थानीयता प्रदर्शित करेगा और कंप्यूटर के भीतर कंप्यूटर की मेमोरी कैश का खराब उपयोग करेगा, विकल्पों के साथ समान संसाधनों को मानते हुए।
 * यदि वेब ब्राउज़र 32-बिट पतों और 32-बिट-वर्ड वाले कंप्यूटर पर चल रहा है-एड्रेसेबल मेमोरी, इसमें उप-इष्टतम पैकिंग और कुछ विस्तृत पतों की आवश्यकता के कारण अतिरिक्त मेमोरी की आवश्यकता होगी। यह प्रभाव अपेक्षाकृत कम होने की संभावना है, क्योंकि ब्राउज़र सबसे महत्वपूर्ण उद्देश्यों के लिए पैकिंग और गैर-विस्तृत पतों का उपयोग करेगा, और ब्राउज़र 16 गीगाबाइट की अधिकतम पता योग्य सीमा के भीतर आराम से फिट होगा। हालांकि, छवियों और पाठ के लिए पैक्ड डेटा के व्यापक उपयोग के कारण एक महत्वपूर्ण रनटाइम ओवरहेड हो सकता है। इससे भी महत्वपूर्ण बात यह है कि 16 गीगाबाइट एक अपेक्षाकृत कम सीमा है, और यदि वेब पेज महत्वपूर्ण रूप से बढ़ता है, तो यह कंप्यूटर अपने पता स्थान को समाप्त कर देगा और बाइट-एड्रेस कंप्यूटर के समान कुछ कठिनाइयों का सामना करना शुरू कर देगा।
 * यदि वेब ब्राउज़र 64-बिट पतों और 32-बिट-वर्ड-एड्रेसेबल मेमोरी वाले कंप्यूटर पर चल रहा है, तो यह उपरोक्त दोनों रनटाइम ओवरहेड्स से पीड़ित होगा: बड़े 64-बिट पतों को समायोजित करने के लिए इसे काफी अधिक मेमोरी की आवश्यकता होती है, पाठ और छवि डेटा के व्यापक पैकिंग के साथ काम करने के रनटाइम ओवरहेड को भी नुकसान पहुंचाते हुए स्थानीयता को नुकसान पहुंचाते हैं। वर्ड एड्रेसिंग का अर्थ है कि प्रोग्राम सैद्धांतिक रूप से केवल 16 एक्साबाइट्स के बजाय 64 एक्साबाइट्स मेमोरी को संबोधित कर सकता है, लेकिन चूंकि प्रोग्राम को इतनी मेमोरी की आवश्यकता नहीं है (और व्यवहार में कोई वास्तविक कंप्यूटर इसे प्रदान करने में सक्षम नहीं है), इससे कोई लाभ नहीं होता है.

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

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

मान लीजिए कि UTF-8 स्ट्रिंग से लगातार चार कोड बिंदुओं को 32-बिट शब्द में पैक करने की आवश्यकता है। पहला कोड पॉइंट 0–7, दूसरा 8-15, तीसरा 16–23 और चौथा 24–31 बिट्स पर कब्जा कर सकता है। (यदि मेमोरी बाइट-एड्रेसेबल थी, तो यह थोड़ा एंडियन बाइट ऑर्डर होगा।)

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

मान लीजिए कि कोई प्रोग्राम तीसरे कोड बिंदु को रजिस्टर में पढ़ना चाहता है  रजिस्टर में एक पते पर शब्द से. निर्देश सेट से किसी अन्य समर्थन की अनुपस्थिति में, प्रोग्राम को पहले दो कोड बिंदुओं को छोड़ने के लिए पूर्ण शब्द, राइट-शिफ्ट को 16 से लोड करना होगा, और फिर चौथे कोड बिंदु को बंद करना होगा:

ldw $r1, 0($r2) # पूरा शब्द लोड करें srl $r1, $r1, 16 # 16 से दाएं शिफ्ट करें andi $r1, $r1, 0xFF # अन्य कोड बिंदुओं को छुपाएं

यदि ऑफ़सेट स्थिर रूप से ज्ञात नहीं है, लेकिन इसके बजाय रजिस्टर में एक बिट ऑफ़सेट संग्रहीत किया जाता है, थोड़ा और जटिल दृष्टिकोण आवश्यक है:

ldw $r1, 0($r2) # पूरा शब्द लोड करें srlv $r1, $r1, $r3 # बिट ऑफ़सेट द्वारा दाईं ओर शिफ्ट करें andi $r1, $r1, 0xFF # अन्य कोड बिंदुओं को छुपाएं

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

<पूर्व> sll $r1, $r1, 16 # 16 से छोड़े गए नए मान को शिफ्ट करें lhi $r5, 0x00FF # तीसरे बाइट का चयन करने के लिए एक स्थिर मास्क का निर्माण करें न ही $r5, $r5, $zero # मास्क को पलटें ताकि यह तीसरा बाइट साफ कर दे ldw $r4, 0($r2) # पूरा शब्द लोड करें तथा $r4, $r5, $r4 # शब्द से तीसरा बाइट साफ़ करें या $r4, $r4, $r1 # नए मान को शब्द में मर्ज करें stw $r4, 0($r2) # परिणाम को पूरे शब्द के रूप में संग्रहित करें

दोबारा, अगर ऑफ़सेट को इसके बजाय संग्रहीत किया जाता है, एक अधिक जटिल दृष्टिकोण की आवश्यकता है:

<पूर्व> sllv $r1, $r1, $r3 # बिट ऑफ़सेट द्वारा छोड़े गए नए मान को स्थानांतरित करें llo $r5, 0x00FF # एक बाइट का चयन करने के लिए एक स्थिर मास्क का निर्माण करें sllv $r5, $r5, $r3 # बिट ऑफसेट द्वारा छोड़े गए मास्क को शिफ्ट करें न ही $r5, $r5, $zero # मास्क को पलटें ताकि यह चयनित बाइट को साफ कर सके ldw $r4, 0($r2) # पूरा शब्द लोड करें तथा $r4, $r5, $r4 # शब्द से चयनित बाइट साफ़ करें या $r4, $r4, $r1 # नए मान को शब्द में मर्ज करें stw $r4, 0($r2) # परिणाम को पूरे शब्द के रूप में संग्रहित करें

यह कोड अनुक्रम मानता है कि एक अन्य थ्रेड शब्द में समवर्ती रूप से अन्य बाइट्स को संशोधित नहीं कर सकता है। यदि समवर्ती संशोधन संभव है, तो संशोधनों में से एक खो सकता है। इस समस्या को हल करने के लिए, पिछले कुछ निर्देशों को एक परमाणु तुलना-विनिमय लूप में बदलना चाहिए ताकि एक समवर्ती संशोधन के कारण यह नए मूल्य के साथ ऑपरेशन को दोहरा सके। इस मामले में कोई स्मृति बाधा आवश्यक नहीं है।

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

इन कोड अनुक्रमों में, अतिरिक्त ऑफ़सेट को आधार पते के साथ संग्रहीत करना होगा, प्रभावी रूप से किसी पते की समग्र संग्रहण आवश्यकताओं को दोगुना करना होगा। यह शब्द मशीनों पर हमेशा सच नहीं होता है, मुख्यतः क्योंकि पतों को अक्सर एक्सेस को अधिक कुशल बनाने के लिए अन्य डेटा के साथ पैक नहीं किया जाता है। उदाहरण के लिए, क्रे X1 64-बिट शब्दों का उपयोग करता है, लेकिन पते केवल 32 बिट्स हैं; जब कोई पता स्मृति में संग्रहीत होता है, तो यह अपने स्वयं के शब्द में संग्रहीत होता है, और इसलिए बाइट ऑफ़सेट शब्द के ऊपरी 32 बिट्स में रखा जा सकता है। उस प्रणाली पर विस्तृत पतों का उपयोग करने की अक्षमता इस ऑफसेट में हेरफेर करने और शब्दों के भीतर बाइट्स निकालने और सम्मिलित करने के लिए सभी अतिरिक्त तर्क हैं; इसका कोई स्मृति-उपयोग प्रभाव नहीं है।

संबंधित अवधारणाएं
कंप्यूटर की न्यूनतम पता योग्य इकाई आवश्यक रूप से कंप्यूटर के निर्देश सेट की न्यूनतम मेमोरी एक्सेस आकार के समान नहीं होती है। उदाहरण के लिए, एक कंप्यूटर एक बाइट को सीधे पढ़ने या लिखने के लिए कोई निर्देश दिए बिना बाइट एड्रेसिंग का उपयोग कर सकता है। प्रोग्रामों से बिट-मैनिपुलेशन वाले सॉफ़्टवेयर में उन परिचालनों का अनुकरण करने की अपेक्षा की जाएगी, ठीक ऊपर दिए गए उदाहरण कोड अनुक्रमों की तरह। यह 32-बिट सुपरकंप्यूटर या मिनीकंप्यूटर, जैसे डीईसी अल्फा और क्रे एक्स 1 के उत्तराधिकारी के रूप में डिजाइन किए गए 64-बिट कंप्यूटर आर्किटेक्चर में अपेक्षाकृत आम है।

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

क्योंकि सी का आकार  उस पर सूचक के प्रतिनिधित्व का निर्णय लेते समय हमेशा ज्ञात नहीं होता है , उपरोक्त नियम को विश्वसनीय रूप से लागू करना संभव नहीं है। कंपाइलर्स को a की शुरुआत को संरेखित करने की आवश्यकता हो सकती है   ताकि यह अधिक कुशल सूचक प्रतिनिधित्व का उपयोग कर सके।

उदाहरण

 * ईआरए 1103 36-बिट शब्दों के साथ शब्द को संबोधित करते हुए उपयोग करता है। केवल 0-1023 पते रैंडम-एक्सेस मेमोरी को संदर्भित करते हैं; अन्य या तो मैप नहीं किए गए हैं या ड्रम मेमोरी को संदर्भित करते हैं।
 * PDP-10 36-बिट शब्दों और 18-बिट पतों के साथ वर्ड एड्रेसिंग का उपयोग करता है।
 * 1980 और 1990 के दशक के अधिकांश क्रे सुपरकंप्यूटर 64-बिट शब्दों के साथ वर्ड एड्रेसिंग का उपयोग करते हैं। Cray-1 और Cray X-MP 24-बिट पतों का उपयोग करते हैं, जबकि अधिकांश अन्य 32-बिट पतों का उपयोग करते हैं।
 * क्रे X1 64-बिट पतों के साथ बाइट एड्रेसिंग का उपयोग करता है। यह सीधे तौर पर 64 बिट्स से छोटी मेमोरी एक्सेस का समर्थन नहीं करता है, और इस तरह के एक्सेस को सॉफ्टवेयर में अनुकरण किया जाना चाहिए। X1 के लिए C कंपाइलर 16-बिट एक्सेस का अनुकरण करने वाला पहला क्रे कंपाइलर था।
 * डीईसी अल्फा 64-बिट पतों के साथ बाइट एड्रेसिंग का उपयोग करता है। शुरुआती अल्फा प्रोसेसर 8-बिट और 16-बिट मेमोरी एक्सेस के लिए कोई सीधा समर्थन प्रदान नहीं करते हैं, और प्रोग्रामों को उदा। 64-बिट शब्द को लोड करके और फिर बाइट को अलग से निकालकर एक बाइट लोड करें। क्योंकि अल्फा बाइट एड्रेसिंग का उपयोग करता है, यह ऑफ़सेट अभी भी पते के कम से कम महत्वपूर्ण बिट्स (बजाय एक विस्तृत पते के रूप में) में दर्शाया गया है, और अल्फा आसानी से लोड और स्टोर असंरेखित निर्देश प्रदान करता है ( और  ) जो उन बिट्स को अनदेखा करते हैं और केवल संरेखित शब्द को लोड और स्टोर करते हैं। आर्किटेक्चर (बीडब्ल्यूएक्स) के बाद के बाइट-वर्ड एक्सटेंशन ने अल्फा 21164ए से शुरू होने वाले 8-बिट और 16-बिट लोड और स्टोर जोड़े। फिर से, यह विस्तार गंभीर सॉफ़्टवेयर असंगतियों के बिना संभव था क्योंकि अल्फा ने हमेशा बाइट एड्रेसिंग का उपयोग किया था।

यह भी देखें

 * बाइट एड्रेसिंग