🕴🏽 🧑🏿‍🤝‍🧑🏾 👨🏽‍🎨 "मल्टीलेट" का गीत 🤶🏿 💘 🤘🏾

नहीं, मैंने आपको MCp0411100101 नाम में छिपाई हुई पहेली नहीं बताई है, लेकिन मैं इस विषय पर टिप्पणी करने वाले nerudo पर विस्तार करने का प्रयास करूंगा जो "मल्टीलेट" विषय में अधिक सुलभ हो गया है :

इस बहुस्तरीय के वास्तु नवाचारों का वर्णन पढ़ते हुए, मैं अगले विषय से वाक्यांश का उपयोग करना चाहूंगा: "मुझे समझ में नहीं आता है।"

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

MCp के लाभों के बारे में

शुरुआत के लिए, मैं कहूंगा कि एमसीपी में ईपीआईसी ऐसा है कि यह प्रोसेसर को कई आकर्षक (कम से कम मेरे लिए व्यक्तिगत रूप से) गुण प्रदान करता है।

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

अब मैं यह समझाने की कोशिश करूँगा कि ये गुण कहाँ से आते हैं और “बहुकोशिकीय” नाम कहाँ से आता है, यानी “सेल” क्या है। चिह्नों में रहस्यमय संख्याओं के बारे में मुझे कुछ नहीं पता। शायद यह कुछ "MultiClet" खोज की कुंजी है? :) नहीं, मैं गंभीरता से नहीं जानता।

कोशिकाओं

एक सेल (ऐसा नाम) MCp माइक्रोआर्किटेक्चर का मुख्य तत्व है। यह क्या है, इसका एक सरल विवरण हो सकता है, लेकिन मौजूदा प्रोसेसर के विवरण के साथ शुरुआत करना मेरे लिए आसान है।

किसी भी आधुनिक सीपीयू में कुछ कार्यात्मक उपकरणों का एक सेट होता है। उन्हें कई प्रकारों में विभाजित किया जा सकता है। आइए विभाजित करते हैं (एमसीपी की विशेषताओं की व्याख्या करने के लिए, मुझे उनके बारे में बहुत विस्तृत विवरण की आवश्यकता नहीं है, इसलिए सब कुछ सतही है)।

ALU : एक व्यापक अर्थ में अंकगणितीय तर्क उपकरण। यही है, डिवाइस जो डेटा पर सभी प्रकार के परिवर्तनों का प्रदर्शन करते हैं। उनके पास इनपुट पोर्ट हैं जिनसे ऑपरेशन कोड और ऑपरेंड्स और आउटपुट की आपूर्ति की जाती है, जिस पर परिणाम उत्पन्न होते हैं।
एलएसयू : मेमोरी एक्सेस डिवाइस (लोड / स्टोर यूनिट)। स्वाभाविक रूप से, डेटा का यह टुकड़ा परिवर्तित नहीं होता है, लेकिन स्मृति से लिखता है या पढ़ता है। इसके अपने इनपुट और आउटपुट पोर्ट हैं।
आरएफ : रजिस्टर फ़ाइल। ये डिवाइस कुछ बसों से डेटा संग्रहीत करते हैं (सही नाम नहीं, लेकिन सार नहीं) और उन्हें अन्य बसों में स्थानांतरित करते हैं, उनके इनपुट बंदरगाहों पर कमांड और मूल्यों पर ध्यान केंद्रित करते हैं। ये बसें LSU या ALU पोर्ट से जुड़ी हैं। यह अक्सर कहा जाता है कि रजिस्टर इतनी तेज आंतरिक प्रोसेसर मेमोरी है। यह कहना अधिक सही है कि आरएफ प्रोसेसर की इतनी कुशल आंतरिक मेमोरी है, और रजिस्टरों के शब्दार्थ इसे एक्सेस करने के लिए इंटरफेस हैं। क्योंकि महामहिम मौजूद है ...
CU : नियंत्रण उपकरण। यह एक ऐसा उपकरण है जो कई ALU, LSUs और RF का प्रबंधन करता है (यह अब एक सामान्य आरएफ प्रति कोर बनाने के लिए फैशनेबल है, लेकिन यह हमेशा इस तरह से नहीं किया गया है; मैं सिर्फ स्पष्ट कर रहा हूं), उनके बीच सिग्नल ट्रांसमिशन को नियंत्रित करते हुए, कार्यक्रम को निष्पादित करना। आधुनिक पारंपरिक उच्च-प्रदर्शन प्रोसेसर में, सीयू स्वयं बहुत जटिल है, और इसमें अन्य घटक शामिल हैं: शेड्यूलर, शाखा भविष्यवक्ता, डिकोडर, कतार, पावती बफ़र, आदि। लेकिन इस कहानी के प्रयोजनों के लिए, मेरे लिए यह सब एक उपकरण के रूप में विचार करना अधिक सुविधाजनक है। उसी तरह, मैं ALU और शिफ्टर्स ALU पर लेट नहीं हूं।

