🕸️ 🌏 🙅🏾 चढ़ाई एलब्रस - लड़ाई में टोही। तकनीकी भाग 1. रजिस्टर, ढेर और अन्य तकनीकी विवरण 🍢 🖐🏾 🎥

जैसा कि वादा किया गया था , हम एलब्रस प्रोसेसर के विकास के बारे में बात करना जारी रखते हैं। यह लेख तकनीकी है। लेख में दी गई जानकारी आधिकारिक दस्तावेज नहीं है, क्योंकि यह एलब्रस के अध्ययन के दौरान ब्लैक बॉक्स की तरह प्राप्त की गई थी। लेकिन एल्ब्रस वास्तुकला की बेहतर समझ के लिए यह निश्चित रूप से दिलचस्प होगा, क्योंकि हालांकि हमारे पास आधिकारिक दस्तावेज थे, कई विवरण लंबे प्रयोगों के बाद ही स्पष्ट हो गए, जब एमबॉक्स ने काम किया।

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

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

संक्षिप्त परिचय: ढेर

एल्ब्रस में तीन ढेर हैं:

प्रक्रिया स्टैक (PS)
प्रक्रिया श्रृंखला ढेर (पीसीएस)
उपयोगकर्ता स्टैक (यूएस)

आइए उनका अधिक विस्तार से विश्लेषण करें। आकृति में पते सशर्त हैं, दिखाते हैं कि किस दिशा में आंदोलनों का निर्देशन किया गया है - एक बड़े पते से एक छोटे से एक या इसके विपरीत।

प्रक्रिया स्टैक (PS) "परिचालन" रजिस्टरों के लिए आवंटित डेटा के लिए है।

उदाहरण के लिए, यह फ़ंक्शन तर्क हो सकता है, "साधारण" आर्किटेक्चर में, यह अवधारणा सामान्य प्रयोजन रजिस्टर के सबसे करीब है। E2K में "नियमित" प्रोसेसर आर्किटेक्चर के विपरीत, फ़ंक्शन में उपयोग किए जाने वाले रजिस्टरों को एक अलग स्टैक पर स्टैक किया जाता है।

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

ये दोनों स्टैक (PS और PCS) एक आधार पते, आकार और वर्तमान ऑफसेट द्वारा विशेषता हैं। ये पैरामीटर PSP और PCSP रजिस्टरों में सेट किए गए हैं, वे 128-बिट हैं और असेंबलर में आपको विशिष्ट क्षेत्रों (उदाहरण के लिए, उच्च या निम्न) को संदर्भित करने की आवश्यकता होती है। इसके अलावा, ढेर का कामकाज एक रजिस्टर फ़ाइल की अवधारणा से निकटता से संबंधित है, जो कि नीचे दिया गया है। फ़ाइल के साथ सहभागिता पंपिंग / स्वैपिंग रजिस्टरों के तंत्र के माध्यम से होती है। इस तंत्र में एक सक्रिय भूमिका क्रमशः प्रक्रियात्मक या बाध्यकारी जानकारी के ढेर के तथाकथित "हार्डवेयर पॉइंटर को स्टैक के शीर्ष पर" द्वारा खेली जाती है। इसके बारे में भी नीचे। यह महत्वपूर्ण है कि प्रत्येक बिंदु पर इन स्टैक्स का डेटा रैम में या रजिस्टर फ़ाइल में हो।

यह भी ध्यान देने योग्य है कि ये ढेर (प्रक्रियात्मक ढेर और बाध्यकारी जानकारी के ढेर) बड़े होते हैं । जब हमने Reference_switch लागू किया तो हम इस पर आ गए।

उपयोगकर्ता स्टैक को आधार पता और आकार भी दिया गया है। वर्तमान सूचक रजिस्टर में है USD.lo. इसके मूल में, यह एक क्लासिक स्टैक है जो नीचे बढ़ता है। केवल, "साधारण" आर्किटेक्चर के विपरीत, अन्य स्टैक (रजिस्टर और रिटर्न एड्रेस) की जानकारी वहां फिट नहीं होती है।

एक गैर-मानक, मेरी राय में, स्टैक की सीमाओं और आकार के लिए आवश्यकता 4Kb संरेखण है, और स्टैक के आधार पते और इसके आकार दोनों को 4Kb में संरेखित किया जाना चाहिए। अन्य आर्किटेक्चर में, मैं इस तरह के प्रतिबंध से नहीं मिला हूं। हम इस विस्तार में आए, फिर से, जब हमने Reference_switch लागू किया।

संक्षिप्त परिचय: रजिस्टर। फ़ाइलें पंजीकृत करें। विंडो रजिस्टर करें

अब जब हमने स्टैक्स को थोड़ा समझ लिया है, तो हमें यह समझने की आवश्यकता है कि उनमें कैसे जानकारी प्रस्तुत की गई है। ऐसा करने के लिए, हमें कुछ और अवधारणाओं को पेश करने की आवश्यकता है।

एक रजिस्टर फ़ाइल (आरएफ) सभी रजिस्टरों का एक सेट है। दो रजिस्टर फाइलें हैं जिनकी हमें आवश्यकता है: कनेक्ट करने वाली जानकारी की एक फाइल (चेन फाइल - सीएफ), दूसरे को रजिस्टर फाइल (आरएफ) कहा जाता है, यह "ऑपरेशनल" रजिस्टरों को संग्रहीत करता है, जो प्रक्रियात्मक स्टैक पर संग्रहीत होते हैं।

रजिस्टर विंडो रजिस्टर फ़ाइल का क्षेत्र (रजिस्टर का सेट) है जो वर्तमान में उपलब्ध है।

मैं और अधिक विस्तार से बताऊंगा। रजिस्टर का एक सेट क्या है, मुझे लगता है, किसी को समझाने की जरूरत नहीं है।

यह सर्वविदित है कि x86 वास्तुकला में अड़चनों में से एक ठीक रजिस्टर की एक छोटी संख्या है। रजिस्टरों के साथ RISC आर्किटेक्चर में यह सरल है, आमतौर पर लगभग 16 रजिस्टरों में से, जिनमें से कई (2-3) आधिकारिक जरूरतों के लिए कब्जा कर लिए जाते हैं। सिर्फ 128 रजिस्टर क्यों नहीं बनाते, क्योंकि ऐसा लगता है कि इससे सिस्टम का प्रदर्शन बढ़ जाएगा? उत्तर काफी सरल है: एक प्रोसेसर निर्देश को रजिस्टर पते को संग्रहीत करने के लिए जगह की आवश्यकता होती है, और यदि उनमें से बहुत सारे हैं, तो इसके लिए बहुत सारे बिट्स की भी आवश्यकता होती है। इसलिए, वे सभी प्रकार की चाल में जाते हैं, छाया रजिस्टर बनाते हैं, बैंकों, खिड़कियों और इतने पर पंजीकरण करते हैं। छाया रजिस्टर द्वारा, मेरा मतलब है कि एआरएम में रजिस्टर संगठन का सिद्धांत। यदि कोई रुकावट या अन्य स्थिति होती है, तो एक ही नाम (संख्या) के साथ रजिस्टरों का एक अलग सेट उपलब्ध होता है, जबकि मूल सेट में संग्रहीत जानकारी वहां रहती है। रजिस्टर बैंक, वास्तव में, छाया रजिस्टरों के समान हैं, रजिस्टर सेटों का बस कोई हार्डवेयर स्विचिंग नहीं है, और प्रोग्रामर चुनता है कि अब किस बैंक (रजिस्टरों का सेट) से संपर्क करें।

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

यह स्पष्ट है कि आपको स्टैक पर रजिस्टरों को सहेजने की आवश्यकता है (मेमोरी में), लेकिन यह तब किया जा सकता है जब नि: शुल्क रजिस्टर विंडोज़ समाप्त हो गई हैं।

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

अर्थात्, पहली विंडो में r0 शून्य में r2 के समान रजिस्टर होगा, और r3 के समान रजिस्टर में पहली विंडो से r1 होगा। यही है, प्रक्रिया को कॉल करने से पहले r2 में लिखना (विंडो नंबर बदलना) हमें r0 में मूल्य कहा जाता है। इस सिद्धांत को खिड़कियों के घूमने का तंत्र कहा जाता है।

आइए थोड़ा और अनुकूलन करें, क्योंकि एल्ब्रस के रचनाकारों ने ऐसा ही किया। हमारे पास जो विंडो हैं, वे निश्चित आकार के नहीं होंगे, लेकिन चर, विंडो का आकार प्रक्रिया में प्रवेश के समय निर्धारित किया जा सकता है। हम घुमाए गए रजिस्टरों की संख्या के साथ भी ऐसा ही करेंगे। यह निश्चित रूप से हमें कुछ समस्याओं की ओर ले जाएगा, क्योंकि यदि क्लासिक रोटेटेबल विंडो में, एक विंडो इंडेक्स है जिसके माध्यम से यह निर्धारित किया जाता है कि आपको डेटा को रजिस्टर फ़ाइल से स्टैक पर सहेजने या लोड करने की आवश्यकता है। लेकिन अगर आप विंडो इंडेक्स दर्ज नहीं करते हैं, लेकिन रजिस्टर इंडेक्स जिसमें से हमारी वर्तमान विंडो शुरू होती है, तो यह समस्या उत्पन्न नहीं होगी। एल्ब्रस में, ये सूचकांक रजिस्टर PSHTP (PS प्रक्रिया स्टैक के लिए) और PCSHTP (PCS प्रक्रियात्मक जानकारी स्टैक के लिए) में समाहित हैं। प्रलेखन "हार्डवेयर पॉइंटर्स को स्टैक के शीर्ष पर संदर्भित करता है"। अब आप फिर से स्टैक्स के बारे में पढ़ने की कोशिश कर सकते हैं, मुझे लगता है कि यह अधिक स्पष्ट होगा।

जैसा कि आप समझते हैं, इस तरह के एक तंत्र का मतलब है कि आपके पास स्मृति में जो है उसे नियंत्रित करने की क्षमता है। यही है, रजिस्टर फ़ाइल और स्टैक को सिंक्रनाइज़ करें। मेरा मतलब एक सिस्टम प्रोग्रामर से है। यदि आप एक एप्लिकेशन प्रोग्रामर हैं, तो उपकरण पारदर्शी प्रविष्टि और प्रक्रिया से बाहर निकलेंगे। यही है, अगर नई विंडो का चयन करने की कोशिश करते समय पर्याप्त रजिस्टर नहीं हैं, तो रजिस्टर विंडो स्वचालित रूप से "पंप आउट" कर देगी। इस स्थिति में, रजिस्टर फ़ाइल के सभी डेटा को उचित स्टैक (मेमोरी में) पर सहेजा जाएगा, और "स्टैक के हार्डवेयर टॉप को पॉइंटर" (ऑफ़सेट इंडेक्स) शून्य पर रीसेट किया जाएगा। इसी तरह, स्टैक से एक रजिस्टर फ़ाइल को स्वैप करने पर स्वचालित रूप से होता है। लेकिन अगर आप विकसित कर रहे हैं, उदाहरण के लिए, संदर्भ स्विचिंग, जो कि वास्तव में हमने किया है, तो आपको रजिस्टर फ़ाइल के छिपे हुए भाग के साथ काम करने के लिए एक तंत्र की आवश्यकता है। एल्ब्रस में, इसके लिए FLUSHR और FLUSHC कमांड का उपयोग किया जाता है। FLUSHR - रजिस्टर फाइल को क्लीयर करते हुए, करंट को छोड़कर सभी विंडो को प्रक्रियात्मक स्टैक में प्रवाहित कर दिया जाता है, PSHTP इंडेक्स को शून्य पर रीसेट किया जाता है। FLUSHC - बाइंडिंग इंफॉर्मेशन फाइल को क्लीयर करते हुए करंट विंडो को छोड़कर सब कुछ बाइंडिंग इंफॉर्मेशन स्टैक पर डंप हो जाता है, PCSHTP इंडेक्स भी जीरो पर रीसेट हो जाता है।

संक्षिप्त परिचय: एल्ब्रस में कार्यान्वयन

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

जब हम अगले फ़ंक्शन में प्रवेश करते हैं, तो प्रोसेसर दो विंडो बनाता है: पीएस स्टैक पर एक विंडो और पीसीएस स्टैक पर एक विंडो।

पीसीएस स्टैक में एक विंडो में फ़ंक्शन से लौटने के लिए आवश्यक जानकारी होती है: उदाहरण के लिए, निर्देश का आईपी (इंस्ट्रक्शन पॉइंटर) जहां आपको फ़ंक्शन से लौटने की आवश्यकता होगी। इसके साथ, सब कुछ कमोबेश स्पष्ट है।

PS स्टैक पर विंडो थोड़ा पेचीदा है। वर्तमान विंडो के रजिस्टरों की अवधारणा पेश की गई है। इस विंडो में, आपके पास वर्तमान विंडो के रजिस्टरों तक पहुंच है -% dr0,% dr1, ...,% dr15, ... यही है, हमारे लिए, एक उपयोगकर्ता के रूप में, वे हमेशा 0 से गिने जाते हैं, लेकिन यह वर्तमान विंडो के आधार पते के सापेक्ष है। इन रजिस्टरों के माध्यम से, फ़ंक्शन को कॉल करने पर तर्क पारित किए जाते हैं, और मान वापस किया जाता है, और फ़ंक्शन का उपयोग फ़ंक्शन के अंदर सामान्य उद्देश्य रजिस्टर के रूप में किया जाता है। वास्तव में, यह समझाया गया था जब रजिस्टर खिड़कियों को घुमाने के तंत्र पर विचार किया गया था।

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

setwd wsz=0x10

क्वाड-रजिस्टरों (128-बिट रजिस्टरों) के संदर्भ में विंडो का आकार निर्दिष्ट करता है।

अब, मान लें कि आप किसी फ़ंक्शन से फ़ंक्शन कॉल करना चाहते हैं। इसके लिए, पहले से ही एक घुमाए गए रजिस्टर विंडो की वर्णित अवधारणा को लागू किया जाता है। ऊपर दी गई तस्वीर एक रजिस्टर फ़ाइल का एक टुकड़ा दिखाती है जहां विंडो 1 (हरा) के साथ एक फ़ंक्शन विंडो 2 (नारंगी) के साथ एक फ़ंक्शन को कॉल करता है। इन दो कार्यों में से प्रत्येक में आपके% dr0,% dr1 तक पहुंच होगी, ... लेकिन तर्क तथाकथित रजिस्टरों के माध्यम से पारित किए जाएंगे। दूसरे शब्दों में, विंडो 1 के रजिस्टरों का हिस्सा विंडो 2 (इन दो विंडो चौराहे पर ध्यान दें) के रजिस्टर बन जाएंगे। ये रजिस्टर खिड़की से भी निर्धारित होते हैं (चित्र में रोटरी रजिस्टर देखें) और पता% db [0],% db [1] है ... इस प्रकार, विंडो 2 में% dr0 रजिस्टर% db [0] रजिस्टर से अधिक कुछ नहीं है। खिड़की 1।

रोटेशन रजिस्टर विंडो सेटबिन ऑपरेशन द्वारा सेट की गई है:

  setbn rbs = 0x3, rsz = 0x8

rbs घुमाए गए विंडो का आकार सेट करता है, और rsz आधार पता सेट करता है, लेकिन वर्तमान रजिस्टर विंडो के सापेक्ष। यानी यहां हमने 8 से शुरू होने वाले 3 रजिस्टर आवंटित किए हैं।

पूर्वगामी के आधार पर, हम दिखाते हैं कि फ़ंक्शन कॉल कैसा दिखता है। सादगी के लिए, हम मानते हैं कि फ़ंक्शन एक तर्क लेता है:

 void my_func(uint64_t a) { }

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

  addd 0, %dr9, %db[0] disp %ctpr1, my_func call %ctpr1, wbs = 0x8

इसलिए, रजिस्टरों के साथ थोड़ा समझ में आया। अब आइए बाइंडिंग जानकारी के ढेर को देखें। यह तथाकथित सीआर रजिस्टरों को संग्रहीत करता है। वास्तव में, दो - CR0, CR1। और उनके पास पहले से ही फ़ंक्शन से लौटने के लिए आवश्यक जानकारी है।

फ़ंक्शन की विंडो के रजिस्टर CR0 और CR1 जिन्हें नारंगी में चिह्नित रजिस्टरों के साथ फ़ंक्शन कहा जाता है, हरे हैं। CR0 रजिस्टरों में कॉलिंग फ़ंक्शन के निर्देश सूचक और एक निश्चित विधेय फ़ाइल (PF-Predicate फ़ाइल) शामिल है, इसके बारे में एक कहानी निश्चित रूप से इस लेख के दायरे से परे है।

CR1 रजिस्टरों में PSR (वर्ड प्रोसेसर स्टेटस), विंडो नंबर, विंडो साइज आदि जैसे डेटा होते हैं। एल्ब्रस में, सब कुछ इतना लचीला है कि हर प्रक्रिया सीआर 1 में जानकारी संग्रहीत करती है, भले ही फ़्लोटिंग पॉइंट ऑपरेशन प्रक्रिया में शामिल हो, और एक रजिस्टर जिसमें सॉफ़्टवेयर अपवादों के बारे में जानकारी हो, लेकिन इसके लिए, आपको अतिरिक्त जानकारी सहेजने के लिए भुगतान करना होगा।

यह बहुत महत्वपूर्ण है कि रजिस्टर फ़ाइल और बाइंडिंग सूचना फ़ाइल को मुख्य मेमोरी और इसके विपरीत (ऊपर वर्णित पीएस और पीसीएस स्टैक से) पंप और स्वैप किया जा सकता है। बाद में वर्णित सेटजम्प को लागू करते समय यह बिंदु महत्वपूर्ण है।

SETJMP / LONGJMP

और अंत में, कम से कम किसी तरह से यह समझना कि एल्ब्रस में स्टैक और रजिस्टरों की व्यवस्था कैसे की जाती है, आप कुछ उपयोगी करने के लिए शुरू कर सकते हैं, अर्थात्, Embox में नई कार्यक्षमता जोड़ सकते हैं।

Embox में, यूनिट परीक्षण प्रणाली को setjmp / longjmp की आवश्यकता होती है, इसलिए हमें इन कार्यों को लागू करना पड़ा।

कार्यान्वयन के लिए, रजिस्टरों को बचाने / बहाल करने के लिए आवश्यक है: CR0, CR1, PSP, PCSP, USD, - पहले से ही एक संक्षिप्त परिचय से हमें परिचित हैं। वास्तव में, बचत / बहाली हमारे माथे में लागू की जाती है, लेकिन एक महत्वपूर्ण अति सूक्ष्म अंतर है जिसे अक्सर स्टैक और रजिस्टरों के विवरण में संकेत दिया जाता है, अर्थात्: स्टैक को सिंक्रनाइज़ किया जाना चाहिए, क्योंकि वे न केवल मेमोरी में स्थित हैं, बल्कि रजिस्टर फ़ाइल में भी हैं। इस बारीकियों का मतलब है कि आपको कई विशेषताओं का ध्यान रखने की आवश्यकता है, जिसके बिना कुछ भी काम नहीं करेगा।

पहला फीचर सेव और रिस्टोर के दौरान इंटरप्ट को डिसेबल करना है। किसी बाधा को बहाल करते समय, इसे प्रतिबंधित करना अनिवार्य है, अन्यथा ऐसी स्थिति उत्पन्न हो सकती है जिसमें हम आधा-स्विच किए गए स्टैक के साथ इंटरचेंज हैंडलर में प्रवेश करते हैं ("संक्षिप्त विवरण" में वर्णित रजिस्टर फ़ाइल स्वैपिंग को पंप करने के लिए)। और जब बचत होती है, तो समस्या यह है कि प्रवेश करने और बाहर निकलने के बाद, प्रोसेसर फिर से रैम से रजिस्टर फ़ाइल का हिस्सा स्वैप कर सकता है (और इससे पीएसएचटीपी = 0 और पीएससीटीपी = 0, इनसे थोड़ा अधिक) को नष्ट कर देगा। इसीलिए, setjmp और longjmp दोनों में, इंटरप्ट को अक्षम करना होगा। यहां यह भी ध्यान दिया जाना चाहिए कि एमसीटीएस के विशेषज्ञों ने हमें बाधित करने के बजाय परमाणु कोष्ठक का उपयोग करने की सलाह दी है, लेकिन अब हम सबसे सरल (हमारे लिए समझने योग्य) कार्यान्वयन का उपयोग कर रहे हैं।

दूसरी विशेषता मेमोरी से एक रजिस्टर फ़ाइल को पंप / पंप करने से संबंधित है। यह इस प्रकार है। रजिस्टर फ़ाइल का एक सीमित आकार है और इसलिए इसे अक्सर मेमोरी में पंप किया जाता है और इसके विपरीत। इसलिए, यदि हम केवल पीएसपी और पीएसएचटीपी रजिस्टरों के मूल्यों को बचाते हैं, तो हम मेमोरी और रजिस्टर फ़ाइल में वर्तमान पॉइंटर के मूल्य को ठीक करेंगे। लेकिन चूंकि रजिस्टर फ़ाइल बदल रही है, संदर्भ बहाली के समय यह पहले से ही गलत होगा (न कि जिन्हें हमने "बचाया") डेटा। इससे बचने के लिए, आपको पूरी रजिस्टर फ़ाइल को मेमोरी में फ्लश करने की आवश्यकता है। इस प्रकार, जब सेजम्प में बचत होती है, तो हमारे पास मेमोरी में PSP.ind रजिस्टर और रजिस्टर विंडो में PSHSHTP.ind रजिस्टर होते हैं। यह पता चला है कि आपको पूरे PCSP.ind + PCSHTP.ind रजिस्टरों को सहेजना होगा। इस कार्य को करने वाला निम्नलिखित कार्य है:

 /* First arg is PCSP, 2nd arg is PCSHTP * Returns new PCSP value with updated PCSP.ind */ .type update_pcsp_ind,@function $update_pcsp_ind: setwd wsz = 0x4, nfx = 0x0 /* Here and below, 10 is size of PCSHTP.ind. Here we * extend the sign of PCSHTP.ind */ shld %dr1, (64 - 10), %dr1 shrd %dr1, (64 - 10), %dr1 /* Finally, PCSP.ind += PCSHTP.ind */ addd %dr1, %dr0, %dr0 E2K_ASM_RETURN

टिप्पणी में वर्णित इस कोड में एक छोटे से बिंदु को स्पष्ट करने के लिए भी आवश्यक है, अर्थात्, PCSHTP.ind सूचकांक में प्रोग्राम को वर्णिक रूप से विस्तारित करना आवश्यक है, क्योंकि सूचकांक नकारात्मक हो सकता है और अतिरिक्त कोड में संग्रहीत किया जा सकता है। ऐसा करने के लिए, हम पहले (64-10) को बाईं ओर (64-बिट रजिस्टर), 10-बिट फ़ील्ड पर, और फिर वापस जाएं।

वही PSP (प्रक्रिया स्टैक) के लिए जाता है

 /* First arg is PSP, 2nd arg is PSHTP * Returns new PSP value with updated PSP.ind */ .type update_psp_ind,@function $update_psp_ind: setwd wsz = 0x4, nfx = 0x0 /* Here and below, 12 is size of PSHTP.ind. Here we * extend the sign of PSHTP.ind as stated in documentation */ shld %dr1, (64 - 12), %dr1 shrd %dr1, (64 - 12), %dr1 muld %dr1, 2, %dr1 /* Finally, PSP.ind += PSHTP.ind */ addd %dr1, %dr0, %dr0 E2K_ASM_RETURN

थोड़े अंतर के साथ (फ़ील्ड 12 बिट्स है, और रजिस्टरों को वहां 128-बिट शब्दों में गिना जाता है, अर्थात, मान 2 से गुणा किया जाना चाहिए)।

स्वयं सेटजम्प कोड

 C_ENTRY(setjmp): setwd wsz = 0x14, nfx = 0x0 /* It's for db[N] registers */ setbn rsz = 0x3, rbs = 0x10, rcur = 0x0 /* We must disable interrupts here */ disp %ctpr1, ipl_save ipd 3 call %ctpr1, wbs = 0x10 /* Store current IPL to dr9 */ addd 0, %db[0], %dr9 /* Store some registers to jmp_buf */ rrd %cr0.hi, %dr1 rrd %cr1.lo, %dr2 rrd %cr1.hi, %dr3 rrd %usd.lo, %dr4 rrd %usd.hi, %dr5 /* Prepare RF stack to flush in longjmp */ rrd %psp.hi, %dr6 rrd %pshtp, %dr7 addd 0, %dr6, %db[0] addd 0, %dr7, %db[1] disp %ctpr1, update_psp_ind ipd 3 call %ctpr1, wbs = 0x10 addd 0, %db[0], %dr6 /* Prepare CF stack to flush in longjmp */ rrd %pcsp.hi, %dr7 rrd %pcshtp, %dr8 addd 0, %dr7, %db[0] addd 0, %dr8, %db[1] disp %ctpr1, update_pcsp_ind ipd 3 call %ctpr1, wbs = 0x10 addd 0, %db[0], %dr7 std %dr1, [%dr0 + E2K_JMBBUFF_CR0_HI] std %dr2, [%dr0 + E2K_JMBBUFF_CR1_LO] std %dr3, [%dr0 + E2K_JMBBUFF_CR1_HI] std %dr4, [%dr0 + E2K_JMBBUFF_USD_LO] std %dr5, [%dr0 + E2K_JMBBUFF_USD_HI] std %dr6, [%dr0 + E2K_JMBBUFF_PSP_HI] std %dr7, [%dr0 + E2K_JMBBUFF_PCSP_HI] /* Enable interrupts */ addd 0, %dr9, %db[0] disp %ctpr1, ipl_restore ipd 3 call %ctpr1, wbs = 0x10 /* return 0 */ adds 0, 0, %r0 E2K_ASM_RETURN

लोंगजम्प को लागू करते समय, यह महत्वपूर्ण है कि दोनों रजिस्टर फाइलों के सिंक्रोनाइज़ेशन के बारे में न भूलें, इसलिए, आपको न केवल रजिस्टर विंडो (फ्लश) को फ्लश करने की जरूरत है, बल्कि बाइंडर फाइल (फ्लश) को भी फ्लश करना होगा। आइए मैक्रो का वर्णन करें:

 #define E2K_ASM_FLUSH_CPU \ flushr; \ nop 2; \ flushc; \ nop 3;

अब जब सारी जानकारी मेमोरी में है, तो हम लॉन्गजम्प में सुरक्षित रूप से रिकवरी कर सकते हैं।

 C_ENTRY(longjmp): setwd wsz = 0x14, nfx = 0x0 setbn rsz = 0x3, rbs = 0x10, rcur = 0x0 /* We must disable interrupts here */ disp %ctpr1, ipl_save ipd 3 call %ctpr1, wbs = 0x10 /* Store current IPL to dr9 */ addd 0, %db[0], %dr9 /* We have to flush both RF and CF to memory because saved values * of P[C]SHTP can be not valid here. */ E2K_ASM_FLUSH_CPU /* Load registers previously saved in setjmp. */ ldd [%dr0 + E2K_JMBBUFF_CR0_HI], %dr2 ldd [%dr0 + E2K_JMBBUFF_CR1_LO], %dr3 ldd [%dr0 + E2K_JMBBUFF_CR1_HI], %dr4 ldd [%dr0 + E2K_JMBBUFF_USD_LO], %dr5 ldd [%dr0 + E2K_JMBBUFF_USD_HI], %dr6 ldd [%dr0 + E2K_JMBBUFF_PSP_HI], %dr7 ldd [%dr0 + E2K_JMBBUFF_PCSP_HI], %dr8 rwd %dr2, %cr0.hi rwd %dr3, %cr1.lo rwd %dr4, %cr1.hi rwd %dr5, %usd.lo rwd %dr6, %usd.hi rwd %dr7, %psp.hi rwd %dr8, %pcsp.hi /* Enable interrupts */ addd 0, %dr9, %db[0] disp %ctpr1, ipl_restore ipd 3 call %ctpr1, wbs = 0x10 /* Actually, we return to setjmp caller with second * argument of longjmp stored on r1 register. */ adds 0, %r1, %r0 E2K_ASM_RETURN

प्रसंग स्विच

जब हम सेटजम्प / लॉन्गजम्प का पता लगाते हैं, उसके बाद हमारे लिए पर्याप्त संदर्भ के मूल कार्यान्वयन_ स्पष्ट हो गए। दरअसल, पहले मामले में, हमें जानकारी और स्टैक को जोड़ने के रजिस्टरों को बचाने / पुनर्स्थापित करने की आवश्यकता है, साथ ही हमें प्रोसेसर स्थिति रजिस्टर (यूपीएसआर) को सही ढंग से बहाल करने की आवश्यकता है।

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

कोडर कोड reference_switch:

 C_ENTRY(context_switch): setwd wsz = 0x10, nfx = 0x0 /* Save prev UPSR */ rrd %upsr, %dr2 std %dr2, [%dr0 + E2K_CTX_UPSR] /* Disable interrupts before saving/restoring context */ rrd %upsr, %dr2 andnd %dr2, (UPSR_IE | UPSR_NMIE), %dr2 rwd %dr2, %upsr E2K_ASM_FLUSH_CPU /* Save prev CRs */ rrd %cr0.lo, %dr2 rrd %cr0.hi, %dr3 rrd %cr1.lo, %dr4 rrd %cr1.hi, %dr5 std %dr2, [%dr0 + E2K_CTX_CR0_LO] std %dr3, [%dr0 + E2K_CTX_CR0_HI] std %dr4, [%dr0 + E2K_CTX_CR1_LO] std %dr5, [%dr0 + E2K_CTX_CR1_HI] /* Save prev stacks */ rrd %usd.lo, %dr3 rrd %usd.hi, %dr4 rrd %psp.lo, %dr5 rrd %psp.hi, %dr6 rrd %pcsp.lo, %dr7 rrd %pcsp.hi, %dr8 std %dr3, [%dr0 + E2K_CTX_USD_LO] std %dr4, [%dr0 + E2K_CTX_USD_HI] std %dr5, [%dr0 + E2K_CTX_PSP_LO] std %dr6, [%dr0 + E2K_CTX_PSP_HI] std %dr7, [%dr0 + E2K_CTX_PCSP_LO] std %dr8, [%dr0 + E2K_CTX_PCSP_HI] /* Load next CRs */ ldd [%dr1 + E2K_CTX_CR0_LO], %dr2 ldd [%dr1 + E2K_CTX_CR0_HI], %dr3 ldd [%dr1 + E2K_CTX_CR1_LO], %dr4 ldd [%dr1 + E2K_CTX_CR1_HI], %dr5 rwd %dr2, %cr0.lo rwd %dr3, %cr0.hi rwd %dr4, %cr1.lo rwd %dr5, %cr1.hi /* Load next stacks */ ldd [%dr1 + E2K_CTX_USD_LO], %dr3 ldd [%dr1 + E2K_CTX_USD_HI], %dr4 ldd [%dr1 + E2K_CTX_PSP_LO], %dr5 ldd [%dr1 + E2K_CTX_PSP_HI], %dr6 ldd [%dr1 + E2K_CTX_PCSP_LO], %dr7 ldd [%dr1 + E2K_CTX_PCSP_HI], %dr8 rwd %dr3, %usd.lo rwd %dr4, %usd.hi rwd %dr5, %psp.lo rwd %dr6, %psp.hi rwd %dr7, %pcsp.lo rwd %dr8, %pcsp.hi /* Restore next UPSR */ ldd [%dr1 + E2K_CTX_UPSR], %dr2 rwd %dr2, %upsr E2K_ASM_RETURN

एक और महत्वपूर्ण बिंदु ओएस थ्रेड का प्रारंभ है। Embox में, प्रत्येक थ्रेड में एक निश्चित प्राथमिक प्रक्रिया होती है

 void _NORETURN thread_trampoline(void);

जिसमें धारा के आगे के सभी कार्य निष्पादित किए जाएंगे। इस प्रकार, हमें किसी तरह से इस फ़ंक्शन को कॉल करने के लिए स्टैक तैयार करने की आवश्यकता है, यह यहां है कि हम इस तथ्य से सामना कर रहे हैं कि तीन स्टैक हैं, और वे एक ही दिशा में नहीं बढ़ते हैं। आर्किटेक्चर द्वारा, हम सिंगल स्टैक के साथ एक स्ट्रीम बनाते हैं, या यूँ कहें कि स्टैक के नीचे इसकी एक ही जगह होती है, सबसे ऊपर हमारे पास एक ऐसा स्ट्रक्चर होता है जो स्ट्रीम का ही वर्णन करता है, और इसी तरह, यहाँ हमें अलग-अलग स्टाॅक का ध्यान रखना था, न कि यह भूल जाना चाहिए कि किस पर एलाइन होना चाहिए 4 केबी, सभी प्रकार के एक्सेस राइट्स और इतने पर मत भूलना।

नतीजतन, फिलहाल हमने तय किया कि हम स्टैक के नीचे की जगह को तीन हिस्सों में बाँट देंगे, एक चौथाई को बाइंडिंग इन्फ़र्मेशन के ढेर के नीचे, एक चौथाई को प्रक्रियात्मक स्टैक के नीचे और आधे को यूज़र स्टैक के नीचे बाँट देंगे।

मैं कोड लाता हूं ताकि आप मूल्यांकन कर सकें कि यह कितना बड़ा है, आपको यह विचार करने की आवश्यकता है कि यह न्यूनतम आरंभीकरण है।

 /* This value is used for both stack base and size align. */ #define E2K_STACK_ALIGN (1UL << 12) #define round_down(x, bound) ((x) & ~((bound) - 1)) /* Reserve 1/4 for PSP stack, 1/4 for PCSP stack, and 1/2 for USD stack */ #define PSP_CALC_STACK_BASE(sp, size) binalign_bound(sp - size, E2K_STACK_ALIGN) #define PSP_CALC_STACK_SIZE(sp, size) binalign_bound((size) / 4, E2K_STACK_ALIGN) #define PCSP_CALC_STACK_BASE(sp, size) \ (PSP_CALC_STACK_BASE(sp, size) + PSP_CALC_STACK_SIZE(sp, size)) #define PCSP_CALC_STACK_SIZE(sp, size) binalign_bound((size) / 4, E2K_STACK_ALIGN) #define USD_CALC_STACK_BASE(sp, size) round_down(sp, E2K_STACK_ALIGN) #define USD_CALC_STACK_SIZE(sp, size) \ round_down(USD_CALC_STACK_BASE(sp, size) - PCSP_CALC_STACK_BASE(sp, size),\ E2K_STACK_ALIGN) static void e2k_calculate_stacks(struct context *ctx, uint64_t sp, uint64_t size) { uint64_t psp_size, pcsp_size, usd_size; log_debug("Stacks:\n"); ctx->psp_lo |= PSP_CALC_STACK_BASE(sp, size) << PSP_BASE; ctx->psp_lo |= E2_RWAR_RW_ENABLE << PSP_RW; psp_size = PSP_CALC_STACK_SIZE(sp, size); assert(psp_size); ctx->psp_hi |= psp_size << PSP_SIZE; log_debug(" PSP.base=0x%lx, PSP.size=0x%lx\n", PSP_CALC_STACK_BASE(sp, size), psp_size); ctx->pcsp_lo |= PCSP_CALC_STACK_BASE(sp, size) << PCSP_BASE; ctx->pcsp_lo |= E2_RWAR_RW_ENABLE << PCSP_RW; pcsp_size = PCSP_CALC_STACK_SIZE(sp, size); assert(pcsp_size); ctx->pcsp_hi |= pcsp_size << PCSP_SIZE; log_debug(" PCSP.base=0x%lx, PCSP.size=0x%lx\n", PCSP_CALC_STACK_BASE(sp, size), pcsp_size); ctx->usd_lo |= USD_CALC_STACK_BASE(sp, size) << USD_BASE; usd_size = USD_CALC_STACK_SIZE(sp, size); assert(usd_size); ctx->usd_hi |= usd_size << USD_SIZE; log_debug(" USD.base=0x%lx, USD.size=0x%lx\n", USD_CALC_STACK_BASE(sp, size), usd_size); } static void e2k_calculate_crs(struct context *ctx, uint64_t routine_addr) { uint64_t usd_size = (ctx->usd_hi >> USD_SIZE) & USD_SIZE_MASK; /* Reserve space in hardware stacks for @routine_addr */ /* Remark: We do not update psp.hi to reserve space for arguments, * since routine do not accepts any arguments. */ ctx->pcsp_hi |= SZ_OF_CR0_CR1 << PCSP_IND; ctx->cr0_hi |= (routine_addr >> CR0_IP) << CR0_IP; ctx->cr1_lo |= PSR_ALL_IRQ_ENABLED << CR1_PSR; /* Divide on 16 because it field contains size in terms * of 128 bit values. */ ctx->cr1_hi |= (usd_size >> 4) << CR1_USSZ; } void context_init(struct context *ctx, unsigned int flags, void (*routine_fn)(void), void *sp, unsigned int stack_size) { memset(ctx, 0, sizeof(*ctx)); e2k_calculate_stacks(ctx, sp, stack_size); e2k_calculate_crs(ctx, (uint64_t) routine_fn); if (!(flags & CONTEXT_IRQDISABLE)) { ctx->upsr |= (UPSR_IE | UPSR_NMIE); } }

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

बस के मामले में, मैं दोहराता हूं, यह सामग्री आधिकारिक दस्तावेज नहीं है! आधिकारिक सहायता, प्रलेखन और बाकी के लिए, आपको सीधे ICST से संपर्क करना होगा। Embox में कोड, निश्चित रूप से खुला है, लेकिन इसे संकलित करने के लिए, आपको एक क्रॉस-कंपाइलर की आवश्यकता होगी, जिसे फिर से, MCST से प्राप्त किया जा सकता है।

चढ़ाई एलब्रस - लड़ाई में टोही। तकनीकी भाग 1. रजिस्टर, ढेर और अन्य तकनीकी विवरण

संक्षिप्त परिचय: ढेर

संक्षिप्त परिचय: रजिस्टर। फ़ाइलें पंजीकृत करें। विंडो रजिस्टर करें

संक्षिप्त परिचय: एल्ब्रस में कार्यान्वयन

SETJMP / LONGJMP

प्रसंग स्विच

More articles: