ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 4. समानांतर कंप्यूटिंग

लंबे ब्रेक के बाद, हम दिलचस्प चीजें करना जारी रखते हैं, जैसा कि हमेशा ऑपरेटिंग सिस्टम के बिना शुद्ध हार्डवेयर पर होता है। लेख के इस भाग में, हम सीखेंगे कि प्रोसेसर की पूरी क्षमता का उपयोग कैसे करें: हम पूरी तरह से समानांतर मोड में एक बार में कई प्रोसेसर कोर पर कार्यक्रम चलाएंगे। ऐसा करने के लिए, हमें भाग 3 में प्राप्त कार्यक्रम की कार्यक्षमता का विस्तार करने के लिए बहुत कुछ करने की आवश्यकता है।

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

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



जाहिर है, सॉकेट्स केवल एक ही मदरबोर्ड पर कुछ स्थापित प्रोसेसर हैं। नीचे कुछ और चित्र दिए गए हैं, स्पष्टता के लिए।





इस सब के बीच, सबसे दिलचस्प तार्किक कोर की उपस्थिति है। यह SMT के सिद्धांत को प्रदर्शित करता है (Simultaneous Multithreading), जिसका अर्थ है, वास्तव में, किसी अन्य लॉजिकल थ्रेड से अगले निर्देशों को निष्पादित करना, जबकि प्रोसेसर भागों को मुक्त किया जाता है, मुख्य थ्रेड से निर्देशों के पूरा होने की प्रतीक्षा करता है। प्रोसेसर के प्रत्येक भौतिक कोर में कई घटक होते हैं (कैश, पाइपलाइन, ALU, FPU, ...), कई भाग एक-दूसरे से स्वतंत्र रूप से काम करते हैं और उन्हें सिंक्रनाइज़ करने की आवश्यकता होती है, इसलिए जब अनुदेश निष्पादन समाप्त होने से पहले कैश या मेमोरी से डेटा की प्रतीक्षा कर रहे हों, तो दूसरों को निष्पादित क्यों नहीं करें उसी निर्देश का उपयोग करके दूसरे थ्रेड से निर्देश? अधिक जानकारी और चित्र इस लिंक पर या इंटेल, एएमडी, एआरएम के आधिकारिक दस्तावेजों में पाए जा सकते हैं।

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

हम कुछ और अवधारणाएँ प्रस्तुत करते हैं:

एसएमपी (सिमेट्रिक मल्टीप्रोसेसिंग) - सभी प्रोसेसर के सममित उपयोग का मतलब है; उदाहरण के लिए, सभी प्रोसेसर कोर पूर्ण रूप से एक ही रैम का उपयोग कर सकते हैं, सभी प्रोसेसर कोर समान हैं और समान व्यवहार करते हैं।

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

NUMA (नॉन-यूनिफ़ॉर्म मेमोरी एक्सेस) - मेमोरी के विभिन्न क्षेत्रों में असमान प्रोसेसर पहुँच। वास्तव में, इसका मतलब है कि प्रत्येक प्रोसेसर कोर सभी मेमोरी तक पहुंच सकता है, लेकिन प्रत्येक कोर के लिए एक मेमोरी क्षेत्र है जो इसे बाकी की तुलना में तेजी से एक्सेस करता है। फिर से अनुकूलन के लिए इस्तेमाल किया।

आधुनिक कंप्यूटर सिस्टम में ये सभी सिद्धांत और प्रौद्योगिकियां हैं।

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

हमारे लक्ष्य को प्राप्त करने के लिए, आपको कई सवालों के जवाब देने की आवश्यकता है:

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

विशिष्ट प्रोसेसर कोर की पहचान कैसे करें?
इसके लिए, APIC डिवाइस, या LAPIC, जो सिस्टम में प्रत्येक प्रोसेसर कोर है, के पास सिस्टम के लिए एक विशिष्ट पहचानकर्ता है (जैसे प्रक्रियाओं के लिए PID), और एक विशिष्ट प्रोसेसर कोर में व्यवधान पहुंचाने के लिए जिम्मेदार है।

एक कोर दूसरे कोर से कैसे शुरू करें?
यह एक प्रोसेसर कोर से दूसरे में एक बाधा भेजने के लिए पर्याप्त है। इस सिग्नल को IPI (इंटर प्रोसेसर इंटरप्ट) कहा जाता है। इसे भेजने के लिए, यह कोर में से एक पर एक LAPIC डिवाइस का उपयोग करने के लिए पर्याप्त है, इसके रजिस्टर में एक निश्चित मूल्य लिख रहा है।

प्रोसेसर कोर के निष्पादन को कैसे रोकें?
इस कर्नेल पर HLT निर्देश को लागू करने के लिए पर्याप्त है।

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



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



पहली नज़र में, यह जटिल लग रहा है, लेकिन अगर आप इसका पता लगाते हैं, तो सब कुछ काफी उचित है: PIC - एक लंबे समय के लिए उपयोग किया गया है जो बाधा नियंत्रक - रहता है और दूर नहीं गया है, यह अभी भी मदरबोर्ड पर चिपसेट का हिस्सा है। मल्टी-कोर के आगमन के साथ, उन्होंने IO APIC को जोड़ा, जो अब कर्नेल के बीच PIC और अन्य स्रोतों से व्यवधान वितरित करता है, क्योंकि किसी को ऐसा करने की आवश्यकता होती है। प्रत्येक LAPIC IPI और IO APIC कॉन्फ़िगरेशन में उपयोग होने वाले विशिष्ट पहचानकर्ता से सुसज्जित है। इसके अलावा LAPIC संख्या में इसकी टोपोलॉजी एन्कोडेड है। बीएसपी के पास हमेशा 0 की पहचान करने वाला LAPIC होता है।
LAPIC को प्रोग्राम करने के लिए, आपको इसके रजिस्टरों (जैसे किसी भी अन्य डिवाइस के साथ) को डेटा पढ़ने और लिखने की जरूरत है, इसके रजिस्टर 0xFEE00000 पर मेमोरी में स्थित हैं। वास्तव में, यह पता अलग हो सकता है, लेकिन यह हमेशा एक विशेष MSR (मॉडल विशिष्ट रजिस्टर - इन रजिस्टरों को rdmsr / wrmsr निर्देशों के माध्यम से पढ़ा और लिखा जाता है) के माध्यम से पता लगाया जा सकता है। सभी कोर के लिए, यह पता अक्सर एक ही होता है, लेकिन इस पते पर प्रत्येक कोर का अपना व्यक्तिगत LAPIC होता है। इस उपकरण में कई रजिस्टर हैं, लेकिन हमें केवल एक - ICR (इंटरप्ट कंट्रोल रजिस्टर) की आवश्यकता है जो आपको IPI भेजने की अनुमति देता है।
प्रोसेसर कोर शुरू करने के लिए, तीन आईपीआई इस कोर को भेजे जाने चाहिए, जो दूसरे कोर को चालू करने के लिए मजबूर करेगा: INIT IPI, फिर STARTUP IPI, और एक और STARTUP IPI। दूसरा STARTUP IPI (या SIPI) प्रारंभिक प्रक्रिया को पूरा करने के लिए आवश्यक है, क्योंकि पहले। रद्द किया जाए, और पहला SIPI सफल होने पर दूसरे को अनदेखा कर दिया जाएगा। ऐसा करने के लिए कुछ भी नहीं है - ऐसे नियम। प्रत्येक IPI को भेजने के लिए, आपको बस अपने LAPIC के ICR रजिस्टर में कुछ बाइट्स लिखने होंगे। इन बाइट्स में LAPIC का बाइट जिसमें IPI भेजा जाता है, और भेजने के लिए IPI का प्रकार शामिल होगा। SIPI के लिए, 2 और बाइट्स का उपयोग किया जाएगा, जिसमें से मेमोरी जिसमें से एपी लॉन्च किया जाएगा, पता निर्धारित किया जाएगा।
उत्तरार्द्ध बहुत सुविधाजनक है, क्योंकि हमें प्रोसेसर को पहले हमारे कोड से शुरू करने की आवश्यकता है, जो प्रोसेसर को संरक्षित मोड में स्थानांतरित कर देगा (हां, INIT-SIPI-SIPI के बाद प्रोसेसर रियल मोड में शुरू होता है, जो हमें सूट नहीं करता है)। प्रोसेसर इनिशियलाइज़ेशन कोड पर बाद में विस्तार से चर्चा की जाएगी। हां, हम कच्चे असेंबलर के बिना नहीं कर सकते।
आप इंटेल प्रोसेसर मैनुअल में LAPIC और IO APIC के बारे में अधिक पढ़ सकते हैं।

अब यह कुछ छोटी चीजों से निपटने के लिए बना हुआ है: लॉक , एफपीयू और रे ट्रेसिंग एल्गोरिदम खुद (पेलोड)।

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

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

हम रे ट्रेसिंग कैसे करेंगे? यह एल्गोरिथम इस लेख के दायरे से परे है, इसलिए इसे यहां नहीं समझाया जाएगा, लेकिन इसके बारे में कई अच्छे लेख हैं । हमारे मामले के लिए, हम बस तैयार कार्यक्रम लेते हैं और इसे थोड़ा संशोधित करते हैं।

अब यह सिद्धांत समाप्त हो गया है, चलो एक कार्यक्रम लिखना शुरू करते हैं।

! महत्वपूर्ण!: लेख के तीसरे भाग से सभी 6 चरणों को सफलतापूर्वक पूरा करने के बाद ही सभी कार्यों को सफलतापूर्वक पूरा किया जा सकता है "ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं"

चरण 1. सबसे पहले, अतिरिक्त को साफ करें।

सबसे पहले, आपको अनावश्यक फ़ाइलों और कार्यों से मौजूदा कोड को थोड़ा स्पष्ट करने की आवश्यकता है। हमें एक पूर्ण गणितीय पुस्तकालय की आवश्यकता होगी, इसलिए हमें अतिरिक्त फ़ाइलों को सामान्य से हटाने की आवश्यकता है: फ़ाइल को सामान्य / s_floor.c हटाएं ।
हमें भग्न खींचने की आवश्यकता नहीं है - हमें रे ट्रेसिंग की आवश्यकता है, इसलिए हम भग्न को हटा सकते हैं। लेकिन चूंकि ग्राफिक मोड अभी भी आवश्यक है, इसलिए हम कर्नेल में निम्नलिखित कोड लिखते हैं:
1. मुख्य फ़ंक्शन के सामने कुछ घोषणाएं जोड़ें, जो अन्य बातों के अलावा, स्क्रीन रिज़ॉल्यूशन और उस छवि को सेट करें जिसे हम प्रस्तुत करेंगे:
मैं

nt vbe_screen_w = 800, vbe_screen_h = 600; int VBE_SetMode( ulong mode ); int VBE_Setup(int w, int h); extern ulong vbe_lfb_addr; extern ulong vbe_selected_mode; extern ulong vbe_bytes; //     int ray_main(); void SmpPrepare(void); 

2. मुख्य कार्य बदलें:

 void main() { clear_screen(); printf("\n>>> Hello World!\n"); //      SmpPrepare(); VBE_Setup(vbe_screen_w, vbe_screen_h); VBE_SetMode(vbe_selected_mode | 0x4000); //      ray_main(); } 

3. लाइन को हटा दें:

 void DrawFractal(void); 

चरण 2. गणित पुस्तकालय fdlibm जोड़ें।

अब आप एक पूर्ण गणितीय पुस्तकालय जोड़ सकते हैं। वास्तव में, हमें केवल sqrt, tan और pow फ़ंक्शन की आवश्यकता है - इनका उपयोग Ray Tracing एल्गोरिथम में किया जाता है।

1. रूट डायरेक्टरी fdlibm बनाएं ।
2. इस निर्देशिका में हम यहाँ से fdlibm लाइब्रेरी डाउनलोड करते हैं । आपको इस फ़ोल्डर से सभी फ़ाइलों को अपलोड करने की आवश्यकता है।
3. अब आपको एक सरल (एक ही समय में आप फ़ाइलों की सूची की जांच कर सकते हैं) के साथ मेकफाइल को बदलने की आवश्यकता है। संकलन के दौरान, मूल में मूल झंडे के रूप में समान झंडे का उपयोग किया जाएगा। यह एक साधारण पुस्तकालय fdlibm.a संकलित करेगा । नए मेकफाइल की सामग्री:

 CC = gcc CFLAGS = -Wall -fno-builtin -nostdinc -nostdlib -ggdb3 LD = ld OBJFILES = \ e_acos.o e_acosh.o e_asin.o e_atan2.o e_atanh.o e_cosh.o e_exp.o \ e_fmod.o e_gamma.o e_gamma_r.o e_hypot.o e_j0.o e_j1.o e_jn.o \ e_lgamma.o e_lgamma_r.o e_log.o e_log10.o e_pow.o e_remainder.o \ e_rem_pio2.o e_scalb.o e_sinh.o e_sqrt.o \ k_cos.o k_rem_pio2.o k_sin.o k_tan.o \ s_asinh.o s_atan.o s_cbrt.o s_ceil.o s_copysign.o s_cos.o s_erf.o s_expm1.o \ s_fabs.o s_finite.o s_floor.o s_frexp.o s_ilogb.o s_isnan.o s_ldexp.o s_lib_version.o \ s_log1p.o s_logb.o s_matherr.o s_modf.o s_nextafter.o s_rint.o s_scalbn.o s_signgam.o \ s_significand.o s_sin.o s_tan.o s_tanh.o \ w_acos.o w_acosh.o w_asin.o w_atan2.o w_atanh.o w_cosh.o w_exp.o w_fmod.o w_gamma.o \ w_gamma_r.o w_hypot.o w_j0.o w_j1.o w_jn.o w_lgamma.o w_lgamma_r.o w_log.o \ w_log10.o w_pow.o w_remainder.o w_scalb.o w_sinh.o w_sqrt.o k_standard.o all: fdlibm.a rebuild: clean all .so: as -o $@ $< .co: $(CC) -Ix86emu –I../include $(CFLAGS) -o $@ -c $< .cpp.o: $(CC) -Ix86emu -I. -Iustl –I../include $(CFLAGS) -o $@ -c $< fdlibm.a: $(OBJFILES) ar -rv fdlibm.a $(OBJFILES) ranlib fdlibm.a clean: rm -f $(OBJFILES) fdlibm.a 

4. सब कुछ इकट्ठा करने के लिए, हम k_standard.c में बदलाव करेंगे । हमें एक गलत फंक्शन की घोषणा करने और एक खाली फंक्शन की परिभाषा देने की जरूरत है, जो बिना फाइल सिस्टम और ग्राफिक डिस्प्ले के हमारे मामले में मायने नहीं रखता। ऐसा करने के लिए, लाइनों को प्रतिस्थापित करें:

 #ifndef _USE_WRITE #include <stdio.h> /* fputs(), stderr */ #define WRITE2(u,v) fputs(u, stderr) #else /* !defined(_USE_WRITE) */ 

प्रति पंक्ति:

 void fputs(void *u, int stderr) { } int errno = 0; #ifndef _USE_WRITE #define WRITE2(u,v) fputs(u, 0) #else /* !defined(_USE_WRITE) */ 

चरण 3. आवश्यक परिभाषाएं और हेडर जोड़ें

हमेशा की तरह, आपको उन परिभाषाओं को थोड़ा विस्तारित करने की आवश्यकता है जो कार्यक्रम में बाद में उपयोग की जाएंगी।
1. इस बार C ++ का उपयोग टेम्प्लेट के साथ भी किया जाएगा, इसलिए, कई त्रुटियों से बचने के लिए, आपको शामिल / स्ट्रिंग .h फ़ाइल को ठीक करने की आवश्यकता है। इसमें, आपको उन सभी स्थानों पर एक स्पष्ट प्रकार का रूपांतरण जोड़ना होगा जहाँ शून्य * को char * में परिवर्तित किया गया है। मुझे यह पंक्ति मिली: 42, 53,54,79,80। हर जगह एक समान परिवर्तन, उदाहरण के लिए, सही रेखा 42 इस तरह दिखती है:
p = (char *) addr;
2. आपको गणित पुस्तकालय के लिए कुछ परिभाषाएँ जोड़ने की आवश्यकता है। इनमें कई वैश्विक चर परिभाषाएं, कई प्रकार, कई स्थिरांक, और त्रुटि कोड शामिल हैं जो fdlibm का उपयोग करता है। परिणामस्वरूप, हम शामिल करने के लिए निम्नलिखित कोड जोड़ते हैं / type.h (फ़ाइल के अंत में अंतिम #endif से पहले):

 typedef unsigned long long u64; #define FLT_MAX 1E+37 #define DBL_MAX 1E+37 #define LDBL_MAX 1E+37 # ifndef INFINITY # define INFINITY (__builtin_inff()) # endif #define NUM 3 #define NAN 2 #define INF 1 #define M_PI 3.14159265358979323846 /* pi */ #define __PI 3.14159265358979323846 #define __SQRT_HALF 0.70710678118654752440 #define __PI_OVER_TWO 1.57079632679489661923132 typedef const union { long l[2]; double d; } udouble; typedef const union { long l; float f; } ufloat; extern double BIGX; extern double SMALLX; 

3. फ़ाइल को शामिल करें / निम्नलिखित कोड के साथ ग़लती करें:

 #ifndef _ERRNO_H #define _ERRNO_H extern int errno; #define EDOM -6 #define ERANGE -8 #endif 

4. अब, आपको हार्डवेयर, एसएमपी, एसीपीआई, एलएपीआईसी सेटिंग्स और विशेष प्रोसेसर रजिस्टरों को स्थापित करने के कार्यों से संबंधित कई परिभाषाओं को जोड़ना होगा। ऐसा करने के लिए, एक शामिल / हार्डवेयर.h फ़ाइल बनाएं जिसमें हम निम्नलिखित कोड जोड़ते हैं। इस बार हमने जीथब पर तैयार कोड के साथ दो फाइलें पोस्ट कीं। यह इस तथ्य के कारण है कि कोड अपेक्षाकृत बड़ी (~ 500 लाइनें) निकला, इसलिए इसे लेख के ढांचे के भीतर लिखना असुविधाजनक है। हम इस बात पर जोर देते हैं कि कोड रूसी में बड़ी संख्या में टिप्पणियों से लैस है, इसलिए जीथब पर कोड को लेख की निरंतरता माना जा सकता है। पैराग्राफ में ही, हम फाइल की सामग्री प्रस्तुत करते हैं:

एक। ACPI तालिकाओं को पार्स करने के लिए प्रयुक्त संरचनाओं की परिभाषाएँ। यह कोड आधिकारिक ACPI विनिर्देश पर आधारित है। कोड में हमारे लिए आवश्यक तालिकाओं (RSDP, RSDT, MADT) की केवल परिभाषाएँ हैं।

ख। फ़ाइल में आगे कई इनलाइन फ़ंक्शंस की घोषणा है जिसमें कोडांतरक निर्देश हैं। अधिकांश भाग के लिए, फ़ंक्शन बहुत छोटे हैं, हालांकि वे gcc में कोडांतरक का उपयोग करने की ख़ासियत के कारण भारी दिखते हैं, जहां एक विशिष्ट डिजाइन इस तरह दिखता है: __asm__ __volatile__ ("<निर्देश>": <आउटपुट पैरामीटर>: <इनपुट पैरामीटर>); नाम से इन कार्यों के कोड को इंटरनेट पर अलग-अलग स्थानों पर पाया जा सकता है, दोनों फ्रीबीएसडी, लिनक्स और बिटविसर जैसी परियोजनाओं में। हम निम्नलिखित कार्यों को समझेंगे: rdtsc, __rdmsr, __rdmsrl, __wrmsr, __wrmsrl, __rep_nop और __cpuid_count, __get -cr0, __set_cr0।

सी। मैं विशेष रूप से दो कार्यों को उजागर करना चाहता हूं जिन्हें हमने SmpSpinlock_LOCK और SmpSpinlock_UNLOCK कहा है। दोनों कार्य orangetide.com/src/bitvisor-1.3/include/core/spinlock.h से लिए गए हैं और कोडांतरक में भी लिखे गए हैं। वे एक साथ काम करने वाले प्रोसेसर कोर के लिए सिंक्रनाइज़ेशन ऑब्जेक्ट के साथ काम करने के लिए कार्यों का प्रतिनिधित्व करते हैं। ये साधारण ताले हैं। उनके काम का सार सरल है: स्मृति में एक बाइट का उपयोग लॉक के रूप में किया जाता है, जो मान 0 या 1. ले सकता है, यदि 0 है, तो लॉक खुला है, और यदि 1, तो यह बंद है। SmpSpinlock_LOCK फ़ंक्शन का सार लॉक के बाइट में मान 0 के लिए प्रतीक्षा करना और इस बाइट को 1 पर सेट करना है। प्रतीक्षा करने के लिए, हम "पॉज़" निर्देश का उपयोग करके सामान्य चक्र का उपयोग करते हैं, जो हमें प्रोसेसर को अनुकूलित करने और प्रतीक्षा चक्र के दौरान इसकी बिजली की खपत को कम करने की अनुमति देता है। पढ़ने और एक साथ मूल्य 1 को मेमोरी के बाइट्स पर सेट करने के लिए, "xchg" निर्देश का उपयोग किया जाता है, जो मेमोरी और रजिस्टर के बीच परमाणु विनिमय की अनुमति देता है। एटोमिसिटी का मतलब है कि एक और प्रोसेसर कोर इस निर्देश के संचालन को बाधित नहीं कर पाएगा और इसके संचालन के बीच में ही अपना बचाव करेगा।

घ। हार्डवेयर। h कोड आगे LAPIC से संबंधित कई स्थिरांक का वर्णन करता है। उन्हें इंटेल डॉक्यूमेंटेशन से लिया गया है।

ई। फ़ाइल के अंत में, एक और __enable_fpu कोडांतरक फ़ंक्शन घोषित किया जाता है, जो प्रोसेसर पर FPU को सक्षम करता है। याद रखें कि फ्लोट प्रकार के साथ काम करने के लिए यह आवश्यक है। फ़ंक्शन दो निर्देशों का निष्पादन है: "fnclex" और "fninit", जो कर्नेल पर FPU को सक्षम करने के लिए आवश्यक हैं।

चरण 4. प्रोसेसर कोर इनिशियलाइज़ेशन कोड जोड़ें।

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

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

• एक। CPU के उपयोग से LAPIC की जाँच करें।
• ख। MSR के माध्यम से आधार LAPIC पता प्राप्त करना।
• सी। 64-बिट ICR रजिस्टर के दो भागों की ओर संकेत मिलता है। ये स्मृति में एक विशिष्ट क्षेत्र के लिए साधारण संकेत हैं। उनका उपयोग आईपीआई भेजने के लिए किया जाएगा।
• घ। फिर RSDP पता खोजा जाता है। यह TSDT तालिका का पता निर्धारित करता है। RSDT तालिका में MADT पर पता है। पूरे एमएडीटी तालिका को स्कैन किया जाता है और इसमें स्थानीय एपीआईसी से संबंधित सभी प्रविष्टियों का विश्लेषण किया जाता है। प्रत्येक प्रविष्टि में एक LAPIC ID और एक कर्नेल सक्षम ध्वज होता है। नतीजतन, सभी की एक सरणी मिली और इसमें शामिल LAPIC आईडी शामिल हैं जो सिस्टम में हैं।
• ई। अगला चरण प्रत्येक प्रोसेसर कोर के पसीने के ढेर पर मेमोरी आरक्षित करना है। स्टैक 64Kb पर आवंटित किया गया है और यह भौतिक मेमोरी के 5 वें मेगाबाइट से शुरू होता है।
• च। फिर, कोडांतरक कोड को भौतिक पते 0x6000 पर कॉपी किया जाता है, जो एपी के प्रत्येक कोर को इनिशियलाइज़ करता है। इस कोड के बारे में नीचे बताया गया है।
• जी। उसके बाद, प्रोसेसर कोर के प्रत्येक एपी को लॉन्च किया जाता है। ऐसा करने के लिए, INIT-SIPI-SIPI सिग्नल प्रत्येक कोर को क्रमिक रूप से ICR को कुछ बाइट्स लिखकर भेजे जाते हैं। यह कोड (http://fxr.watson.org/fxr/source/i386/i386/mp_machdep.c) से लिया गया है। कोड को निष्पादित करने के लिए, पहले प्राप्त की गई LAPIC आईडी और वेक्टर 6, पता 0x6000 के पते के आधार पर, जो आरंभीकरण कोड पर स्थित है, का उपयोग किया जाता है।
• एच। तब बीएसपी को उम्मीद है कि सभी प्रोसेसर कोर चालू हैं, जिसके लिए वह उस समय की प्रतीक्षा करता है जब कोर पर चालू काउंटर उनकी कुल संख्या के बराबर होता है। प्रत्येक AP कोर इस काउंटर को 1 से बढ़ाता है।
• मैं। इस समारोह में अपना काम समाप्त करता है।

2. प्रत्येक एपी पर कोड चल रहा है। यह कोड कोडांतरक से शुरू होता है। Smp.c की शुरुआत में तुरंत स्थित है। इस कोडांतरक कोड में, प्रत्येक पंक्ति पर टिप्पणी की गई है। यदि आप इस कोड कोड का संक्षेप में वर्णन करते हैं, तो यह निम्नलिखित क्रियाएं करता है:

• एक। ध्वज रजिस्टर में कई झंडे इकट्ठा करना, और काम शुरू करने के लिए आधार रजिस्टर रीसेट करना।
• ख। पेजिंग के बिना cr0 में संरक्षित मोड का समावेश।
• सी। 32-बिट कोड सेगमेंट में संक्रमण।
• घ। लोडिंग GDTR और सभी खंडों को 32-बिट (कोड और डेटा) के रूप में।
• ई। MSR से आधार LAPIC पते को पढ़ना।
• च। इसकी आईडी (वर्तमान कर्नेल के लिए) निर्धारित करने के लिए LAPIC रजिस्टर पढ़ना।
• जी। वर्तमान कर्नेल के लिए स्टैक पॉइंटर प्राप्त करना। प्रत्येक कोर के लिए, मेमोरी अपने व्यक्तिगत स्टैक के लिए अग्रिम में आरक्षित है।
• एच। C (SmpApMain) में फ़ंक्शन कॉल।

SmpApMain फ़ंक्शन प्रोसेसर इंडेक्स को परिभाषित करता है। सूचकांक इसकी संख्या 0 से एन तक है - जहां एन -1 कंप्यूटर पर कोर की कुल संख्या है। फिर, चल रहे कोर के काउंटर को समकालिक रूप से बढ़ाया जाता है, जिसका उपयोग सभी प्रोसेसर के शुरू होने की प्रतीक्षा करने के लिए किया जाता है। फिर प्रोसेसर कोर सक्षम होने के लिए पेलोड लॉन्च ध्वज की प्रतीक्षा करता है। जैसे ही ध्वज को चालू किया जाता है, ap_cpu_worker फ़ंक्शन को कहा जाता है - जो पेलोड (रे-ट्रैस) करता है।

चरण 5. रे ट्रेसिंग एल्गोरिथ्म जोड़ना।

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

1. एक ray.cpp फ़ाइल बनाएँ। परिणामी कोड को इसमें कॉपी करें।

2. इसमें लाइनें बदलें:

 #include <cstdlib> #include <cstdio> #include <cmath> #include <fstream> #include <vector> #include <iostream> #include <cassert> 

प्रति पंक्ति:

 extern "C" { #include "types.h" #include "printf.h" #include "string.h" #include "hardware.h" double tan(double x); double sqrt(double x); double pow (double x, double y); extern int vbe_screen_w; extern int vbe_screen_h; extern ulong vbe_lfb_addr; extern ulong vbe_bytes; extern u32 cpu_count; extern ulong SmpStartedCpus; void SmpReleaseAllAps(); } namespace std { template <class T> const T& max (const T& a, const T& b) { return (a<b)?b:a; // or: return comp(a,b)?b:a; for version (2) } template <class T> const T& min (const T& a, const T& b) { return !(b<a)?a:b; // or: return !comp(b,a)?a:b; for version (2) } } 

3. निम्नलिखित पंक्तियों को हटाएँ:

 friend std::ostream & operator << (std::ostream &os, const Vec3<T> &v) { os << "[" << vx << " " << vy << " " << vz << "]"; return os; } 

और ये:

 // Save result to a PPM image (keep these flags if you compile under Windows) std::ofstream ofs("./untitled.ppm", std::ios::out | std::ios::binary); ofs << "P6\n" << width << " " << height << "\n255\n"; for (unsigned i = 0; i < width * height; ++i) { ofs << (unsigned char)(std::min(T(1), image[i].x) * 255) << (unsigned char)(std::min(T(1), image[i].y) * 255) << (unsigned char)(std::min(T(1), image[i].z) * 255); 

4. बदलें:

 const std::vector<Sphere<T> *> &spheres, const int &depth) 

करने के लिए:

 const Sphere<T> **spheres, unsigned spheres_size, const int &depth) 

5. संपूर्ण रे.कैप फ़ाइल में , spheres_size ( कुल में 3 प्रतिस्थापन ) के साथ spheres.size ( ) बदलें।
6. इसके साथ रेंडर फ़ंक्शन को बदलें:

 void render(const Sphere<T> **spheres, unsigned spheres_size, unsigned y_start, unsigned y_end) { Vec3<T> pixel; T invWidth = 1 / T(vbe_screen_w), invHeight = 1 / T(vbe_screen_h); T fov = 30, aspectratio = vbe_screen_w / T(vbe_screen_h); T angle = tan(M_PI * 0.5 * fov / T(180)); // Trace rays for (unsigned y = y_start; y < y_end; ++y) { for (unsigned x = 0; x < (unsigned)vbe_screen_w; ++x) { T xx = (2 * ((x + 0.5) * invWidth) - 1) * angle * aspectratio; T yy = (1 - 2 * ((y + 0.5) * invHeight)) * angle; Vec3<T> raydir(xx, yy, -1); raydir.normalize(); pixel = trace(Vec3<T>(0), raydir, spheres, spheres_size, 0); //   int color = ((int)(pixel.x * 255) << 16) | ((int)(pixel.y * 255) << 8) | (int)(pixel.z * 255); //     *(int *)((char *)vbe_lfb_addr + y * vbe_screen_w * vbe_bytes + x * vbe_bytes + 0) = color & 0xFFFFFF; } } } 

7. तदनुसार, पूरी फ़ाइल में, एक अन्य spheres_size पैरामीटर जोड़कर दो शेष कॉल को ट्रेस फ़ंक्शन में ठीक करें:

 Vec3<T> reflection = trace(phit + nhit * bias, refldir, spheres, depth + 1); 

इसके साथ बदलें:

 Vec3<T> reflection = trace(phit + nhit * bias, refldir, spheres, spheres_size, depth + 1) ; 

और यह:

 refraction = trace(phit - nhit * bias, refrdir, spheres, depth + 1) ; 

पर:

 refraction = trace(phit - nhit * bias, refrdir, spheres, spheres_size, depth + 1) ; 

8. फ़ाइल के अंत में, मुख्य फ़ंक्शन के बजाय, ray_main और ap_cpu_worker फ़ंक्शंस जोड़ें:

 #define RAY_SHAPES_COUNT 6 Sphere<float> *ray_spheres[RAY_SHAPES_COUNT]; extern "C" void ap_cpu_worker( int index ) { __enable_fpu(); render<float>((const Sphere<float> **)ray_spheres, 6, vbe_screen_h/cpu_count * index, vbe_screen_h/cpu_count * index + vbe_screen_h/cpu_count); forever(); } extern "C" int ray_main() { Sphere<float> sp1 (Vec3<float>(0, -10004, -20), 10000, Vec3<float>(0.2), 0, 0.0); Sphere<float> sp2 (Vec3<float>(0, 0, -20), 4, Vec3<float>(1.00, 0.32, 0.36), 1, 0.0); Sphere<float> sp3 (Vec3<float>(5, -1, -15), 2, Vec3<float>(0.90, 0.76, 0.46), 1, 0.0); Sphere<float> sp4 (Vec3<float>(5, 0, -25), 3, Vec3<float>(0.65, 0.77, 0.97), 1, 0.0); Sphere<float> sp5 (Vec3<float>(-5.5, 0, -15), 3, Vec3<float>(0.90, 0.90, 0.90), 1, 0.0); Sphere<float> sp6 (Vec3<float>(0, 20, -30), 3, Vec3<float>(0), 0, 0, Vec3<float>(3)); ray_spheres[0] = &sp1; ray_spheres[1] = &sp2; ray_spheres[2] = &sp3; ray_spheres[3] = &sp4; ray_spheres[4] = &sp5; ray_spheres[5] = &sp6; SmpReleaseAllAps(); ap_cpu_worker(0); forever (); return 0; } 

चरण 6. हाल ही में सुधार और लॉन्च।

यह केवल मेकफाइल को अंतिम रूप देने के लिए बनी हुई है ताकि सब कुछ संकलित हो जाए। ऐसा करने के लिए, निम्नलिखित परिवर्तन करें:
1. अद्यतन OBJFILES:

 OBJFILES = \ loader.o \ common/printf.o \ common/screen.o \ common/bios.o \ common/vbe.o \ common/qdivrem.o \ common/udivdi3.o \ common/umoddi3.o \ common/divdi3.o \ common/moddi3.o \ common/setjmp.o \ common/string.o \ x86emu/x86emu.o \ x86emu/x86emu_util.o \ smp.o \ ray.o \ kernel.o 

2. C ++ संकलित करने के लिए एक लक्ष्य जोड़ें:

 .cpp.o: $(CC) -Ix86emu -I. -Iustl -Iinclude $(CFLAGS) -o $@ -c $< 

3. अगला, आपको नई लाइब्रेरी को जोड़ने के लिए लिंकर की कॉल लाइन को बदलना होगा:

 $(LD) -T linker.ld -o $@ $^ fdlibm/fdlibm.a 

4. अब आपको पुस्तकालय बनाने की आवश्यकता है:

 cd fdlibm make rebuild 

5. अब आप परियोजना का पुनर्निर्माण कर सकते हैं:

 make rebuild sudo make image 

6. यह सुनिश्चित करने के लिए कि सब कुछ काम करता है, 4-कोर प्रोसेसर का अनुकरण करने के विकल्प के साथ परियोजना को चलाएं:

 sudo qemu-system-i386 -hda hdd.img –smp 4 

यदि सब कुछ सही ढंग से किया जाता है, तो हमें इस सुंदरता को देखना चाहिए:


जैसा कि लेख के पिछले भागों में, dd कमांड का उपयोग करके, आप hdd.img छवि को USB फ्लैश ड्राइव पर कॉपी कर सकते हैं और वास्तविक कंप्यूटर पर प्रोग्राम का परीक्षण कर सकते हैं।

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

श्रृंखला में निम्नलिखित लेखों के लिंक:
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 5. ओएस से BIOS तक पहुंचना
" ऑपरेटिंग सिस्टम के बिना प्रोग्राम कैसे चलाएं: भाग 6. FAT फाइल सिस्टम के साथ डिस्क के साथ काम करने के लिए समर्थन "