ओएस के कर्नेल में मल्टीटास्किंग का संगठन

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

परिचय

पहले हम परिभाषित करेंगे कि "मल्टीटास्किंग" शब्द का क्या अर्थ है। यहाँ रूसी विकिपीडिया से परिभाषा दी गई है:

मल्टीटास्किंग (अंग्रेजी मल्टीटास्किंग) - कई प्रक्रियाओं के समानांतर (या छद्म-समानांतर) प्रसंस्करण की क्षमता प्रदान करने के लिए ऑपरेटिंग सिस्टम या प्रोग्रामिंग वातावरण की संपत्ति।

अंग्रेजी में, मेरी राय में, एक कम स्पष्ट, लेकिन अधिक विस्तृत परिभाषा है:

कंप्यूटिंग में, मल्टीटास्किंग एक ऐसी विधि है जहां कई कार्यों, जिन्हें प्रक्रियाओं के रूप में भी जाना जाता है, समान अवधि के दौरान किए जाते हैं। कार्य सामान्य संसाधन संसाधन, जैसे CPU और मुख्य मेमोरी साझा करते हैं। एकल सीपीयू के साथ एक कंप्यूटर के मामले में, केवल एक कार्य को किसी भी समय पर चलने के लिए कहा जाता है, जिसका अर्थ है कि सीपीयू उस कार्य के लिए निर्देशों को सक्रिय रूप से निष्पादित कर रहा है। मल्टीटास्किंग समस्या को हल करके बताता है कि कौन सा कार्य किसी भी समय चल रहा है, और जब किसी अन्य प्रतीक्षा कार्य को एक मोड़ मिलता है। सीपीयू को एक कार्य से दूसरे कार्य में पुन: सौंपने के कार्य को संदर्भ स्विच कहा जाता है।

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

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

कई अलग-अलग नियोजन विधियां हैं। उनमें से अधिकांश को दो मुख्य प्रकारों के लिए जिम्मेदार ठहराया जा सकता है:

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

आइए एक गैर-निवारक नियोजन विधि से शुरू करें, क्योंकि इसे बहुत सरलता से लागू किया जा सकता है।

गैर-प्रीमेप्टिव प्लानर

विचाराधीन गैर-निवारक अनुसूचक बहुत सरल है, यह सामग्री शुरुआती लोगों के लिए मल्टीटास्किंग को समझने में आसान बनाने के लिए दी गई है। जिस किसी के पास एक विचार है, यहां तक ​​कि एक सैद्धांतिक भी, तुरंत "एक्सट्रूज़न शेड्यूलर" अनुभाग पर जा सकता है।

सबसे सरल गैर-भीड़ शेड्यूलर

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

#include <stdio.h> #define TASK_COUNT 2 struct task { void (*func)(void *); void *data; }; static struct task tasks[TASK_COUNT]; static void scheduler(void) { int i; for (i = 0; i < TASK_COUNT; i++) { tasks[i].func(tasks[i].data); } } static void worker(void *data) { printf("%s\n", (char *) data); } static struct task *task_create(void (*func)(void *), void *data) { static int i = 0; tasks[i].func = func; tasks[i].data = data; return &tasks[i++]; } int main(void) { task_create(&worker, "First"); task_create(&worker, "Second"); scheduler(); return 0; } 

आउटपुट परिणाम:

पहले
दूसरा

CPU व्यस्त ग्राफ:

घटना-आधारित गैर-निवारक समयबद्धक

यह स्पष्ट है कि ऊपर वर्णित उदाहरण बहुत आदिम है। चलो एक विशिष्ट कार्य को सक्रिय करने के लिए एक और अवसर देते हैं। ऐसा करने के लिए, कार्य विवरण संरचना में एक ध्वज जोड़ें जो यह दर्शाता है कि कार्य सक्रिय है या नहीं। बेशक, सक्रियण को नियंत्रित करने के लिए आपको अभी भी एक छोटे एपीआई की आवश्यकता है।

 #include <stdio.h> #define TASK_COUNT 2 struct task { void (*func)(void *); void *data; int activated; }; static struct task tasks[TASK_COUNT]; struct task_data { char *str; struct task *next_task; }; static struct task *task_create(void (*func)(void *), void *data) { static int i = 0; tasks[i].func = func; tasks[i].data = data; return &tasks[i++]; } static int task_activate(struct task *task, void *data) { task->data = data; task->activated = 1; return 0; } static int task_run(struct task *task, void *data) { task->activated = 0; task->func(data); return 0; } static void scheduler(void) { int i; int fl = 1; while (fl) { fl = 0; for (i = 0; i < TASK_COUNT; i++) { if (tasks[i].activated) { fl = 1; task_run(&tasks[i], tasks[i].data); } } } } static void worker1(void *data) { printf("%s\n", (char *) data); } static void worker2(void *data) { struct task_data *task_data; task_data = data; printf("%s\n", task_data->str); task_activate(task_data->next_task, "First activated"); } int main(void) { struct task *t1, *t2; struct task_data task_data; t1 = task_create(&worker1, "First create"); t2 = task_create(&worker2, "Second create"); task_data.next_task = t1; task_data.str = "Second activated"; task_activate(t2, &task_data); scheduler(); return 0; } 

आउटपुट परिणाम:

दूसरा सक्रिय
पहले सक्रिय

सीपीयू व्यस्त ग्राफ

संदेश गैर-निवारक समयबद्धक पंक्तिबद्ध करना

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

 #include <stdio.h> #include <stdlib.h> #define TASK_COUNT 2 struct message { void *data; struct message *next; }; struct task { void (*func)(void *); struct message *first; }; struct task_data { char *str; struct task *next_task; }; static struct task tasks[TASK_COUNT]; static struct task *task_create(void (*func)(void *), void *data) { static int i = 0; tasks[i].func = func; tasks[i].first = NULL; return &tasks[i++]; } static int task_activate(struct task *task, void *data) { struct message *msg; msg = malloc(sizeof(struct message)); msg->data = data; msg->next = task->first; task->first = msg; return 0; } static int task_run(struct task *task, void *data) { struct message *msg = data; task->first = msg->next; task->func(msg->data); free(data); return 0; } static void scheduler(void) { int i; int fl = 1; struct message *msg; while (fl) { fl = 0; for (i = 0; i < TASK_COUNT; i++) { while (tasks[i].first) { fl = 1; msg = tasks[i].first; task_run(&tasks[i], msg); } } } } static void worker1(void *data) { printf("%s\n", (char *) data); } static void worker2(void *data) { struct task_data *task_data; task_data = data; printf("%s\n", task_data->str); task_activate(task_data->next_task, "Message 1 to first"); task_activate(task_data->next_task, "Message 2 to first"); } int main(void) { struct task *t1, *t2; struct task_data task_data; t1 = task_create(&worker1, "First create"); t2 = task_create(&worker2, "Second create"); task_data.next_task = t1; task_data.str = "Second activated"; task_activate(t2, &task_data); scheduler(); return 0; } 

काम के परिणाम:

दूसरा सक्रिय
संदेश 2 से पहले
संदेश 1 से पहला

सीपीयू व्यस्त ग्राफ

गैर-पूर्वनिर्धारित अनुसूचक कॉल आदेश संरक्षण के साथ

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

 #include <stdio.h> #include <stdlib.h> #define TASK_COUNT 2 struct task { void (*func)(void *); void *data; struct task *next; }; static struct task *first = NULL, *last = NULL; static struct task *task_create(void (*func)(void *), void *data) { struct task *task; task = malloc(sizeof(struct task)); task->func = func; task->data = data; task->next = NULL; if (last) { last->next = task; } else { first = task; } last = task; return task; } static int task_run(struct task *task, void *data) { task->func(data); free(task); return 0; } static struct task *task_get_next(void) { struct task *task = first; if (!first) { return task; } first = first->next; if (first == NULL) { last = NULL; } return task; } static void scheduler(void) { struct task *task; while ((task = task_get_next())) { task_run(task, task->data); } } static void worker2(void *data) { printf("%s\n", (char *) data); } static void worker1(void *data) { printf("%s\n", (char *) data); task_create(worker2, "Second create"); task_create(worker2, "Second create again"); } int main(void) { struct task *t1; t1 = task_create(&worker1, "First create"); scheduler(); return 0; } 

काम के परिणाम:

पहले बनाएं
दूसरा बनाते हैं
दूसरा फिर से बनाएं

सीपीयू व्यस्त ग्राफ

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

एक्सट्रूज़न प्लानर

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

यह डेटा - इंस्ट्रक्शन पॉइंटर और स्टैक पॉइंटर - प्रोसेसर रजिस्टरों में संग्रहीत होता है। उनके अलावा, रजिस्टरों में निहित अन्य जानकारी सही संचालन के लिए आवश्यक है: स्टेटस फ्लैग, विभिन्न सामान्य-उद्देश्य रजिस्टर जिसमें अस्थायी चर होते हैं, और इसी तरह। यह सब एक प्रोसेसर संदर्भ कहा जाता है।

प्रोसेसर का संदर्भ

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

हमारी परियोजना से x86 वास्तुकला के लिए संदर्भ संरचना का विवरण:

 struct context { /* 0x00 */uint32_t eip; /**< instruction pointer */ /* 0x04 */uint32_t ebx; /**< base register */ /* 0x08 */uint32_t edi; /**< Destination index register */ /* 0x0c */uint32_t esi; /**< Source index register */ /* 0x10 */uint32_t ebp; /**< Stack pointer register */ /* 0x14 */uint32_t esp; /**< Stack Base pointer register */ /* 0x18 */uint32_t eflags; /**< EFLAGS register hold the state of the processor */ }; 

प्रोसेसर के संदर्भ और संदर्भ स्विचिंग की अवधारणाएं प्रीमेप्टिव प्लानिंग के सिद्धांत को समझने में मौलिक हैं।

प्रसंग स्विच

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

X86 आर्किटेक्चर के लिए संदर्भ स्विच प्रक्रिया:

  .global context_switch context_switch: movl 0x04(%esp), %ecx /* Point ecx to previous registers */ movl (%esp), %eax /* Get return address */ movl %eax, CTX_X86_EIP(%ecx) /* Save it as eip */ movl %ebx, CTX_X86_EBX(%ecx) /* Save ebx */ movl %edi, CTX_X86_EDI(%ecx) /* Save edi */ movl %esi, CTX_X86_ESI(%ecx) /* Save esi */ movl %ebp, CTX_X86_EBP(%ecx) /* Save ebp */ add $4, %esp /* Move esp in state corresponding to eip */ movl %esp, CTX_X86_ESP(%ecx) /* Save esp */ pushf /* Push flags */ pop CTX_X86_EFLAGS(%ecx) /* ...and save them */ movl 0x04(%esp), %ecx /* Point ecx to next registers */ movl CTX_X86_EBX(%ecx), %ebx /* Restore ebx */ movl CTX_X86_EDI(%ecx), %edi /* Restore edi */ movl CTX_X86_ESP(%ecx), %esi /* Restore esp */ movl CTX_X86_EBP(%ecx), %ebp /* Restore ebp */ movl CTX_X86_ESP(%ecx), %esp /* Restore esp */ push CTX_X86_EFLAGS(%ecx) /* Push saved flags */ popf /* Restore flags */ movl CTX_X86_EIP(%ecx), %eax /* Get eip */ push %eax /* Restore it as return address */ ret 

स्ट्रीम स्टेट मशीन

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

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

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

इस तरह से एक सामान्यीकृत राज्य मशीन का प्रतिनिधित्व किया जा सकता है:

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

राज्य कार्यान्वयन

यदि आप राज्य आरेख पर करीब से नज़र डालते हैं, तो आप देख सकते हैं कि init और प्रतीक्षा अवस्थाएँ लगभग समान हैं: दोनों ही तैयार अवस्था में जा सकते हैं, अर्थात, अनुसूचक को बता सकते हैं कि वे अपना समय प्राप्त करने के लिए तैयार हैं। इस प्रकार, इनिट अवस्था बेमानी है।

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

इस प्रकार, हमारे पास तीन राज्य हैं। हम इन राज्यों को तीन अलग-अलग क्षेत्रों में संग्रहीत करेंगे। एक पूर्णांक फ़ील्ड में सब कुछ स्टोर करना संभव होगा, लेकिन चेक को सरल बनाने और मल्टीप्रोसेसर मामले की ख़ासियत के कारण, जिस पर हम यहां चर्चा नहीं करेंगे, ऐसा निर्णय किया गया था। तो, धारा की स्थिति:

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

सृजन

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

 struct thread *thread_create(unsigned int flags, void *(*run)(void *), void *arg) { int ret; struct thread *t; //… /* below we are going work with thread instances and therefore we need to * lock the scheduler (disable scheduling) to prevent the structure being * corrupted */ sched_lock(); { /* allocate memory */ if (!(t = thread_alloc())) { t = err_ptr(ENOMEM); goto out; } /* initialize internal thread structure */ thread_init(t, flags, run, arg); //… } out: sched_unlock(); return t; } 

 void thread_init(struct thread *t, unsigned int flags, void *(*run)(void *), void *arg) { sched_priority_t priority; assert(t); assert(run); assert(thread_stack_get(t)); assert(thread_stack_get_size(t)); t->id = id_counter++; /* setup thread ID */ dlist_init(&t->thread_link); /* default unlink value */ t->critical_count = __CRITICAL_COUNT(CRITICAL_SCHED_LOCK); t->siglock = 0; t->lock = SPIN_UNLOCKED; t->ready = false; t->active = false; t->waiting = true; t->state = TS_INIT; /* set executive function and arguments pointer */ t->run = run; t->run_arg = arg; t->joining = NULL; //... /* cpu context init */ context_init(&t->context, true); /* setup default value of CPU registers */ context_set_entry(&t->context, thread_trampoline);/*set entry (IP register*/ /* setup stack pointer to the top of allocated memory * The structure of kernel thread stack follow: * +++++++++++++++ top * | * v * the thread structure * xxxxxxx * the end * +++++++++++++++ bottom (t->stack - allocated memory for the stack) */ context_set_stack(&t->context, thread_stack_get(t) + thread_stack_get_size(t)); sigstate_init(&t->sigstate); /* Initializes scheduler strategy data of the thread */ runq_item_init(&t->sched_attr.runq_link); sched_affinity_init(t); sched_timing_init(t); } 

खड़े द्वारा

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

प्रवाह पूर्ण होना

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

 void __attribute__((noreturn)) thread_exit(void *ret) { struct thread *current = thread_self(); struct task *task = task_self(); struct thread *joining; /* We can not free the main thread */ if (task->main_thread == current) { /* We are last thread. */ task_exit(ret); /* NOTREACHED */ } sched_lock(); current->waiting = true; current->state |= TS_EXITED; /* Wake up a joining thread (if any). * Note that joining and run_ret are both in a union. */ joining = current->joining; if (joining) { current->run_ret = ret; sched_wakeup(joining); } if (current->state & TS_DETACHED) /* No one references this thread anymore. Time to delete it. */ thread_delete(current); schedule(); /* NOTREACHED */ sched_unlock(); /* just to be honest */ panic("Returning from thread_exit()"); } 

एक प्रसंस्करण फ़ंक्शन को कॉल करने के लिए स्प्रिंगबोर्ड

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

 static void __attribute__((noreturn)) thread_trampoline(void) { struct thread *current = thread_self(); void *res; assert(!critical_allows(CRITICAL_SCHED_LOCK), "0x%x", (uint32_t)__critical_count); sched_ack_switched(); assert(!critical_inside(CRITICAL_SCHED_LOCK)); /* execute user function handler */ res = current->run(current->run_arg); thread_exit(res); /* NOTREACHED */ } 

सारांश: स्ट्रीम संरचना विवरण

इसलिए, भीड़-भाड़ वाले शेड्यूलर के मामले में कार्य का वर्णन करने के लिए, हमें एक जटिल संरचना की आवश्यकता है। इसमें शामिल हैं:

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

तदनुसार, हमारी परियोजना में संरचना का वर्णन इस प्रकार है:

 struct thread { unsigned int critical_count; unsigned int siglock; spinlock_t lock; /**< Protects wait state and others. */ unsigned int active; /**< Running on a CPU. TODO SMP-only. */ unsigned int ready; /**< Managed by the scheduler. */ unsigned int waiting; /**< Waiting for an event. */ unsigned int state; /**< Thread-specific state. */ struct context context; /**< Architecture-dependent CPU state. */ void *(*run)(void *); /**< Start routine. */ void *run_arg; /**< Argument to pass to start routine. */ union { void *run_ret; /**< Return value of the routine. */ void *joining; /**< A joining thread (if any). */ } /* unnamed */; thread_stack_t stack; /**< Handler for work with thread stack */ __thread_id_t id; /**< Unique identifier. */ struct task *task; /**< Task belong to. */ struct dlist_head thread_link; /**< list's link holding task threads. */ struct sigstate sigstate; /**< Pending signal(s). */ struct sched_attr sched_attr; /**< Scheduler-private data. */ thread_local_t local; thread_cancel_t cleanups; }; 

संरचना में ऐसे क्षेत्र हैं जिन्हें लेख (सिगस्टेट, स्थानीय, क्लीनअप) में वर्णित नहीं किया गया है, उन्हें पूर्ण पोसिक्स थ्रेड्स (pthread) का समर्थन करने की आवश्यकता होती है और इस लेख के ढांचे में महत्वपूर्ण नहीं हैं।

नियोजक और नियोजन रणनीति

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

 extern void runq_init(runq_t *queue); extern void runq_insert(runq_t *queue, struct thread *thread); extern void runq_remove(runq_t *queue, struct thread *thread); extern struct thread *runq_extract(runq_t *queue); extern void runq_item_init(runq_item_t *runq_link); 

अधिक विस्तार से नियोजन रणनीति के कार्यान्वयन पर विचार करें।

योजना रणनीति उदाहरण

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

 void runq_item_init(runq_item_t *runq_link) { dlist_head_init(runq_link); } void runq_init(runq_t *queue) { dlist_init(queue); } void runq_insert(runq_t *queue, struct thread *thread) { dlist_add_prev(&thread->sched_attr.runq_link, queue); } void runq_remove(runq_t *queue, struct thread *thread) { dlist_del(&thread->sched_attr.runq_link); } struct thread *runq_extract(runq_t *queue) { struct thread *thread; thread = dlist_entry(queue->next, struct thread, sched_attr.runq_link); runq_remove(queue, thread); return thread; } 

योजनाकार

अब हम सबसे दिलचस्प को पास करेंगे - अनुसूचक का वर्णन।

शेड्यूलर लॉन्च करें

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

 int sched_init(struct thread *idle, struct thread *current) { runq_init(&rq.queue); rq.lock = SPIN_UNLOCKED; sched_wakeup(idle); sched_ticker_init(); return 0; } 

जागृति और एक धागा शुरू करना

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

 /** Locks: IPL, thread. */ static int __sched_wakeup_ready(struct thread *t) { int ready; spin_protected_if (&rq.lock, (ready = t->ready)) t->waiting = false; return ready; } /** Locks: IPL, thread. */ static void __sched_wakeup_waiting(struct thread *t) { assert(t && t->waiting); spin_lock(&rq.lock); __sched_enqueue_set_ready(t); __sched_wokenup_clear_waiting(t); spin_unlock(&rq.lock); } static inline void __sched_wakeup_smp_inactive(struct thread *t) { __sched_wakeup_waiting(t); } /** Called with IRQs off and thread lock held. */ int __sched_wakeup(struct thread *t) { int was_waiting = (t->waiting && t->waiting != TW_SMP_WAKING); if (was_waiting) if (!__sched_wakeup_ready(t)) __sched_wakeup_smp_inactive(t); return was_waiting; } int sched_wakeup(struct thread *t) { assert(t); return SPIN_IPL_PROTECTED_DO(&t->lock, __sched_wakeup(t)); } 

उम्मीद

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

 #define SCHED_WAIT_TIMEOUT(cond_expr, timeout) \ ((cond_expr) ? 0 : ({ \ int __wait_ret = 0; \ clock_t __wait_timeout = timeout == SCHED_TIMEOUT_INFINITE ? \ SCHED_TIMEOUT_INFINITE : ms2jiffies(timeout); \ \ threadsig_lock(); \ do { \ sched_wait_prepare(); \ \ if (cond_expr) \ break; \ \ __wait_ret = sched_wait_timeout(__wait_timeout, \ &__wait_timeout); \ } while (!__wait_ret); \ \ sched_wait_cleanup(); \ \ threadsig_unlock(); \ __wait_ret; \ })) 

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

ए - सक्रिय
आर - रेडी
डब्ल्यू - प्रतीक्षा

करें तस्वीर में, पत्र राज्यों की उपस्थिति का संकेत देते हैं। प्रतीक्षा से पहले लाइट ग्रीन स्ट्रीम की स्थिति है। प्रतीक्षा करें, प्रतीक्षा के बाद ग्रीन ग्रीन है। बेहतर है, और गहरे हरे रंग का पुनर्निर्धारण स्ट्रीम है।
यदि घटना को पुनर्निर्धारण करने से पहले होने का समय नहीं है, तो सब कुछ सरल है - धागा सो जाएगा और जागने का इंतजार करेगा:

शेड्यूलिंग

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

 static void sched_switch(struct thread *prev, struct thread *next) { sched_prepare_switch(prev, next); trace_point(__func__); /* Preserve initial semantics of prev/next. */ cpudata_var(saved_prev) = prev; thread_set_current(next); context_switch(&prev->context, &next->context); /* implies cc barrier */ prev = cpudata_var(saved_prev); sched_finish_switch(prev); } static void __schedule(int preempt) { struct thread *prev, *next; ipl_t ipl; prev = thread_self(); assert(!sched_in_interrupt()); ipl = spin_lock_ipl(&rq.lock); if (!preempt && prev->waiting) prev->ready = false; else __sched_enqueue(prev); next = runq_extract(&rq.queue); spin_unlock(&rq.lock); if (prev != next) sched_switch(prev, next); ipl_restore(ipl); assert(thread_self() == prev); if (!prev->siglock) { thread_signal_handle(); } } void schedule(void) { sched_lock(); __schedule(0); sched_unlock(); } 

परीक्षण मल्टीथ्रेडिंग

एक उदाहरण के रूप में, मैंने निम्नलिखित कोड का उपयोग किया:

 #include <stdint.h> #include <errno.h> #include <stdio.h> #include <util/array.h> #include <kernel/thread.h> #include <framework/example/self.h> /** * This macro is used to register this example at the system. */ EMBOX_EXAMPLE(run); /* configs */ #define CONF_THREADS_QUANTITY 0x8 /* number of executing threads */ #define CONF_HANDLER_REPEAT_NUMBER 300 /* number of circle loop repeats*/ /** The thread handler function. It's used for each started thread */ static void *thread_handler(void *args) { int i; /* print a thread structure address and a thread's ID */ for(i = 0; i < CONF_HANDLER_REPEAT_NUMBER; i ++) { printf("%d", *(int *)args); } return thread_self(); } /** * Example's executing routine * It has been declared by the macro EMBOX_EXAMPLE */ static int run(int argc, char **argv) { struct thread *thr[CONF_THREADS_QUANTITY]; int data[CONF_THREADS_QUANTITY]; void *ret; int i; /* starting all threads */ for(i = 0; i < ARRAY_SIZE(thr); i ++) { data[i] = i; thr[i] = thread_create(0, thread_handler, &data[i]); } /* waiting until all threads finish and print return value*/ for(i = 0; i < ARRAY_SIZE(thr); i ++) { thread_join(thr[i], &ret); } printf("\n"); return ENOERR; } 

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


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