मैं एक खिलौना ओएस लिख रहा हूं (अनुसूचक के बारे में अधिक सुलभ)

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

तो एक अनुसूचक क्या है? अनुसूचक ओएस का एक हिस्सा है जो मल्टीटास्किंग को लागू करता है। प्रोसेसर की संख्या आमतौर पर किए गए कार्यों की संख्या से बहुत कम है। इसलिए, प्रत्येक प्रोसेसर के पास कई कार्य हैं। इसकी सुसंगत प्रकृति के कारण, प्रोसेसर इन कार्यों को एक ही समय में नहीं कर सकता है - और यह बारी-बारी से एक कार्य से दूसरे में बदल जाता है।

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

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

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

प्राथमिकता के आधार पर, एक धारा को एक निश्चित मात्रा में समय दिया जाता है। उदाहरण के लिए, मान लीजिए कि एक टाइमर उत्पन्न करता है, जो हर मिलीसेकंड को बाधित करता है। फिर प्रवाह जिसे क्वांटम 50 सौंपा गया है, 50 मिलीसेकंड के लिए काम कर सकता है यदि यह उच्च प्राथमिकता के साथ प्रवाह द्वारा प्रतिस्थापित नहीं किया जाता है।

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

खिलौना में, यह इस तरह से किया जाता है:

DEFINE_ISR(timer, 0) { ... thrd->context = *stack_frame; //      thread_data update_priority_quantum(thrd); //       ... prio = &cpud->priorities[cpud->current_priority = highest]; //      struct thread_data *thrd2 = prio->active_tail; //        if (thrd2 != thrd) { //     -       *stack_frame = thrd2->context; //      wrmsr(MSR_FS_BASE, (uint64_t)thrd2); } ... } 

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

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

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

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

सक्रिय प्रतीक्षा पर आधारित मुख्य तुल्यकालन आदिम स्पिनकॉक है । आधुनिक प्रणालियों में, स्पिनलॉक परमाणु निर्देशों पर आधारित होते हैं। X86 के लिए, ये xchg, लॉक cmpxchg, और अन्य हैं। ऐसे निर्देशों का मुख्य कार्य मेमोरी सेल को परमाणु रूप से पढ़ना और बदलना है। एक खिलौने में एक स्पिनलॉक की बुनियादी कैप्चर और रिलीज को लागू करना:

 struct spinlock { volatile uint8_t busy; }; static inline void create_spinlock(struct spinlock *lock) { lock->busy = false; } // zero tries means (practically) forever static inline bool acquire_spinlock_int(struct spinlock *lock, uint64_t tries) { uint8_t al; do ASMV("mov $1, %%al\nxchgb %%al, %0" : "+m"(lock->busy), "=&a"(al)); while (al && --tries); return !al; } static inline void release_spinlock_int(struct spinlock *lock) { ASMV("xorb %%al, %%al\nxchgb %%al, %0" : "+m"(lock->busy) : : "al"); } 

आज के लिए बस इतना ही।