हम कह सकते हैं कि CU एक ऐसा उपकरण है जो प्रोसेसर के प्रकार को निर्धारित करता है। लगभग सभी आधुनिक पारंपरिक प्रोसेसर में, ALU, LSU और RF कार्यात्मक रूप से लगभग समान होते हैं (यदि आप कार्यान्वयन के सूक्ष्म विवरण में नहीं जाते हैं और वेक्टर और स्केलर ALUs के बीच अंतर करते हैं; हां, मैं मानता हूं कि यह कथन सशर्त था)। सीपीयू, जीपीयू, पीपीयू, एसपीयू और अन्य एक्सपीयू मॉडल की पूरी विविधता विभिन्न सीयू वेरिएंट के काम के तर्क में अंतर द्वारा प्रदान की जाती है (और यह अंतर वेक्टर और स्केलर एएलयू के बीच अंतर की तुलना में बहुत अधिक महत्वपूर्ण है)।

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

यह असाधारण निष्पादन के साथ एक फैंसी सुपरस्क्लेयर और मल्टी-थ्रेड POWER8 का तर्क हो सकता है, जो प्रत्येक घड़ी चक्र के लिए कई निर्देशों का चयन करता है, पिछले नमूने को डिकोड करता है, रजिस्टर का नाम बदल देता है, एक विशाल रजिस्टर फ़ाइल चलाता है (यहां तक कि 16 दृश्य रजिस्टरों के साथ i686 के साथ, रजिस्टर फाइलें आकार हो सकती हैं। 128x64 बिट्स में), ब्रांचिंग आदि की भविष्यवाणी करता है। आप इस तरह के प्रोसेसर को होमवर्क के रूप में नहीं कर सकते।

या यह एक काफी सरल आरआईएससी-जैसे सीयू भी हो सकता है, जो कि जीपीयू सभी ALU, LSUs और RFs को एक मल्टीप्रोसेसर में समान कमांड में वितरित करता है।

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

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

तो, एक सेल एक परिचित सीपीयू में नाभिक का एक एनालॉग है। इसमें अपना सीयू, एएलयू (एक, लेकिन प्रोसेसर के शुरुआती संस्करण में भी काफी उन्नत है, फ्लोट [2] मूल्यों के साथ संचालन करने में सक्षम है, जिसमें जटिल अंकगणितीय ऑपरेशन भी शामिल हैं; वर्तमान में विकसित किया गया संस्करण दोहरे के साथ गणना का समर्थन करेगा)। सेल में सामान्य आरएफ और एलएसयू तक पहुंच हो सकती है, या उनका अपना हो सकता है, जो मिरर मोड या यहां तक कि RAID-5 में संचालित हो सकता है (यदि आवश्यक हो; याद रखें, परियोजना के विकास के इस चरण में सबसे महत्वपूर्ण शब्द "गलती सहिष्णुता" है)। और एमसीपी वास्तुकला में सबसे सुखद स्थानों में से एक यह है कि हालांकि आरएफ ऐसे साधनों में बहुत धीमी गति से काम करेगा, एमसीपी प्रदर्शन इसे काफी कम नहीं करेगा, क्योंकि गणना के दौरान मुख्य डेटा विनिमय आरएफ और शंट (बाईपास) के माध्यम से नहीं है, लेकिन एक अन्य गैर-मेमोरी डिवाइस के माध्यम से - एक स्विच।

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

मेरी राय में (जो स्वयं MCp को विकसित और सुधारने वाले इंजीनियरों की राय से भिन्न हो सकते हैं), प्रोसेसर में सबसे महत्वपूर्ण उपलब्धि वास्तव में ये CU हैं, जो गलती को सहनशीलता और ऊर्जा दक्षता प्रदान करते हैं जो प्रोसेसर के अस्तित्व के वर्तमान चरण में महत्वपूर्ण हैं। और उनके निर्माण का प्रस्तावित सिद्धांत न केवल माइक्रोप्रोसेसरों के लिए महत्वपूर्ण है, बल्कि अन्य उच्च-प्रदर्शन वितरित कंप्यूटिंग सिस्टम के लिए भी है (उदाहरण के लिए, RiDE सिस्टम समान सिद्धांतों पर बनाया गया है)।

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

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

नॉनक्लियरिटी का जन्म

अब मैं यह समझाने की कोशिश करूंगा कि ऐसा वितरित सीयू क्यों संभव है, कि यह वास्तव में सरल हो सकता है, इसके लिए प्रोग्राम कोडिंग की एक और विधि की आवश्यकता है, और क्यों एमसीपी के लेखकों द्वारा प्रस्तावित यह विधि शांत है। फिर, मेरे लिए पारंपरिक (GPU और VLIWs को पारंपरिक भी माना जाता है) आर्किटेक्चर का वर्णन करके शुरू करना आसान है।

चलो पहले से ही कुछ संकलित करें, अन्यथा मैंने पहले से ही दो दिनों के लिए कुछ भी संकलित नहीं किया है, मेरे हाथ खुजली कर रहे हैं।

cat test-habr.c && gcc -S test-habr.c && cat test-habr.s

typedef struct arrst Arrst;

struct arrst
{
	void * p;
	char a[27];
	unsigned x;
};

struct st2
{
	Arrst a[23];
	struct st2 * ptr;
};

struct st2 fn5(unsigned x, char y, int z, char w, double r, Arrst a, Arrst b)
{
	int la[27];
	char lb[27];
	double lc[4];
	struct st2 ld[1];

	return ((struct st2 *)b.p)[a.a[((Arrst *)b.p)->a[13]]].ptr->ptr->ptr[lb[10]];
}

	.file	"test-habr.c"
	.text
	.globl	fn5
	.type	fn5, @function
fn5:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$1016, %rsp
	movq	%rdi, -1112(%rbp)
	movl	%esi, -1116(%rbp)
	movl	%edx, %eax
	movl	%ecx, -1124(%rbp)
	movl	%r8d, %edx
	movsd	%xmm0, -1136(%rbp)
	movb	%al, -1120(%rbp)
	movb	%dl, -1128(%rbp)
	movq	56(%rbp), %rdx
	movq	56(%rbp), %rax
	movzbl	21(%rax), %eax
	movsbl	%al, %eax
	cltq
	movzbl	24(%rbp,%rax), %eax
	movsbq	%al, %rax
	imulq	$928, %rax, %rax
	addq	%rdx, %rax
	movq	920(%rax), %rax
	movq	920(%rax), %rax
	movq	920(%rax), %rdx
	movzbl	-134(%rbp), %eax
	movsbq	%al, %rax
	imulq	$928, %rax, %rax
	leaq	(%rdx,%rax), %rcx
	movq	-1112(%rbp), %rax
	movq	%rax, %rdx
	movq	%rcx, %rsi
	movl	$116, %eax
	movq	%rdx, %rdi
	movq	%rax, %rcx
	rep movsq
	movq	-1112(%rbp), %rax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	fn5, .-fn5
	.ident	"GCC: (GNU) 4.7.2"
	.section	.note.GNU-stack,"",@progbits

. , CU, (, AT&T ):

	imulq	$928, %rax, %rax
	addq	%rdx, %rax
	movq	920(%rax), %rax
	movq	920(%rax), %rax
	movq	920(%rax), %rdx
	movzbl	-134(%rbp), %eax

, , , , 6-, . , , . , : - .

, , , — ( , , , , ; CU ; , ) — ( , ). CU :

CU ?
, ( ?) , ?
?
?

, , . , , CU. Core iX, AMD FX, POWER8 . CU «», , , . . CU — , CPU. . , . , .

, . VIA Isaiah ( ) . , , PLL, FP, IU, Load/Store — .

ARM big.LITTLE, , , . , NVIDIA , 4 , Sandy Bridge. SB - .

VLIW EPIC Intel HP (Itanium) : , ( , ). , . . CU VLIW- Itanium- . , CU , . , MCp. , VLIW : 6- ( Itanium) , , 12. : , ( ), VLIW . Itanium prefetch-, . , . () RISC SMT-, , .

. - , , CU ( , ALU). (, , CU ). .

«» : ? : !

! compilation time! (, ) MCp.

cat test-habr.c && rcc -target=mcp < test-habr.c

typedef struct arrst Arrst;

struct arrst
{
	void * p;
	char a[27];
	unsigned x;
};

struct st2
{
	Arrst a[23];
	struct st2 * ptr;
};

struct st2 fn5(unsigned x, char y, int z, char w, double r, Arrst a, Arrst b)
{
	int la[27];
	char lb[27];
	double lc[4];
	struct st2 ld[1];

	return ((struct st2 *)b.p)[a.a[((Arrst *)b.p)->a[13]]].ptr->ptr->ptr[lb[10]];
}

: .local/.global ( ). .alias, #define. . . beta- ( , , ). . . , . , .

.alias SP 39	; stack pointer
.alias BP 38	; function frame base pointer
.alias SI 37	; source address
.alias DI 36	; destination address
.alias CX 35	; counter

.text

fn5:
	.alias fn5.2.0C #BP,8
	.alias fn5.x.4C #BP,12
	.alias fn5.y.8C #BP,16
	.alias fn5.z.12C #BP,20
	.alias fn5.w.16C #BP,24
	.alias fn5.r.20C #BP,28
	.alias fn5.a.24C #BP,32
	.alias fn5.b.60C #BP,68

	.alias fn5.2.0A #BP,8
	.alias fn5.x.4A #BP,12
	.alias fn5.y.8A #BP,16
	.alias fn5.z.12A #BP,20
	.alias fn5.w.16A #BP,24
	.alias fn5.r.20A #BP,28
	.alias fn5.a.24A #BP,32
	.alias fn5.b.60A #BP,68

	.alias fn5.lb.27AD #BP,-27
	.alias fn5.1.32RT #BP,-32
	.alias fn5.2.36RT #BP,-36
	.alias fn5.3.40RT #BP,-40
	.alias fn5.4.44RT #BP,-44
	.alias fn5.5.48RT #BP,-48

	jmp	fn5.P0
	getl	#SP
	getl	#BP
	subl	@2, 4
	subl	@3, 56
	wrl	@3, @2
	setl	#SP, @2
	setl	#BP, @4
	complete

fn5.P0:
	jmp	fn5.P1
	rdsl	fn5.y.8C
	wrsb	@1, fn5.y.8A
	complete

fn5.P1:
	jmp	fn5.P2
	rdsl	fn5.w.16C
	wrsb	@1, fn5.w.16A
	complete

fn5.P2:
	jmp	fn5.P3
	getsl	0x340
	wrsl	@1, fn5.1.32RT
	complete

fn5.P3:
	jmp	fn5.P4
	rdsb	fn5.lb.27AD + 10
	rdsl	fn5.1.32RT
	mulsl	@1, @2
	wrsl	@1, fn5.2.36RT
	complete

fn5.P4:
	jmp	fn5.P5
	rdl	fn5.b.60A
	wrl	@1, fn5.3.40RT
	complete

fn5.P5:
	jmp	fn5.P6
	rdl	fn5.3.40RT
	addl	@1, 0x11
	rdsb	@1
	exa	fn5.a.24A + 4
	addl	@2, @1
	rdsb	@1
	rdsl	fn5.1.32RT
	mulsl	@1, @2
	wrsl	@1, fn5.4.44RT
	complete

fn5.P6:
	jmp	fn5.P7
	getsl	0x33c
	wrsl	@1, fn5.5.48RT
	complete

fn5.P7:
	jmp	fn5.P7.blkloop
	rdl	fn5.3.40RT
	rdsl	fn5.4.44RT
	rdsl	fn5.5.48RT
	addl	@2, @3
	addl	@1, @2
	rdsl	fn5.5.48RT
	rdl	@2
	addl	@1, @2
	rdsl	fn5.5.48RT
	rdl	@2
	addl	@1, @2
	rdl	@1
	rdsl	fn5.2.36RT
	addl	@1, @2
	rdl	fn5.2.0A

;   -     :)
	getl	0x0000ffff
	patch	@1, @3
	patch	@2, @3
	setq	#SI, @2
	setq	#DI, @2
	getl	0xfcc1ffff
	patch	@1, 0
	setq	#CX, @1

	getl	#MODR
	or	@1, 0x38
	setl	#MODR, @1
	complete

;  ,    CX, SI  DI  
fn5.P7.blkloop:
	exa	#CX
	jne	@1, fn5.P7.blkloop
	je	@2, fn5.P7.blkclean
	rdb	#SI
	wrb	@1, #DI
	complete

fn5.P7.blkclean:
	jmp	fn5.PF
	getl	#MODR
	and	@1, 0xffffffc7
	setl	#MODR, @1
	complete

fn5.1L:
fn5.PF:
	rdl	#BP, 4
	jmp	@1
	getl	#BP
	rdl	#BP, 0
	addl	@2, 4
	setl	#BP, @2
	setl	#SP, @2
	complete

, . , , complete. .

. , ( #), , . @N, N — , . , , , .

, , @- . , , , , , . MCp «» . (setX) (wrX).

, , , , . .

, N . n, , N*k+n (k = 0, 1, ...) , complete ( , ). .

, . , . , @- ( ) - , .

. , , — , - , CU . VLIW EPIC-, ( ), , , CU , ( ).

. RF. MCp , , RF . , RF .

Load/Store/MOB Isaiah. , — MOB, Memory Ordering Buffer. , , / ( ) . : . .

: ! RF . , , @- . , :

volatile a;
a += a;

( ):

	rdsl	a
	rdsl	a
	addsl	@1, @2
	wrsl	@1, a

, , . , MOB, +1 MCp.

. . , , . . , . . .

MCp . , (, , ) . : jmp ( ) j ( ), , .

, complete , . , jmp , .

MCp . , , :

	doSomething;
	if(condition)
	{
		doStuff;
	}

, doSomething. condition, ( , ). doSomething.

doSomething . , CU , , , . , . : , ! ; : , ! , .

MCp , , , doSomething (, ). MCp ( ), ( ) ( ). +1 .

, MCp CU, CU . CU , : , RF.

MCp. . , . MCp , , .

— . . , RF , ( ), . , . , ( ). .

-, , , . -, WriteBack-, . WB-, , , MCp RF (, , , MCp , , +1 ), . .

— (MMU). . , OS, : Linux, Plan9 :) , MMU — . , SPEC MMU 17.5% ; SUN Java 40%. , MMU ( MCp)? CUDA . , () , Java, .Net, JavaScript, Go, : ?

, - , , . , (TLB) MMU 32 , 33 . . - . .. , .

MCp

, , .

, :) , CU. , . , , , . , , N*k+n (k = 0, 1, ...) N=1 n=0, . , . Profit? PROFIT! big.LITTLE .

. , - , , N n. (, , SMS- , ! !).

(managed runtimes) . (, , , ?). MCp (, ) , . , - , .

, MCp , , , . , , , (dependable) . , pattern-matching . , (- ):

fib :: (Integral t) => t -> t
fib 0 = 1
fib 1 = 1
fib n = fib (n - 1) + fib (n - 2)

CPU fib , , 1 .. , . MCp , .

, . , . , ( , ..). 16- , , , : ? ( ). , . , , .

MCp. , ( , ) , . . , , .

, !

, ( , ) - , .

"मल्टीलेट" का गीत

MCp के लाभों के बारे में

कोशिकाओं

नॉनक्लियरिटी का जन्म

MCp

, !

More articles: