🌲 👍🏿 👉 सीपीयू कोर या एसएमपी क्या है और यह क्या खाता है 🏗️ 🤵🏽 ✍🏽

परिचय

अच्छा दिन है, आज मैं एक साधारण विषय पर बात करना चाहूंगा जो आम प्रोग्रामर के लिए लगभग अज्ञात है, लेकिन आप में से प्रत्येक ने इसका उपयोग किया है।
यह सममित मल्टीप्रोसेसिंग (लोकप्रिय रूप से - एसएमपी) के बारे में होगा - जो आर्किटेक्चर सभी मल्टीटास्किंग ऑपरेटिंग सिस्टम में पाया जाता है, और निश्चित रूप से, उनका एक अभिन्न अंग है। हर कोई जानता है कि एक प्रोसेसर जितना अधिक कोर होता है, उतना अधिक शक्तिशाली प्रोसेसर होगा, हाँ यह है, लेकिन एक ही समय में एक ओएस कई कोर का उपयोग कैसे कर सकता है? कुछ प्रोग्रामर अमूर्तता के इस स्तर तक नहीं जाते हैं - उन्हें बस इसकी आवश्यकता नहीं है, लेकिन मुझे लगता है कि एसएमपी कैसे काम करता है, इस पर सभी की दिलचस्पी होगी।

मल्टीटास्किंग और इसका कार्यान्वयन

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

इंटरप्ट और पीआईसी

शायद कुछ के लिए यह खबर बन जाएगी, कुछ के लिए यह नहीं होगा, लेकिन i386 आर्किटेक्चर (मैं x86 आर्किटेक्चर के बारे में बात करूँगा, एआरएम गिनती नहीं करता है, क्योंकि मैंने इस आर्किटेक्चर का अध्ययन नहीं किया है, और मैं कभी भी इसके पार नहीं आया हूं (यहां तक कि एक सेवा या निवासी कार्यक्रम लिखने के स्तर पर)) एक घटना के बारे में ओएस या कार्यक्रम को सूचित करने के लिए इंटरप्ट का उपयोग करता है (हम केवल हार्डवेयर रुकावट, आईआरक्यू के बारे में बात करेंगे)। उदाहरण के लिए, एक अवरोध 0x8 है (संरक्षित और लंबे मोड के लिए, उदाहरण के लिए, 0x20, PIC को कॉन्फ़िगर करने के तरीके के आधार पर, उस पर और बाद में), जिसे पीआईटी द्वारा कहा जाता है, जो कि, उदाहरण के लिए, किसी भी आवश्यक आवृत्ति के साथ व्यवधान उत्पन्न कर सकता है। फिर समय क्वांटा के वितरण के लिए ओएस का काम 0 पर कम हो जाता है, जब एक बाधा कहा जाता है, तो कार्यक्रम बंद हो जाता है और नियंत्रण दिया जाता है, उदाहरण के लिए, कर्नेल को, जो बदले में वर्तमान प्रोग्राम डेटा (रजिस्टर, झंडे, आदि) को बचाता है और अगली प्रक्रिया को नियंत्रण देता है। ।

जैसा कि आप शायद समझ गए हैं, इंटरप्ट कार्य (या प्रक्रियाएं) हैं जिन्हें कुछ बिंदुओं पर उपकरण द्वारा, या स्वयं कार्यक्रम द्वारा कहा जाता है। कुल मिलाकर, प्रोसेसर दो PICs पर 16 इंटरप्ट का समर्थन करता है। प्रोसेसर में झंडे होते हैं, और उनमें से एक "I" ध्वज है - इंटरप्ट कंट्रोल। इस ध्वज को 0 पर सेट करके, प्रोसेसर किसी भी हार्डवेयर रुकावट का कारण नहीं होगा। लेकिन, मैं यह भी नोट करना चाहता हूं कि तथाकथित NMI हैं - नॉन-मास्केबल इंटरप्ट्स - इंटरप्ट डेटा को तब भी कॉल किया जाएगा, भले ही बिट I को 0. पर सेट किया गया हो। PIC प्रोग्रामिंग का उपयोग करके, आप इंटरप्ट डेटा को अक्षम कर सकते हैं, लेकिन किसी भी इंटरप्ट से लौटने के बाद IRET - उन्हें फिर से प्रतिबंधित नहीं किया जाएगा। मैं ध्यान देता हूं कि एक नियमित कार्यक्रम के तहत आप इंटरप्ट कॉल को ट्रैक नहीं कर सकते हैं - आपका प्रोग्राम बंद हो जाता है और केवल थोड़ी देर बाद फिर से शुरू हो जाता है, आपका प्रोग्राम भी ध्यान नहीं देता है (हां, आप जांच सकते हैं कि इंटरप्ट कहा गया था - लेकिन क्यों?

PIC - प्रोग्रामेबल इंटरप्ट कंट्रोलर

विकी से:

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

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

जैसा कि आप समझते हैं, यह एक इलेक्ट्रॉनिक सर्किट है जो उपकरणों को रुकावट अनुरोध भेजने की अनुमति देता है, आमतौर पर उनमें से बिल्कुल 2 होते हैं।

अब, लेख के विषय पर चलते हैं।

SMP

इस मानक को लागू करने के लिए, मदरबोर्ड पर नई योजनाएं शुरू की गईं: APIC और ACPI। पहले बात करते हैं।

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

स्थानीय APIC और IO APIC

APIC- आधारित प्रणाली में, प्रत्येक प्रोसेसर में एक "कोर" और एक "स्थानीय APIC" होता है। प्रोसेसर-विशिष्ट व्यवधान कॉन्फ़िगरेशन को संभालने के लिए स्थानीय APIC जिम्मेदार है। अन्य बातों के अलावा, इसमें एक स्थानीय वेक्टर टेबल (LVT) है, जो घटनाओं का अनुवाद करता है, जैसे कि "आंतरिक घड़ी" और रुकावट के अन्य "स्थानीय" स्रोत, एक बाधा वेक्टर में (उदाहरण के लिए, संपर्क LocalINT1 एक NMI अपवाद बढ़ा सकता है, संरक्षण) 2 "इसी LVT इनपुट के लिए)।

स्थानीय एपीआईसी के बारे में अधिक जानकारी आधुनिक इंटेल प्रोसेसर के "सिस्टम प्रोग्रामिंग गाइड" में पाई जा सकती है।

इसके अलावा, एक एपीआईसी आईओ है (उदाहरण के लिए, इंटेल 82093AA), जो चिपसेट का हिस्सा है और सभी प्रोसेसर के लिए इंटरप्ट के स्थिर और गतिशील सममित वितरण सहित मल्टी-प्रोसेसर इंटरप्ट कंट्रोल प्रदान करता है। मल्टीपल I / O सबसिस्टम वाले सिस्टम पर, प्रत्येक सबसिस्टम में इंटरप्ट का अपना सेट हो सकता है।

प्रत्येक रुकावट पिन को व्यक्तिगत रूप से किनारे या स्तर के रूप में क्रमादेशित किया जाता है। इंटरप्ट वेक्टर और इंटरप्ट कंट्रोल की जानकारी प्रत्येक इंटरप्ट के लिए निर्दिष्ट की जा सकती है। अप्रत्यक्ष रजिस्टर एक्सेस योजना आंतरिक APIC I / O रजिस्टरों तक पहुंचने के लिए आवश्यक मेमोरी स्पेस को अनुकूलित करती है। मेमोरी स्पेस आवंटित करते समय सिस्टम फ्लेक्सिबिलिटी बढ़ाने के लिए, दो APIC I / O रजिस्टर रीकोसेबल हैं, लेकिन डिफ़ॉल्ट 0xF0000000000 है।

एक "स्थानीय" APIC की शुरुआत

स्थानीय APIC बूट समय पर सक्रिय होता है और इसे बिट 11 IA32_APIC_BASE (MSR) को रीसेट करके निष्क्रिय किया जा सकता है (यह केवल परिवार के साथ प्रोसेसर के साथ काम करता है> 5, चूंकि पेंटियम में ऐसा MSR नहीं है), फिर प्रोसेसर संगत 8259 PIC से सीधे अपने इंटरप्ट को प्राप्त करता है । हालाँकि, Intel का सॉफ़्टवेयर डेवलपमेंट गाइड बताता है कि IA32_APIC_BASE के माध्यम से स्थानीय APIC को अक्षम करने के बाद, आप इसे तब तक चालू नहीं कर पाएंगे, जब तक कि यह पूरी तरह से रीसेट न हो जाए। एपीओ आईओ को विरासत मोड में संचालित करने के लिए भी कॉन्फ़िगर किया जा सकता है ताकि यह 8259 डिवाइस का अनुकरण करे।

स्थानीय APIC को भौतिक पृष्ठ FEE00xxx (तालिका 8-1 इंटेल P4 SPG देखें) में मैप किया जाता है। यह पता प्रत्येक स्थानीय APIC के लिए समान है जो कॉन्फ़िगरेशन में मौजूद है, जिसका अर्थ है कि आप सीधे स्थानीय APIC कर्नेल के रजिस्टरों तक पहुंच सकते हैं जिसमें आपका कोड वर्तमान में चल रहा है। ध्यान दें कि एक MSR है जो वास्तविक APIC आधार को परिभाषित करता है (केवल परिवार के साथ प्रोसेसर के लिए उपलब्ध> 5)। MADT में एक स्थानीय APIC आधार होता है, और 64-बिट सिस्टम पर यह आधार पते के 64-बिट पुनर्वितरण को परिभाषित करने वाला एक क्षेत्र भी हो सकता है, जिसे आपको इसके बजाय उपयोग करना चाहिए। आप स्थानीय APIC आधार को केवल वहीं छोड़ सकते हैं जहाँ आप इसे पाते हैं, या जहाँ चाहें इसे स्थानांतरित कर सकते हैं। नोट: मुझे नहीं लगता कि आप इसे 4 जीबी रैम से आगे बढ़ा सकते हैं।

इंटरप्ट प्राप्त करने के लिए स्थानीय APIC को सक्षम करने के लिए, आपको Spurious Interrupt वेक्टर रजिस्टर को कॉन्फ़िगर करना होगा। इस फ़ील्ड के लिए सही मान IRQ नंबर है जिसे आप निचले 8 बिट्स के साथ झूठे व्यवधान के लिए मैप करना चाहते हैं, और 8 वीं बिट 1 से वास्तव में APIC को सक्षम करने के लिए सेट है (अधिक जानकारी के लिए विनिर्देश देखें)। आपको एक बाधा संख्या का चयन करना होगा जिसमें कम 4 बिट्स सेट हों; सबसे आसान तरीका 0xFF का उपयोग करना है। यह कुछ पुराने प्रोसेसर के लिए महत्वपूर्ण है, क्योंकि इन मूल्यों के लिए निचले 4 बिट्स को 1 पर सेट किया जाना चाहिए।

8259 PIC को सही ढंग से अक्षम करें। यह लगभग उतना ही महत्वपूर्ण है जितना कि APIC को कॉन्फ़िगर करना। आप इसे दो चरणों में करते हैं: सभी व्यवधानों को मास्क करना और IRQ को पुन: असाइन करना। सभी व्यवधानों को खारिज करते हुए उन्हें पीआईसी में निष्क्रिय कर देता है। रीमैपिंग रुकावट वह है जो आपने शायद पहले से ही किया था जब आपने PIC का उपयोग किया था: आप अपवादों के साथ संघर्ष से बचने के लिए 0 के बजाय 32 पर शुरू करने के लिए अवरोध अनुरोध चाहते हैं (संरक्षित और लंबे (लंबे) प्रोसेसर मोड में, क्योंकि पहले 32 व्यवधान अपवाद हैं)। फिर आपको अन्य प्रयोजनों के लिए इन रुकावट वैक्टर का उपयोग करने से बचना चाहिए। यह आवश्यक है क्योंकि, इस तथ्य के बावजूद कि आपने सभी PIC इंटरप्ट को मास्क किया है, फिर भी यह गलत इंटरप्रिट्स को फेंक सकता है, जिसे तब आपके कर्नेल में अपवाद के रूप में गलत तरीके से संसाधित किया जाएगा।
SMP पर चलते हैं।

सिमेट्रिक मल्टीटास्किंग: इनिशियलाइज़ेशन

विभिन्न सीपीयू के लिए स्टार्टअप क्रम अलग-अलग होता है। इंटेल प्रोग्रामर गाइड (धारा 7.5.4) में इंटेल एक्सॉन प्रोसेसर के लिए एक इनिशियलाइज़ेशन प्रोटोकॉल होता है और पुराने प्रोसेसर को कवर नहीं करता है। सामान्य "सभी प्रोसेसर प्रकार" एल्गोरिथ्म के लिए, इंटेल मल्टीप्रोसेसर विशिष्टता देखें।

80486 के लिए (बाहरी APIC 8249DX के साथ) आपको IPIT INIT के बाद IPI “INIT स्तर de-assert” का उपयोग बिना किसी SIPI के करना होगा। इसका अर्थ है कि आप उन्हें यह नहीं बता सकते हैं कि अपना कोड (SIPI का सदिश भाग) निष्पादित करना कहाँ से शुरू करें, और वे हमेशा BIOS कोड निष्पादित करना शुरू करते हैं। इस स्थिति में, आप CMOS BIOS रीसेट मान को "दूर की छलांग के साथ गर्म शुरुआत" (यानी, CMOS स्थिति 0x0F को 10 पर सेट करें) ताकि BIOS दूर तक jmp करता है ~ [0: 0x0469], और सेगमेंट और ऑफसेट सेट करें एपी प्रवेश बिंदु 0x0469 पर।

"INIT स्तर डी-एसेटर" IPI नए प्रोसेसर (Pentium 4 और Intel Xeon) पर समर्थित नहीं है, और AFAIK इन प्रोसेसर पर पूरी तरह से नजरअंदाज कर दिया गया है।

नए प्रोसेसर (पी 6, पेंटियम 4) के लिए, एक एसआईपीआई पर्याप्त है, लेकिन मुझे यकीन नहीं है कि पुराने इंटेल प्रोसेसर (पेंटियम) या अन्य निर्माताओं के प्रोसेसर को दूसरे एसआईपीआई की आवश्यकता होती है। यह भी संभव है कि पहले SIPI (बस शोर, आदि) के लिए वितरण विफलता की स्थिति में एक दूसरा SIPI मौजूद हो।

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

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

MT तालिका का उपयोग करके जानकारी की तलाश में

मल्टीप्रोसेसिंग के लिए कुछ जानकारी (जो नई मशीनों पर उपलब्ध नहीं हो सकती है)। सबसे पहले आपको एमपी फ्लोटिंग पॉइंटर स्ट्रक्चर ढूंढना होगा। यह 16-बाइट सीमा पर संरेखित है और इसमें "_MP_" या 0x5F504D5F की शुरुआत में एक हस्ताक्षर है। OS को EBDA, BIOS ROM स्थान और "किल मेमोरी" के अंतिम किलोबाइट में देखना चाहिए; बेस मेमोरी का आकार किलोबाइट्स में 0x413 के 2-बाइट मान, माइनस 1 केबी में निर्दिष्ट है। यह संरचना कैसी दिखती है:

struct mp_floating_pointer_structure { char signature[4]; uint32_t configuration_table; uint8_t length; // In 16 bytes (eg 1 = 16 bytes, 2 = 32 bytes) uint8_t mp_specification_revision; uint8_t checksum; // This value should make all bytes in the table equal 0 when added together uint8_t default_configuration; // If this is not zero then configuration_table should be // ignored and a default configuration should be loaded instead uint32_t features; // If bit 7 is then the IMCR is present and PIC mode is being used, otherwise // virtual wire mode is; all other bits are reserved }

यहाँ विन्यास तालिका इस तरह दिखती है कि सूचक की अस्थायी संरचना इस ओर इशारा करती है:

 struct mp_configuration_table { char signature[4]; // "PCMP" uint16_t length; uint8_t mp_specification_revision; uint8_t checksum; // Again, the byte should be all bytes in the table add up to 0 char oem_id[8]; char product_id[12]; uint32_t oem_table; uint16_t oem_table_size; uint16_t entry_count; // This value represents how many entries are following this table uint32_t lapic_address; // This is the memory mapped address of the local APICs uint16_t extended_table_length; uint8_t extended_table_checksum; uint8_t reserved; }

कॉन्फ़िगरेशन तालिका के बाद प्रविष्टियाँ हैं entry_count, जिसमें सिस्टम के बारे में अधिक जानकारी होती है, उसके बाद एक विस्तारित तालिका होती है। प्रविष्टियाँ प्रोसेसर का प्रतिनिधित्व करने के लिए या तो 20 बाइट्स हैं, या किसी और चीज़ के लिए 8 बाइट्स। यहाँ APIC प्रोसेसर और I / O रिकॉर्ड कैसा दिखता है।

 struct entry_processor { uint8_t type; // Always 0 uint8_t local_apic_id; uint8_t local_apic_version; uint8_t flags; // If bit 0 is clear then the processor must be ignored // If bit 1 is set then the processor is the bootstrap processor uint32_t signature; uint32_t feature_flags; uint64_t reserved; }

यहाँ IO APIC प्रविष्टि है।

 struct entry_io_apic { uint8_t type; // Always 2 uint8_t id; uint8_t version; uint8_t flags; // If bit 0 is set then the entry should be ignored uint32_t address; // The memory mapped address of the IO APIC is memory }

APIC के साथ जानकारी की तलाश में

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

एपी लॉन्च करें

आपके द्वारा जानकारी एकत्र करने के बाद, आपको PIC को अक्षम करना होगा और APIC I / O की तैयारी करनी होगी। आपको स्थानीय APIC के BSP को भी कॉन्फ़िगर करना होगा। फिर एसआईपीआई का उपयोग करके एपी शुरू करें।

गुठली चलाने के लिए कोड:

मैं ध्यान देता हूं कि आप जिस वेक्टर को स्टार्टअप पर निर्दिष्ट करते हैं, वह प्रारंभिक पता दर्शाता है: वेक्टर 0x8 - पता 0x8000, वेक्टर 0x9 - पता 0x9000, आदि।

 // ------------------------------------------------------------------------------------------------ static u32 LocalApicIn(uint reg) { return MmioRead32(*g_localApicAddr + reg); } // ------------------------------------------------------------------------------------------------ static void LocalApicOut(uint reg, u32 data) { MmioWrite32(*g_localApicAddr + reg, data); } // ------------------------------------------------------------------------------------------------ void LocalApicInit() { // Clear task priority to enable all interrupts LocalApicOut(LAPIC_TPR, 0); // Logical Destination Mode LocalApicOut(LAPIC_DFR, 0xffffffff); // Flat mode LocalApicOut(LAPIC_LDR, 0x01000000); // All cpus use logical id 1 // Configure Spurious Interrupt Vector Register LocalApicOut(LAPIC_SVR, 0x100 | 0xff); } // ------------------------------------------------------------------------------------------------ uint LocalApicGetId() { return LocalApicIn(LAPIC_ID) >> 24; } // ------------------------------------------------------------------------------------------------ void LocalApicSendInit(uint apic_id) { LocalApicOut(LAPIC_ICRHI, apic_id << ICR_DESTINATION_SHIFT); LocalApicOut(LAPIC_ICRLO, ICR_INIT | ICR_PHYSICAL | ICR_ASSERT | ICR_EDGE | ICR_NO_SHORTHAND); while (LocalApicIn(LAPIC_ICRLO) & ICR_SEND_PENDING) ; } // ------------------------------------------------------------------------------------------------ void LocalApicSendStartup(uint apic_id, uint vector) { LocalApicOut(LAPIC_ICRHI, apic_id << ICR_DESTINATION_SHIFT); LocalApicOut(LAPIC_ICRLO, vector | ICR_STARTUP | ICR_PHYSICAL | ICR_ASSERT | ICR_EDGE | ICR_NO_SHORTHAND); while (LocalApicIn(LAPIC_ICRLO) & ICR_SEND_PENDING) ; } void SmpInit() { kprintf("Waking up all CPUs\n"); *g_activeCpuCount = 1; uint localId = LocalApicGetId(); // Send Init to all cpus except self for (uint i = 0; i < g_acpiCpuCount; ++i) { uint apicId = g_acpiCpuIds[i]; if (apicId != localId) { LocalApicSendInit(apicId); } } // wait PitWait(200); // Send Startup to all cpus except self for (uint i = 0; i < g_acpiCpuCount; ++i) { uint apicId = g_acpiCpuIds[i]; if (apicId != localId) LocalApicSendStartup(apicId, 0x8); } // Wait for all cpus to be active PitWait(10); while (*g_activeCpuCount != g_acpiCpuCount) { kprintf("Waiting... %d\n", *g_activeCpuCount); PitWait(10); } kprintf("All CPUs activated\n"); }

 [org 0x8000] AP: jmp short bsp ;     -   BSP xor ax,ax mov ss,ax mov sp, 0x7c00 xor ax,ax mov ds,ax ; Mark CPU as active lock inc byte [ds:g_activeCpuCount] ;   ,   jmp zop bsp: xor ax,ax mov ds,ax mov dword[ds:g_activeCpuCount],0 mov dword[ds:g_activeCpuCount],0 mov word [ds:0x8000], 0x9090 ;  JMP   2 NOP' ;   ,

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

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

सौभाग्य है

सीपीयू कोर या एसएमपी क्या है और यह क्या खाता है