मैं एक खिलौना ओएस लिख रहा हूँ (योजनाकार के बारे में)

मैं एक खिलौना ओएस के विकास पर ब्लॉग जारी रखता हूं।

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

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

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

इसलिए, उपरोक्त अनुसूचियों के इंटरफ़ेस में उपरोक्त आवश्यकताओं के परिणामस्वरूप:

// IN fields should be set before calling attach_thread struct thread_data { INTERNAL uint64_t magic; INTERNAL struct thread_data *prev, *next, *all_prev, *all_next; IN struct int_stack_frame context; IN uint8_t *stack; IN size_t stack_size; // size available to thread: stack_size - 8 IN uint64_t affinity[THREAD_AFFINITY_SIZE]; OUT uint64_t output; OUT uint64_t run_time; IN uint8_t priority; INTERNAL uint8_t real_priority; INTERNAL uint16_t quantum; INTERNAL uint8_t cpu; INTERNAL uint8_t state: 2; IN uint8_t fixed_priority : 1; }; typedef uint64_t thread_id; typedef uint64_t (*thread_proc)(uint64_t input); // set stack and stack_size fields before calling this function err_code set_thread_context(struct thread_data *thread, thread_proc proc, uint64_t input); // attached thread becomes paused; thread should not reside in stack! err_code attach_thread(struct thread_data *thread, thread_id *id); err_code detach_thread(thread_id id, struct thread_data **thread); err_code resume_thread(thread_id id); err_code pause_thread(thread_id id); err_code stop_thread(thread_id id, uint64_t output); thread_id get_thread(void); 

यहां एक नया धागा शुरू करने वाले कोड का एक उदाहरण दिया गया है:

 static uint64_t thread_proc(uint64_t input) { // do some work return output; } #define STACK_SIZE 0x1000 static void start_thread(void) { thread_id id; struct thread_data *thrd; struct thread_data *thrd = kmalloc(sizeof(*thrd)+STACK_SIZE); if (!thrd) { LOG_ERROR("Failed to allocate memory"); return; } memset(thrd, 0, sizeof(*thrd)); thrd->stack = (uint8_t*)(thrd + 1); thrd->stack_size = STACK_SIZE; thrd->affinity[0] = 1; // will run on first CPU only thrd->priority = 3; thrd->fixed_priority = true; set_thread_context(thrd, thread_proc, 0); if (attach_thread(thrd, &id) != ERR_NONE) { LOG_ERROR("Failed to attach thread"); return; } if (resume_thread(id) != ERR_NONE) { LOG_ERROR("Failed to resume thread"); return; } 

अब हुड के नीचे देखने का समय है।

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



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

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

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

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

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