अपरेटिङ सिस्टम को परिचय

नमस्ते, Habr! म तपाइँको ध्यान मा लेख को एक श्रृंखला प्रस्तुत गर्न चाहन्छु - एक साहित्य को अनुवाद जुन मेरो विचार मा रोचक छ - OSTEP। यो सामग्रीले युनिक्स-जस्तो अपरेटिङ सिस्टमहरूको कामलाई गहिरो रूपमा जाँच्छ, अर्थात्, प्रक्रियाहरू, विभिन्न शेड्यूलरहरू, मेमोरी र अन्य समान कम्पोनेन्टहरू जसले आधुनिक ओएस बनाउँछ। तपाईं यहाँ सबै सामग्रीको मूल हेर्न सक्नुहुन्छ यहाँ। कृपया ध्यान दिनुहोस् कि अनुवाद अव्यवसायिक रूपमा (धेरै स्वतन्त्र रूपमा) गरिएको थियो, तर मलाई आशा छ कि मैले सामान्य अर्थ राखेको छु।

यस विषयमा प्रयोगशाला काम यहाँ फेला पार्न सकिन्छ:

• मौलिक: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• मौलिक: github.com/remzi-arpacidusseau/ostep-code
• मेरो व्यक्तिगत रूपान्तरण: github.com/bykvaadm/OS/tree/master/ostep

अन्य भागहरू:

• भाग १: परिचय

तपाईं मेरो च्यानल मा पनि जाँच गर्न सक्नुहुन्छ टेलीग्राम =)

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

यसले समस्या खडा गर्छ: धेरै CPU हरूको भ्रम कसरी प्रदान गर्ने? OS ले कसरी लगभग असीमित संख्याको CPU हरूको भ्रम सिर्जना गर्न सक्छ, यदि तपाईंसँग एउटा मात्र भौतिक CPU छ भने पनि?

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

सार: प्रक्रिया

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

प्रक्रिया API

प्रक्रिया कसरी काम गर्छ भन्ने हाम्रो बुझाइमा सुधार गर्नको लागि, कुनै पनि अपरेटिङ सिस्टम इन्टरफेसमा समावेश गरिनु पर्ने प्रणाली कलहरूको उदाहरणहरू अध्ययन गरौं। यी API हरू कुनै पनि OS मा एक वा अर्को फारममा उपलब्ध छन्।

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

प्रक्रिया सिर्जना: विवरण

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

प्रारम्भिक अपरेटिङ सिस्टमहरूमा, लोडिङ प्रक्रिया उत्सुकताका साथ गरिएको थियो, जसको मतलब कार्यक्रम सुरु हुनु अघि सम्पूर्ण कोड मेमोरीमा लोड गरिएको थियो। आधुनिक अपरेटिङ सिस्टमहरूले यो अल्छी रूपमा गर्छन्, अर्थात्, कोड वा डाटाका टुक्राहरू लोड गर्ने कार्यहरू जब कार्यक्रमलाई कार्यान्वयनको क्रममा आवश्यक पर्दछ।

एक पटक कोड र स्थिर डेटा OS मेमोरीमा लोड भएपछि, त्यहाँ केही थप चीजहरू छन् जुन प्रक्रिया चलाउन अघि गर्न आवश्यक छ। स्ट्याकको लागि मेमोरीको केही मात्रा आवंटित हुनुपर्छ। कार्यक्रमहरूले स्थानीय चरहरू, प्रकार्य प्यारामिटरहरू, र फिर्ता ठेगानाहरूको लागि स्ट्याक प्रयोग गर्दछ। OS ले यो मेमोरी आवंटित गर्दछ र यसलाई प्रक्रियामा दिन्छ। स्ट्याकलाई केही तर्कहरूसँग पनि आवंटित गर्न सकिन्छ, विशेष गरी यसले मुख्य() प्रकार्यको प्यारामिटरहरू भर्छ, उदाहरणका लागि argc र argv को एरेसँग।

अपरेटिङ सिस्टमले कार्यक्रम हिपमा केही मेमोरी पनि आवंटित गर्न सक्छ। डायनामिक रूपमा आवंटित डाटाको लागि स्पष्ट रूपमा अनुरोध गर्न प्रोग्रामहरूद्वारा हीप प्रयोग गरिन्छ। कार्यक्रमहरूले प्रकार्यलाई कल गरेर यो ठाउँ अनुरोध गर्दछ malloc () र प्रकार्यलाई कल गरेर स्पष्ट रूपमा खाली गर्दछ नि:शुल्क()। लिङ्क गरिएको पानाहरू, ह्यास तालिकाहरू, रूखहरू र अन्य जस्ता डेटा संरचनाहरूको लागि ढेर आवश्यक छ। सुरुमा, मेमोरीको सानो मात्रा हिपमा आवंटित गरिन्छ, तर समयको साथ, कार्यक्रम चल्दै जाँदा, हिपले लाइब्रेरी API कल malloc() मार्फत थप मेमोरी अनुरोध गर्न सक्छ। अपरेटिङ सिस्टम यी कलहरू पूरा गर्न मद्दत गर्न थप मेमोरी आवंटित गर्ने प्रक्रियामा संलग्न छ।

अपरेटिङ सिस्टमले प्रारम्भिक कार्यहरू पनि गर्नेछ, विशेष गरी ती I/O सँग सम्बन्धित। उदाहरणका लागि, UNIX प्रणालीहरूमा, प्रत्येक प्रक्रियामा पूर्वनिर्धारित रूपमा 3 खुला फाइल वर्णनकर्ताहरू छन्, मानक इनपुट, आउटपुट, र त्रुटिका लागि। यी ह्यान्डलहरूले प्रोग्रामहरूलाई टर्मिनलबाट इनपुट पढ्न र स्क्रिनमा जानकारी प्रदर्शन गर्न अनुमति दिन्छ।

यसरी, मेमोरीमा कोड र स्थिर डाटा लोड गरेर, स्ट्याक सिर्जना र प्रारम्भ गरेर, र I/O कार्यहरू गर्न सम्बन्धित अन्य कामहरू गरेर, OS ले प्रक्रिया कार्यान्वयन गर्न चरण तयार गर्दछ। अन्तमा, त्यहाँ एउटा अन्तिम कार्य बाँकी छ: कार्यक्रमलाई यसको प्रविष्टि बिन्दु मार्फत चलाउने, मुख्य() प्रकार्य भनिन्छ। main() प्रकार्य कार्यान्वयन गरेर, OS ले CPU नियन्त्रणलाई नयाँ सिर्जना प्रक्रियामा स्थानान्तरण गर्दछ, यसरी कार्यक्रम कार्यान्वयन गर्न सुरु हुन्छ।

प्रक्रिया अवस्था

अब हामीले प्रक्रिया के हो र यो कसरी सिर्जना हुन्छ भन्ने बारे केही बुझेका छौँ, त्यसमा हुनसक्ने प्रक्रियालाई सूचीबद्ध गरौं। यसको सरल रूप मा, एक प्रक्रिया यी राज्यहरु मध्ये एक हुन सक्छ:
● दौडने। चलिरहेको बेला, प्रक्रिया प्रोसेसरमा चल्छ। यसको मतलब निर्देशनहरू कार्यान्वयन भइरहेको छ।
● तयार। तयार अवस्थामा, प्रक्रिया चलाउनको लागि तयार छ, तर कुनै कारणले OS ले निर्दिष्ट समयमा यसलाई कार्यान्वयन गर्दैन।
● अवरुद्ध। अवरुद्ध अवस्थामा, एक प्रक्रियाले केहि अपरेशनहरू गर्दछ जसले यसलाई कार्यान्वयन गर्न तयार हुनबाट रोक्छ जबसम्म केही घटना देखा पर्दैन। एउटा सामान्य उदाहरण हो जब कुनै प्रक्रियाले IO अपरेशन प्रारम्भ गर्छ, यो अवरुद्ध हुन्छ ताकि केही अन्य प्रक्रियाले प्रोसेसर प्रयोग गर्न सक्छ।

तपाईले यी अवस्थाहरूलाई ग्राफको रूपमा कल्पना गर्न सक्नुहुन्छ। हामीले तस्विरमा देख्न सक्छौं, प्रक्रियाको अवस्था OS को विवेकमा चलिरहेको र तयार बीचमा परिवर्तन हुन सक्छ। जब प्रक्रियाको अवस्था READY बाट RUNNING मा परिवर्तन हुन्छ, यसको मतलब प्रक्रिया निर्धारित गरिएको छ। विपरित दिशामा - लेआउटबाट हटाइयो। यस क्षणमा जब कुनै प्रक्रिया अवरुद्ध हुन्छ, उदाहरणका लागि, म IO सञ्चालन सुरु गर्छु, OS ले यसलाई यस अवस्थामा राख्छ जबसम्म केही घटनाहरू देखा पर्दैन, उदाहरणका लागि IO को समाप्ति। यस क्षणमा READY स्थितिमा संक्रमण र सम्भवतः तुरुन्तै चलिरहेको अवस्थामा यदि OS ले निर्णय गर्छ भने।
यी अवस्थाहरूमा कसरी दुई प्रक्रियाहरू सर्छन् भन्ने उदाहरण हेरौं। सुरु गर्नको लागि, कल्पना गरौं कि दुबै प्रक्रियाहरू चलिरहेका छन्, र प्रत्येकले CPU मात्र प्रयोग गरिरहेको छ। यस अवस्थामा, तिनीहरूको राज्य यस्तो देखिन्छ।

निम्न उदाहरणमा, पहिलो प्रक्रिया, केहि समय चलेको पछि, IO अनुरोध गर्दछ र BLOCKED स्थितिमा प्रवेश गर्दछ, अर्को प्रक्रिया चलाउन अनुमति दिँदै (FIG 1.4)। OS ले देख्छ कि प्रक्रिया 0 ले CPU प्रयोग गरिरहेको छैन र प्रक्रिया 1 सुरु हुन्छ। प्रक्रिया 1 चलिरहेको बेला, IO पूरा हुन्छ र प्रक्रिया 0 को स्थिति READY मा परिवर्तन हुन्छ। अन्तमा, प्रक्रिया 1 पूरा भयो, र पूरा भएपछि, प्रक्रिया 0 सुरु हुन्छ, कार्यान्वयन हुन्छ, र यसको काम समाप्त हुन्छ।

डाटा संरचना

OS आफैमा एउटा प्रोग्राम हो, र कुनै पनि अन्य प्रोग्राम जस्तै, यसमा केही प्रमुख डेटा संरचनाहरू छन् जसले जानकारीका विभिन्न सान्दर्भिक टुक्राहरूको ट्रयाक राख्छ। प्रत्येक प्रक्रियाको अवस्था ट्र्याक गर्न, OS ले केही समर्थन गर्नेछ प्रक्रिया सूची READY स्थितिमा भएका सबै प्रक्रियाहरूको लागि र हाल चलिरहेका प्रक्रियाहरू ट्र्याक गर्न केही थप जानकारी। साथै, OS ले अवरुद्ध प्रक्रियाहरू निगरानी गर्नुपर्छ। IO पूरा भएपछि, OS ले आवश्यक प्रक्रियालाई जगाउनु पर्छ र यसलाई चलाउनको लागि तयार अवस्थामा राख्नुपर्छ।

उदाहरणका लागि, OS ले प्रोसेसर दर्ताको अवस्था सुरक्षित गर्नुपर्छ। प्रक्रिया रोकिने क्षणमा, दर्ताहरूको अवस्था प्रक्रियाको ठेगाना ठाउँमा भण्डार गरिएको छ, र यसको सञ्चालन जारी रहँदा, दर्ताहरूको मानहरू पुनर्स्थापित हुन्छन् र यसरी यस प्रक्रियाको कार्यान्वयन जारी राख्छन्।

तयार, अवरुद्ध, चलिरहेको राज्यहरू बाहेक, त्यहाँ केही अन्य राज्यहरू छन्। कहिलेकाहीँ, सिर्जनाको समयमा, प्रक्रिया INIT स्थितिमा हुन सक्छ। अन्तमा, एक प्रक्रिया अन्तिम अवस्थामा राख्न सकिन्छ जब यो पहिले नै पूरा भएको छ, तर यसको जानकारी अझै खाली गरिएको छैन। UNIX प्रणालीहरूमा यो अवस्था भनिन्छ जोम्बी प्रक्रिया। यो अवस्था मामिलाहरूको लागि उपयोगी छ जहाँ अभिभावक प्रक्रियाले बच्चाको फिर्ता कोड जान्न चाहन्छ, उदाहरणका लागि, सामान्यतया 0 ले सफलता र 1 त्रुटि संकेत गर्दछ, तर प्रोग्रामरहरूले विभिन्न समस्याहरू सङ्केत गर्न थप आउटपुट कोडहरू जारी गर्न सक्छन्। जब अभिभावक प्रक्रिया समाप्त हुन्छ, यसले अन्तिम प्रणाली कल गर्दछ, जस्तै wait(), बच्चा प्रक्रिया समाप्त हुनको लागि पर्खन र OS लाई संकेत गर्दछ कि यसले समाप्त प्रक्रियासँग सम्बन्धित कुनै पनि डाटा खाली गर्न सक्छ।

व्याख्यानको मुख्य बुँदाहरू:

● प्रक्रिया - OS मा चलिरहेको कार्यक्रम को मुख्य सार। कुनै पनि समयमा, प्रक्रियालाई यसको अवस्थाद्वारा वर्णन गर्न सकिन्छ: यसको ठेगाना स्पेसमा मेमोरीको सामग्री, प्रोसेसर दर्ताका सामग्रीहरू, निर्देशन सूचक र स्ट्याक सूचक सहित, र IO जानकारी, जस्तै खुला फाइलहरू पढ्न वा लेखिएको।
● प्रक्रिया API कलहरू समावेश हुन्छन् जुन प्रोग्रामहरूले प्रक्रियाहरूमा गर्न सक्छन्। सामान्यतया यी सिर्जना, मेटाउन, वा अन्य कलहरू हुन्।
● प्रक्रिया चलिरहेको, तयार, अवरुद्ध सहित धेरै राज्यहरू मध्ये एकमा छ। विभिन्न घटनाहरू जस्तै समयतालिका, समयतालिकाबाट अपवादहरू, वा पर्खाइहरूले प्रक्रियाको अवस्था एकबाट अर्कोमा परिवर्तन गर्न सक्छन्।
● प्रक्रिया सूची प्रणालीमा सबै प्रक्रियाहरूको बारेमा जानकारी समावेश गर्दछ। यसमा प्रत्येक प्रविष्टिलाई प्रक्रिया नियन्त्रण ब्लक भनिन्छ, जुन वास्तवमा एक संरचना हो जुन एक विशिष्ट प्रक्रियाको बारेमा सबै आवश्यक जानकारी समावेश गर्दछ। 

स्रोत: www.habr.com