🚊 👨🏻‍✈️ 💎 मैं एक खिलौना ओएस लिख रहा हूं (म्यूटेक्स के कार्यान्वयन के बारे में) 💃 ⛩️ 🕶️

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

म्यूटेक्स को लागू करने के लिए ( src / Sync.h और src / sync.c में परिभाषित और कार्यान्वित) दो पिछले पदों में वर्णित मौजूदा अनुसूचक को संशोधित करने की आवश्यकता नहीं है। एक म्यूटेक्स को इसके केवल दो कार्यों के आधार पर बनाया जा सकता है: एक स्ट्रीम शुरू करें और रोकें (देखें src / schedule.h )।

struct mutex { struct __mutex_node *head, *tail; struct spinlock mlock, ilock; }; static inline void create_mutex(struct mutex *mutex) { mutex->head = mutex->tail = NULL; create_spinlock(&mutex->mlock); create_spinlock(&mutex->ilock); }

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

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

 static inline err_code acquire_mutex(struct mutex *mutex) { extern err_code __sleep_in_mutex(struct mutex *mutex); if (!acquire_spinlock_int(&mutex->mlock, 1000)) return __sleep_in_mutex(mutex); return ERR_NONE; } struct __mutex_node { struct __mutex_node *next; thread_id id; }; INTERNAL err_code __sleep_in_mutex(struct mutex *mutex) { struct __mutex_node *node = NULL; bool acquired; acquire_spinlock(&mutex->ilock, 0); acquired = acquire_spinlock_int(&mutex->mlock, 1); if (!acquired) { node = alloc_block(&mutex_node_pool); if (node) { node->next = NULL; node->id = get_thread(); if (mutex->head) mutex->head->next = node; mutex->head = node; if (!mutex->tail) mutex->tail = node; pause_this_thread(&mutex->ilock); } } if (!node) release_spinlock(&mutex->ilock); return (acquired || node) ? ERR_NONE : ERR_OUT_OF_MEMORY; }

उपरोक्त कोड को कुछ स्पष्टीकरण की आवश्यकता है:

1. ach_spinlock_int फ़ंक्शन ach_spinlock के समान है, सिवाय इसके कि जब तक स्पिनलॉक जारी नहीं होता है तब तक यह बाधित नहीं होता है। झुंड पर कब्जा करते समय, हम व्यवधानों को निष्क्रिय नहीं करना चाहते हैं - म्यूटेक्स के मालिक होने में लंबा समय लग सकता है। एक और बात यह है कि जब हम आईलॉक पर कब्जा कर रहे हैं, तो कतार में एक धागा जोड़ना चाहते हैं - यह ऑपरेशन जल्दी होना चाहिए।

2. __sleep_in_mutex फ़ंक्शन की निम्न पंक्ति पहली नज़र में संवेदनहीन है:

  acquired = acquire_spinlock_int(&mutex->mlock, 1);

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

3. आबंटित_ब्लॉक और फ्री_ब्लॉक फ़ंक्शन एक निश्चित आकार के पूर्व-आवंटित मेमोरी ब्लॉकों के एक पूल को संदर्भित करते हैं (देखें src / memory.h )। जब भी हमें ब्लॉक (इस मामले में, __mutex_bode) की आवश्यकता होती है, तो इस पूल का नमक एक धीमी मॉलोक को कॉल नहीं करता है। वैसे, मेरे पास अभी भी कार्यान्वयन के बिना यह पूल है (केवल एक स्टब सीधे मॉलोक कह रहा है), साथ ही साथ मॉलॉक भी। अगर किसी को पहली या दूसरे पोर्ट को लागू करने की एक अनूठा इच्छा है - लिखना।

4. यदि आप पहले प्रयास के बाद सो सकते हैं, तो M को पकड़ने के लिए N प्रयास क्यों करें? आप कर सकते हैं, यह सिर्फ बहुत प्रभावी नहीं है। एक स्विचलॉक प्राप्त करने के लिए संदर्भ स्विचिंग समय एक प्रयास से काफी अधिक है। इसलिए, यह एन प्रयास करने के लिए तर्कसंगत है (कोड 1000 में, छत से लिया गया है, भविष्य में यह आवश्यक है कि व्यवहारिक माप का संचालन, व्युत्पन्न करने से पहले एक अधिक उचित एन को प्राप्त करना और औचित्य करना)।

5. कोड pause_thread के संशोधित संस्करण का उपयोग करता है: pause_this_thread। वर्तमान प्रवाह को euthanizing के अलावा, यह परमाणु (रुकावट में) इसके लिए प्रेषित स्पिनलॉक को छोड़ता है।

जब म्यूटेक्स को मुक्त कर दिया जाता है, तो मेजबान इलॉक को पकड़ लेता है, और फिर कतार में प्रतीक्षा कर रहे थ्रेड्स की जांच करता है। यदि धारा मिलती है, तो यह उठता है, म्यूटेक्स का नया मालिक बन जाता है। यदि कोई लंबित थ्रेड नहीं हैं, तो होस्ट Mlock और निकास देता है।

 static inline void release_mutex(struct mutex *mutex) { extern void __awake_in_mutex(struct mutex *mutex); acquire_spinlock(&mutex->ilock, 0); if (mutex->tail) __awake_in_mutex(mutex); else release_spinlock_int(&mutex->mlock); release_spinlock(&mutex->ilock); } INTERNAL void __awake_in_mutex(struct mutex *mutex) { struct __mutex_node *node; err_code err; do { node = mutex->tail; mutex->tail = node->next; if (mutex->head == node) mutex->head = NULL; err = resume_thread(node->id); free_block(&mutex_node_pool, node); } while (mutex->tail && err); if (!mutex->tail) release_spinlock_int(&mutex->mlock); }

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

PS यदि आपको कोड में त्रुटियां मिलती हैं - तो अवश्य लिखें।

मैं एक खिलौना ओएस लिख रहा हूं (म्यूटेक्स के कार्यान्वयन के बारे में)

More articles: