Multitasking (အလုပ် အများကို တစ်ပြိုင်နက်လို လုပ်ခြင်း)

A1.3.5: Explain the role of the OS in managing multitasking and resource allocation
မြန်မာလို: Multitasking နဲ့ resource allocation (process တွေကို CPU အချိန်၊ memory စတဲ့ resource တွေ ခွဲဝေပေးခြင်း) ကို စီမံရာမှာ OS (operating system၊ ကွန်ပျူတာကို စီမံတဲ့ အဓိက software) ရဲ့ အခန်းကဏ္ဍကို explain (ရှင်းပြ) လုပ်နိုင်ရပါမယ်။

ဒီစာမျက်နှာ တစ်ခုလုံးက HL အဆင့်မှာပဲ အကဲဖြတ် စစ်ဆေးတဲ့ အကြောင်းအရာ ဖြစ်ပါတယ်။ SL (Standard Level) နဲ့ HL (Higher Level) ဆိုတာ IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) သင်တန်းရဲ့ အဆင့်နှစ်ဆင့်ဖြစ်ပြီး HL အပိုင်းတွေက ပိုနက်နက်ရှိုင်းရှိုင်း လေ့လာရတဲ့ အပိုင်းတွေပါ။

အဓိက အယူအဆများ

Multitasking နဲ့ Multiprocessing (A1.3.5)

ခေတ်သစ် ကွန်ပျူတာတွေမှာ program အများကြီး တစ်ချိန်တည်း run နေသလို ထင်ရပါတယ်: သီချင်း နားထောင်ရင်း web စာမျက်နှာတွေ ကြည့်ပြီး file တစ်ခုကိုလည်း တစ်ပြိုင်နက် download လုပ်နိုင်ပါတယ်။ ဒါပေမယ့် OS က ဒါကို ဘယ်လို လုပ်ပေးသလဲ။

Multitasking ဆိုတာ OS က CPU (ကွန်ပျူတာရဲ့ အဓိက processor) အချိန်ကို process (run နေတဲ့ program) အများကြား ခွဲဝေပေးပြီး အဲဒီ process တွေကို concurrently (အချိန်ကာလ တစ်ခုတည်းအတွင်း အတူ ဆက်လုပ်နေအောင်) run ပေးနိုင်စွမ်းပါ။ CPU core (ညွှန်ကြားချက်တွေကို သီးခြား run နိုင်တဲ့ processor ထဲက processing unit) တစ်ခုတည်း ပေါ်မှာတောင် အလုပ်လုပ်ပါတယ်။ Core က process တွေကြား အမြန် ပြောင်းပြီး process တစ်ခုစီကို time slice (process တစ်ခုကို ပေးတဲ့ CPU အချိန် အပိုင်းလေး) အသေးလေး တစ်ခုစီ ပေးပါတယ်။ ပြောင်းတာ အရမ်းမြန်လို့ (တစ်စက္ကန့်မှာ အကြိမ် ထောင်ချီ) illusion of parallelism (တကယ် တစ်ပြိုင်နက် မဟုတ်ပေမယ့် တစ်ပြိုင်နက် run နေသလို ထင်ရခြင်း) ကို ဖြစ်စေပါတယ်: အရာအားလုံး တစ်ပြိုင်နက် run နေသလို ထင်ရပေမယ့် ဘယ်အချိန် ခဏမှာမဆို core တစ်ခုစီက process တစ်ခုကိုပဲ execute (run) လုပ်နေတာပါ။

Multiprocessing (CPU ဒါမှမဟုတ် core အများနဲ့ process တွေကို တကယ် တစ်ပြိုင်နက် run ခြင်း) က process တွေကို တကယ့် parallel execution (တစ်ပြိုင်နက် လုပ်ဆောင်ခြင်း) နဲ့ execute လုပ်ဖို့ CPU ဒါမှမဟုတ် core အများ ကို သုံးပါတယ်။ Quad-core (core လေးခု ပါတဲ့) processor တစ်ခုက core တစ်ခုမှာ process တစ်ခုစီနဲ့ process လေးခုကို တကယ်ကို တစ်ချိန်တည်း run နိုင်ပါတယ်။ ခေတ်သစ် ကွန်ပျူတာ အများစုက multiprocessing (core အများ) နဲ့ multitasking ကို ပေါင်းသုံးကြပါတယ်: core တစ်ခုစီက process အများကြားမှာ time-sharing (CPU အချိန်ကို အလှည့်ကျ ခွဲဝေ မျှသုံးခြင်း) လုပ်ပါတယ်။

Multithreading (process တစ်ခုကို thread တွေ ခွဲပြီး run ခြင်း) ဆိုတာ process တစ်ခုကို thread (program ထဲမှာ သီးခြား run နေတဲ့ အလုပ်လမ်းကြောင်း) တွေအဖြစ် ခွဲလိုက်တာပါ: thread တွေက memory (မှတ်ဉာဏ်) နေရာ တစ်ခုတည်းကို မျှသုံးတဲ့ ပေါ့ပါးတဲ့ အလုပ်ခွဲလေးတွေပါ။ ဥပမာ web browser (ဝဘ်စာမျက်နှာ ဖွင့်တဲ့ software) တစ်ခုက စာမျက်နှာကို render (ပုံဖော်) လုပ်ဖို့ thread တစ်ခု၊ ပုံတွေ download လုပ်ဖို့ နောက်တစ်ခု၊ JavaScript run ဖို့ တတိယ တစ်ခု သုံးနိုင်ပါတယ်။ Process တစ်ခုတည်းထဲက thread တွေက heap memory (object တွေကို သိမ်းထားတဲ့ memory အပိုင်း) နဲ့ ဖွင့်ထားတဲ့ file တွေလို resource (သုံးလို့ရတဲ့ ကွန်ပျူတာ အရင်းအမြစ်) တွေကို မျှသုံးကြပေမယ့် thread တစ်ခုစီမှာ ကိုယ်ပိုင် stack (အပေါ်ကနေပဲ ထည့်၊ ထုတ်တဲ့ အထပ်) နဲ့ program counter (နောက် run မယ့် instruction ရဲ့ address ကို သိမ်းတဲ့ register) ရှိပါတယ်။

အယူအဆ အဓိက အချက် Parallelism (တစ်ပြိုင်နက် လုပ်နိုင်မှု)
Multitasking Process အများက time-sharing နဲ့ CPU အချိန်ကို မျှသုံးကြပါတယ် Core တစ်ခုပေါ်မှာ တစ်ပြိုင်နက်လို ထင်ရရုံပါ၊ core အများပေါ်မှာ တကယ် တစ်ပြိုင်နက်ပါ
Multiprocessing CPU/core အများ၊ တစ်ပြိုင်နက် execute လုပ်ခြင်း တကယ် တစ်ပြိုင်နက်ပါ
Multithreading Process တစ်ခု၊ thread အများ၊ memory ကို မျှသုံးခြင်း Multi-core (core အများကြီး ပါတဲ့ CPU) မှာ တကယ် တစ်ပြိုင်နက် ဖြစ်နိုင်ပြီး single-core (core တစ်ခုတည်း ပါတဲ့) CPU မှာ တစ်ပြိုင်နက်လို ထင်ရရုံ ဖြစ်နိုင်ပါတယ်

ရောထွေးလွယ်ပါတယ်: Multitasking နဲ့ multiprocessing ကို မရောပါနဲ့။ Multitasking ဆိုတာ OS က အလုပ်တွေကြား အမြန် ပြောင်းပေးပြီး CPU အချိန်ကို ခွဲဝေပေးတာပါ။ Core တစ်ခုတည်းမှာ ဒါက concurrent ဖြစ်ပေမယ့် တကယ့် parallel မဟုတ်ပါဘူး။ Multiprocessing ဆိုတာ CPU/core အများက အလုပ်တွေကို တစ်ချိန်တည်းမှာ execute လုပ်တာပါ (တကယ့် parallel)။ Multicore ကွန်ပျူတာ တစ်လုံးက နှစ်မျိုးလုံးကို လုပ်ပါတယ်။

Context Switching (process တစ်ခုကနေ တစ်ခုကို CPU ပြောင်းခြင်း)

OS က process တစ်ခုကို run နေရာကနေ နောက် process တစ်ခုကို ပြောင်း run တဲ့အခါ context switch ကို လုပ်ပါတယ်။ Multitasking ကို ဖြစ်နိုင်အောင် လုပ်ပေးတဲ့ နည်းလမ်းက ဒါပါပဲ။

ဘာတွေကို save (သိမ်း) ပြီး load (ပြန်ထည့်) လုပ်သလဲ။ Process တစ်ခုစီမှာ Process Control Block (PCB) တစ်ခု ရှိပါတယ်: PCB ဆိုတာ process ကို ခဏ ရပ်ပြီး ပြန်ဆက် run ဖို့ လိုတဲ့ အချက်အလက် အားလုံးကို သိမ်းထားပေးတဲ့၊ OS က ထိန်းသိမ်းထားတဲ့ data structure (ဒေတာ သိမ်းဆည်းပုံ) တစ်ခုပါ:

PCB ထဲက အကွက် သိမ်းထားတဲ့ အရာ
Program Counter (PC) Execute လုပ်ရမယ့် နောက် instruction (processor လုပ်ဆောင်ရမယ့် ညွှန်ကြားချက်) ရဲ့ address (memory ထဲက နေရာ လိပ်စာ)
Register (CPU ထဲက အမြန်ဆုံး သိမ်းဆည်းရာ) တန်ဖိုးများ R1၊ R2၊ accumulator (ALU တွက်ချက်မှု ရလဒ်ကို သိမ်းတဲ့ register) စတဲ့ CPU register အားလုံးထဲက တန်ဖိုးတွေ
Process state (process ရဲ့ လက်ရှိ အခြေအနေ) Ready (အဆင်သင့်)၊ Running (run နေ) ဒါမှမဟုတ် Waiting (စောင့်နေ)
Memory management (memory ကို စီမံခန့်ခွဲခြင်း) အချက်အလက် Page table (virtual memory page တွေ memory ထဲ ဘယ်မှာ ရှိလဲ မှတ်ထားတဲ့ ဇယား) တွေ၊ base/limit register (process ရဲ့ memory အပိုင်း ဘယ် address က စပြီး ဘယ်လောက် ကျယ်လဲ မှတ်တဲ့ register) တွေ
I/O (ဒေတာ အဝင်အထွက်) အခြေအနေ ဖွင့်ထားတဲ့ file တွေ၊ မပြီးသေးတဲ့ I/O တောင်းဆိုချက်တွေ
Process ID (PID) Process တစ်ခုချင်းကို ခွဲခြားပေးတဲ့ မထပ်တဲ့ အမှတ်အသား
Priority (ဦးစားပေး အဆင့်) Scheduling (ဘယ် process ကို CPU အချိန် ပေးမလဲ ဆုံးဖြတ်ခြင်း) မှာ သုံးတဲ့ ဦးစားပေး အဆင့်

Context Switch ရဲ့ အဆင့်များ

  1. Timer interrupt (သတ်မှတ်ထားတဲ့ အချိန် ပြည့်တိုင်း CPU ကို ခဏ ရပ်ခိုင်းတဲ့ signal) ဖြစ်ပါတယ်၊ ဒါမှမဟုတ် process က I/O ပြီးတာကို စောင့်ရလို့ block ဖြစ် (ရပ်ပြီး စောင့်) သွားပါတယ်
  2. OS က လက်ရှိ process ရဲ့ state (အခြေအနေ) ကို သူ့ PCB ထဲ save လုပ်ပါတယ် (register တွေ၊ PC၊ state က Running ကနေ Ready ကို ပြောင်းသွားပါတယ်၊ I/O ကို စောင့်ရလို့ block ဖြစ်သွားတာဆိုရင်တော့ Waiting ကို ပြောင်းသွားပါတယ်)
  3. OS က scheduling algorithm (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း) ကို သုံးပြီး နောက် run မယ့် process ကို ရွေးပါတယ်
  4. OS က process အသစ်ရဲ့ PCB ကို CPU register တွေထဲ load လုပ်ပြီး PC ကို သတ်မှတ်ပါတယ်
  5. Process အသစ်က နောက်ဆုံး ရပ်ခဲ့တဲ့ နေရာကနေ ဆက် run ပါတယ်
Process P1 running
     |
     v
[Timer interrupt fires]
     |
     v
Save P1 state to PCB1:  PC=100, R1=42, R2=7, State=Ready
     |
     v
Load P2 state from PCB2: PC=200, R1=15, R2=3, State=Running
     |
     v
Process P2 running

ပုံထဲက စာတွေရဲ့ အဓိပ္ပာယ်: Process P1 running (P1 run နေတယ်) → Timer interrupt fires (timer interrupt ဖြစ်တယ်) → Save P1 state to PCB1 (P1 ရဲ့ state ကို PCB1 ထဲ save လုပ်တယ်) → Load P2 state from PCB2 (P2 ရဲ့ state ကို PCB2 ကနေ load လုပ်တယ်) → Process P2 running (P2 run နေတယ်)။

Context switching မှာ overhead (အပို ကုန်ကျတဲ့ အချိန်နဲ့ အလုပ်) ရှိပါတယ်: ပြောင်းနေတဲ့ အချိန်အတွင်း CPU က ဘယ် process အတွက်မှ အသုံးဝင်တဲ့ အလုပ် မလုပ်ပါဘူး။ စီမံခန့်ခွဲရေး အလုပ်သက်သက်ပါ။ OS က မကြာခဏ ပြောင်းလွန်းရင် (time slice အရမ်း သေးရင်) CPU အချိန် အများကြီးကို ပြောင်းရတာနဲ့ပဲ ဖြုန်းမိပါတယ်။ OS က ကြာမှ တစ်ခါ ပြောင်းရင် (time slice အရမ်း ကြီးရင်) responsiveness (user လုပ်တာကို မြန်မြန် တုံ့ပြန်နိုင်မှု) ကျသွားပါတယ်။ Scheduler (နောက် ဘယ် process run မလဲ ဆုံးဖြတ်တဲ့ OS အစိတ်အပိုင်း) က ဒီ trade-off (တစ်ခု ရဖို့ တစ်ခု အလျှော့ပေးရတာ) တွေကို ချိန်ညှိရပါတယ်။

Resource Contention (resource တစ်ခုတည်းကို process အများ တစ်ပြိုင်နက် လိုချင်ကြခြင်း)

Resource contention က process အများက resource တစ်ခုတည်း ကို တစ်ချိန်တည်းမှာ လိုအပ်တဲ့အခါ ဖြစ်ပါတယ်။ Resource တွေထဲမှာ ဒါတွေ ပါပါတယ်:

  • CPU အချိန်: process တွေ အများဆုံး လုကြတဲ့ resource
  • Memory: RAM (ပါဝါပိတ်ရင် ပျောက်တဲ့ အဓိက memory) အစစ်၊ virtual memory (RAM ပြည့်ရင် disk နေရာကို memory အဖြစ် ချေးသုံးခြင်း) page တွေ
  • File တွေ: file တစ်ခုတည်းကို ဖတ်တာ ဒါမှမဟုတ် ရေးတာ
  • I/O device (ဒေတာ အဝင်အထွက် စက်ပစ္စည်း) တွေ: printer တွေ၊ disk drive တွေ၊ network interface (network နဲ့ ချိတ်ပေးတဲ့ hardware) တွေ
  • Network ချိတ်ဆက်မှုတွေ: socket (program တစ်ခုရဲ့ network ချိတ်ဆက်မှု အဆုံးမှတ်) တွေ၊ bandwidth (တစ်စက္ကန့်မှာ ပို့နိုင်တဲ့ ဒေတာ အများဆုံး)

OS က မျှသုံးတဲ့ resource တွေကို ယူသုံးတာကို ကြားဝင် ထိန်းညှိ ပေးရပါတယ်။ ဒီလို ဖြစ်အောင် သေချာစေရပါတယ်:

  • Process တစ်ခုရဲ့ ဒေတာကို နောက် process တစ်ခုက မဖျက်ဆီးမိဖို့
  • Resource တွေကို တရားမျှတစွာ ခွဲဝေပေးဖို့
  • စနစ်က မြန်မြန် ဆက်တုံ့ပြန်နေဖို့

Resource တွေကို မှန်မှန်ကန်ကန် မစီမံရင် process တွေက တစ်ခုရဲ့ ဒေတာကို နောက်တစ်ခုက overwrite (ရှိပြီးသား content ကို ဖျက်ပြီး အသစ် ရေးခြင်း) လုပ်မိတာ၊ တစ်ဝက်တစ်ပျက်ပဲ ရေးရသေးတဲ့ file တွေကို ဖတ်မိတာ ဒါမှမဟုတ် hardware ချင်း တိုက်မိတာမျိုး ဖြစ်နိုင်ပါတယ်။

Mutual Exclusion (တစ်ကြိမ်မှာ process တစ်ခုတည်းကိုပဲ resource သုံးခွင့်ပေးခြင်း)

Mutual exclusion ဆိုတာ မျှသုံးတဲ့ resource တစ်ခုကို တစ်ကြိမ်မှာ process တစ်ခုတည်း ကပဲ ယူသုံးနိုင်အောင် သေချာစေတဲ့ နည်းလမ်းပါ။ Process တစ်ခုက resource ကို သုံးနေတဲ့အခါ တခြား process အားလုံးက အဲဒီ resource ကို ပြန်လွှတ်တဲ့အထိ စောင့်ရပါတယ်။

ဘာကြောင့် လိုအပ်သလဲ

Process နှစ်ခုက file တစ်ခုတည်းထဲကို တစ်ပြိုင်နက် ရေးနေတယ်လို့ စဉ်းစားကြည့်ပါ။ Mutual exclusion မရှိရင် သူတို့ ရေးတာတွေ ရောယှက်သွားပြီး ပျက်စီးနေတဲ့ ရလဒ် ထွက်လာနိုင်ပါတယ်။ Mutual exclusion က process တစ်ခု ရေးတာ လုံးဝ ပြီးမှ နောက် process က စရေးအောင် သေချာစေပါတယ်။

Mutual Exclusion ကို လုပ်ဆောင်တဲ့ နည်းလမ်းများ

Semaphore တွေ: process တွေကြား အချက်ပြဖို့ သုံးတဲ့ integer (ကိန်းပြည့်) variable (တန်ဖိုး သိမ်းထားတဲ့ နာမည်ပေးထားတဲ့ နေရာ) တွေပါ:

  • Binary semaphore: 0 ဒါမှမဟုတ် 1 ပဲ ဖြစ်နိုင်ပါတယ်: 0 က locked (သော့ခတ်ထား)၊ 1 က unlocked (သော့ဖွင့်ထား) ပါ။ Semaphore က 0 ဖြစ်နေရင် process က wait (စောင့်) လုပ်ပြီး ပြီးသွားရင် signal (1 လို့ သတ်မှတ်) လုပ်ပါတယ်။ Lock (သော့) ကို တစ်ကြိမ်မှာ process တစ်ခုတည်းကပဲ ကိုင်ထားနိုင်လို့ mutex (lock ကို ကိုင်ထားတဲ့ process ကပဲ ပြန်ဖွင့်ခွင့်ရှိတဲ့ lock) နဲ့ အတော်လေး ဆင်တူစွာ အလုပ်လုပ်ပါတယ်။
  • Counting semaphore: resource အစု တစ်ခုကို process N ခုအထိ တစ်ပြိုင်နက် ယူသုံးခွင့်ပေးပါတယ်။ Process တွေက resource ကို acquire (ယူ) လုပ်တိုင်း semaphore က 1 လျော့ပြီး release (ပြန်လွှတ်) လုပ်တိုင်း 1 တိုးပါတယ်။ 0 ရောက်သွားရင် နောက်ထပ် တောင်းဆိုချက်တွေက စောင့်ရပါတယ်။

Lock တွေ: ရိုးရှင်းတဲ့ acquire/release နည်းလမ်းပါ။ Process က critical section (မျှသုံးတဲ့ resource ကို ယူသုံးတဲ့ code အပိုင်း) ထဲ မဝင်ခင် lock ကို acquire လုပ်ပြီး ပြီးသွားရင် release လုပ်ပါတယ်။

Monitor တွေ: မျှသုံးတဲ့ ဒေတာ၊ အဲဒီ ဒေတာပေါ်မှာ လုပ်တဲ့ operation (ဒေတာပေါ်မှာ လုပ်တဲ့ လုပ်ဆောင်ချက်) တွေနဲ့ synchronisation (process တွေ အလုပ်လုပ်ချိန်ကို ညှိပေးခြင်း) ကို ယူနစ် တစ်ခုတည်းအဖြစ် ထုပ်ပိုးထားတဲ့ အဆင့်မြင့် synchronisation နည်းလမ်း တစ်ခုပါ။ Monitor ရဲ့ operation တွေထဲက ဘယ်ဟာကိုမဆို တစ်ကြိမ်မှာ process တစ်ခုတည်းကပဲ execute လုပ်နိုင်ပါတယ်။

Semaphore ကို မုန့်တိုက်က တန်းစီ လက်မှတ် စနစ်လို့ မြင်ကြည့်ပါ။ Binary semaphore မှာ လက်မှတ် တစ်စောင်ပဲ ရှိပါတယ် (တစ်ကြိမ်မှာ ဝယ်သူ တစ်ယောက်ကိုပဲ ဝန်ဆောင်ပေးပါတယ်)။ N=3 ရှိတဲ့ counting semaphore မှာ လက်မှတ် သုံးစောင် ရှိပါတယ် (ဝယ်သူ သုံးယောက်ကို တစ်ပြိုင်နက် ဝန်ဆောင်ပေးနိုင်ပါတယ်)။ လက်မှတ်တွေ အကုန် ကုန်သွားရင် ဝယ်သူ အသစ်တွေက စောင့်ရပါတယ်။

Deadlock (အချင်းချင်း စောင့်ရင်း ပိတ်မိနေခြင်း)

Deadlock ဆိုတာ process နှစ်ခု ဒါမှမဟုတ် ပိုများတဲ့ process တွေ အမြဲတမ်း ပိတ်မိ (block ဖြစ်) နေတဲ့ အခြေအနေပါ: process တစ်ခုစီက အုပ်စုထဲက တခြား process တစ်ခု ကိုင်ထားတဲ့ resource ကို စောင့်နေကြပါတယ်။ Process တစ်ခုစီက တစ်ဖက်က resource ကို အရင် ပြန်လွှတ်ဖို့ စောင့်နေကြလို့ ဘယ် process မှ ရှေ့ဆက် မသွားနိုင်ပါဘူး။

မဖြစ်မနေ ရှိရမယ့် အခြေအနေ လေးခု

Deadlock ဖြစ်ဖို့ဆိုရင် အောက်က အခြေအနေ လေးခုလုံး တစ်ပြိုင်နက် ရှိနေရပါမယ်။ တစ်ခုကိုတောင် တားဆီးထားနိုင်ရင် deadlock မဖြစ်နိုင်ပါဘူး။

  1. Mutual exclusion: အနည်းဆုံး resource တစ်ခုကို မျှသုံးလို့ မရပါဘူး (တစ်ကြိမ်မှာ process တစ်ခုတည်းကပဲ သုံးနိုင်ပါတယ်)
  2. Hold and wait (ကိုင်ထားရင်း စောင့်ခြင်း): process တစ်ခုက resource အနည်းဆုံး တစ်ခုကို ကိုင်ထားရင်း နောက်ထပ် resource တစ်ခုကို ရဖို့ စောင့်နေပါတယ်
  3. No preemption (အတင်း ပြန်ယူလို့ မရခြင်း): resource တွေကို process ဆီကနေ အတင်း ယူလို့ မရပါဘူး၊ process ကိုယ်တိုင် ဆန္ဒအလျောက် ပြန်လွှတ်မှ ရပါတယ်
  4. Circular wait (စက်ဝိုင်းပုံ စောင့်ဆိုင်းခြင်း): process တွေရဲ့ ကွင်းဆက် တစ်ခု ရှိနေပြီး process တစ်ခုစီက ကွင်းဆက်ထဲက နောက် process ကိုင်ထားတဲ့ resource ကို စောင့်နေပါတယ်

Circular Wait ကို ပြတဲ့ ပုံ 

Process A holds Resource 1
    |
    waits for Resource 2
    |
Process B holds Resource 2
    |
    waits for Resource 1
    |
(Deadlock!)

ပုံထဲက စာတွေရဲ့ အဓိပ္ပာယ်: Process A holds Resource 1 (Process A က Resource 1 ကို ကိုင်ထားတယ်)၊ waits for Resource 2 (Resource 2 ကို စောင့်နေတယ်)၊ Process B holds Resource 2 (Process B က Resource 2 ကို ကိုင်ထားတယ်)၊ waits for Resource 1 (Resource 1 ကို စောင့်နေတယ်)။

ဘယ် process မှ ရှေ့မတိုးနိုင်ပါဘူး။ Process A က Resource 2 ကို မရမချင်း Resource 1 ကို ပြန်မလွှတ်ပါဘူး၊ ဒါပေမယ့် Resource 2 ကို Process B က ကိုင်ထားပြီး Resource 1 ကို မရမချင်း ပြန်မလွှတ်ပါဘူး။

Deadlock ဖြစ်ဖို့ လိုတဲ့ အခြေအနေ လေးခုလုံးကို စာရင်း ပြောနိုင်ရပါမယ်၊ ပြီးတော့ တစ်ခုစီက ပေးထားတဲ့ အခြေအနေ (scenario) တစ်ခုမှာ ဘယ်လို ဖြစ်နေလဲဆိုတာကိုလည်း ရှင်းပြနိုင်ရပါမယ်။ မမေ့ပါနဲ့: deadlock ဖြစ်ဖို့ လေးခုလုံး တစ်ပြိုင်နက် ရှိနေရပါမယ်။

Deadlock ကို ကိုင်တွယ်တဲ့ နည်းဗျူဟာများ

နည်းဗျူဟာ လုပ်ပုံ အားသာချက် အားနည်းချက်
Prevention (ကြိုတင် တားဆီးခြင်း) အခြေအနေ လေးခုထဲက အနည်းဆုံး တစ်ခု မဖြစ်နိုင်အောင် စနစ်ကို ဒီဇိုင်းလုပ်ပါတယ် Deadlock မဖြစ်နိုင်ပါဘူး Resource ကို ထိရောက်စွာ အသုံးချနိုင်မှု ဒါမှမဟုတ် throughput (အချိန် တစ်ခုအတွင်း လုပ်ပြီးနိုင်တဲ့ အလုပ် ပမာဏ) ကို လျော့ကျစေနိုင်ပါတယ်
Avoidance (ရှောင်ရှားခြင်း) တောင်းဆိုချက် တစ်ခုကို ခွင့်ပြုရင် deadlock ဖြစ်လာနိုင်မလား စနစ် run နေစဉ် တောင်းဆိုချက်တိုင်းမှာ စစ်ပါတယ် Prevention ထက် resource ကို ပိုပြောင်းလွယ်ပြင်လွယ် သုံးခွင့်ပေးပါတယ် Process တွေ လိုမယ့် resource ကို ကြိုသိထားဖို့ လိုပါတယ်၊ တွက်ချက်ရတာ အကုန်အကျ များပါတယ်
Detection (ရှာဖွေ တွေ့ရှိခြင်း) Deadlock ဖြစ်ခွင့်ပေးပြီးမှ ရှာတွေ့အောင် လုပ်ပြီး ပြန်ကောင်းအောင် လုပ်ပါတယ် ပုံမှန် အလုပ်လုပ်နေချိန်မှာ overhead နည်းပါတယ် (အချိန်မှန်မှန် စစ်တာပဲ ရှိပါတယ်) ပြန်ကောင်းအောင် လုပ်တာက အနှောင့်အယှက် ဖြစ်စေနိုင်ပါတယ် (process တွေကို ရပ်ပစ်ရတာ ဒါမှမဟုတ် rollback (အရင် အခြေအနေကို ပြန်ဆုတ်ခြင်း) လုပ်ရတာ)
Ignorance (Ostrich Algorithm) (လျစ်လျူရှုခြင်း၊ ငှက်ကုလားအုတ် algorithm) Deadlock ဖြစ်ခဲတယ်လို့ ယူဆပြီး ဖြစ်ရင် restart (ပြန်စ) လုပ်ပါတယ် Overhead လုံးဝ မရှိပါဘူး၊ implement (တကယ် အလုပ်လုပ်အောင် code ရေး) လုပ်ရ လွယ်ပါတယ် လူက ဝင်မဖြေရှင်းမချင်း deadlock တွေ မပြေလည်ဘဲ ကျန်နေပါတယ်

Prevention ဥပမာများ:

  • Process တွေကို မစခင် လိုတဲ့ resource အားလုံး ကို တစ်ခါတည်း တောင်းခိုင်းပါ (hold and wait ကို ဖယ်ရှားပေးပါတယ်)
  • Resource အမျိုးအစားတွေကို စနစ်တစ်ခုလုံးအတွက် အစဉ် တစ်ခု သတ်မှတ်ပြီး process တွေကို အဲဒီ အစဉ်အတိုင်းပဲ တောင်းခိုင်းပါ (circular wait ကို ဖယ်ရှားပေးပါတယ်)
  • Preemption (process ဆီက resource ကို အတင်း ပြန်ယူခြင်း) ကို ခွင့်ပြုပါ: စောင့်နေတဲ့ process တွေဆီက resource တွေကို အတင်း ယူပါ (no preemption ကို ဖယ်ရှားပေးပါတယ်)

Avoidance က Banker’s Algorithm (ဘဏ်လုပ်ငန်းရှင် algorithm) လို algorithm တွေကို သုံးပါတယ်။ အဲဒီ algorithm က resource တောင်းဆိုချက် တစ်ခုကို ခွင့်ပြုလိုက်ရင် စနစ်က process အားလုံး ဆက်ပြီး ပြီးဆုံးနိုင်တဲ့ “safe state” (ဘေးကင်းတဲ့ အခြေအနေ) မှာ ဆက်ရှိနေမလား စစ်ပါတယ်။ မရှိနိုင်ရင် တောင်းဆိုချက်ကို ငြင်းပါတယ်။ (အယူအဆကိုပဲ သိဖို့ လိုပါတယ်: ဒီ algorithm ကို implement လုပ်ဖို့ မလိုပါဘူး။)

Detection က resource allocation graph (ဘယ် process က ဘယ် resource ကို ကိုင်ထားလဲ၊ စောင့်နေလဲ ပြတဲ့ ပုံ) ထဲမှာ cycle (စက်ဝိုင်းပုံ ပြန်ဆုံနေတဲ့ လမ်းကြောင်း) ရှိမရှိ အချိန်မှန်မှန် စစ်ပါတယ်။ Cycle တွေ့ရင် deadlock ရှိနေပါတယ်။ ပြန်ကောင်းအောင် လုပ်နိုင်တဲ့ နည်းတွေထဲမှာ ဒါတွေ ပါပါတယ်:

  • Cycle ထဲက process တစ်ခု ဒါမှမဟုတ် တစ်ခုထက်ပိုပြီး ရပ်ပစ်ခြင်း
  • Process တစ်ခုဆီက resource တွေကို အတင်း ပြန်ယူပြီး အဲဒီ process ကို rollback လုပ်ခြင်း

လက်တွေ့မှာ desktop operating system အများစုက Ignorance (Ostrich Algorithm) ကို သုံးကြပါတယ်: နေ့စဉ် ကွန်ပျူတာ သုံးတဲ့အခါ deadlock တွေ ဖြစ်ခဲလွန်းလို့ prevention ဒါမှမဟုတ် detection ရဲ့ ကုန်ကျစရိတ်က ရံဖန်ရံခါ restart လုပ်ရတာထက် ပိုများပါတယ်။

ဒီပြဿနာ သုံးခုက ရောထွေးလွယ်ပါတယ်။ Process တစ်ခုစီ ဘာလုပ်နေလဲ၊ တစ်စုံတစ်ရာ ရှေ့တိုးလား ဆိုတာကို ကြည့်ပြီး ခွဲခြားနိုင်အောင် လုပ်ပါ။

Starvation (process တစ်ခုက CPU အချိန် ဒါမှမဟုတ် resource ကို အမြဲ မရဘဲ ငတ်နေခြင်း): process တစ်ခုက run ဖို့ အဆင်သင့် ဖြစ်နေပေမယ့် resource တွေကို အမြဲတမ်း မရဘဲ ငြင်းပယ်ခံနေရပါတယ်။ Scheduling algorithm က priority မြင့်တဲ့ process တွေကို အမြဲ ဦးစားပေးလို့ priority နိမ့်တဲ့ process က CPU အချိန် ဘယ်တော့မှ မရတဲ့အခါ ဒါ ဖြစ်နိုင်ပါတယ်။ Starvation က deadlock နဲ့ တူတာ မဟုတ်ပါဘူး: starvation မှာ တခြား process တွေက ရှေ့ဆက် တိုးနေကြပါတယ်၊ deadlock မှာတော့ ဘယ် process မှ ရှေ့မတိုးပါဘူး။

Priority inversion (priority ပြောင်းပြန် ဖြစ်သွားခြင်း): priority မြင့်တဲ့ process တစ်ခုက မျှသုံးတဲ့ resource ကို priority နိမ့်တဲ့ process တစ်ခုက ကိုင်ထားလို့ မဖြစ်မနေ စောင့်ရပါတယ်။ Priority မြင့်တဲ့ process က ရှေ့ဆက် မသွားနိုင်တော့ဘဲ လက်တွေ့မှာ priority နိမ့်တဲ့ process ရဲ့ priority နဲ့ run နေသလို ဖြစ်သွားပါတယ်။ ဒါကို priority inheritance (priority ကို ခဏ အမွေပေးခြင်း) နဲ့ ဖြေရှင်းပါတယ်: priority နိမ့်တဲ့ process ရဲ့ priority ကို ခဏ မြှင့်ပေးလိုက်လို့ အဲဒီ process က မြန်မြန် ပြီးပြီး resource ကို ပြန်လွှတ်နိုင်ပါတယ်။

Livelock (လှုပ်ရှားနေပေမယ့် ရှေ့မတိုးဘဲ ပိတ်မိနေခြင်း): process နှစ်ခု ဒါမှမဟုတ် ပိုများတဲ့ process တွေက တစ်ခုကို တစ်ခု တုံ့ပြန်ရင်း state ကို အဆက်မပြတ် ပြောင်းနေ ကြပေမယ့် ရှေ့ လုံးဝ မတိုးပါဘူး။ Process တွေ ရပ်တန့်နေတဲ့ deadlock နဲ့ မတူဘဲ livelock မှာ process တွေက အလုပ်လုပ်နေကြပေမယ့် တစ်ခုကို တစ်ခု တုံ့ပြန်နေတဲ့ အဆုံးမရှိ စက်ဝိုင်းထဲမှာ ပိတ်မိနေကြပါတယ်။ စင်္ကြံ တစ်ခုမှာ လူနှစ်ယောက်က တစ်ယောက်ကို တစ်ယောက် ကျော်ဖြတ်ဖို့ ကြိုးစားနေတာကို မြင်ကြည့်ပါ: နှစ်ယောက်လုံး ဘယ်ဘက် ရှောင်၊ ပြီးတော့ နှစ်ယောက်လုံး ညာဘက် ရှောင်၊ ပြီးတော့ နှစ်ယောက်လုံး ဘယ်ဘက် ပြန်ရှောင်နဲ့ အဆုံးမရှိ ဆက်ဖြစ်နေပါတယ်။

ပြဿနာ Process တွေ အလုပ်လုပ်နေလား ရှေ့တိုးလား အဓိက ကွာခြားချက်
Deadlock မလုပ်ပါ (block ဖြစ်နေ) လုံးဝ မတိုးပါ Process အားလုံး အမြဲတမ်း ရပ်တန့်နေ
Starvation Process တစ်ခု ငြင်းပယ်ခံရ တခြား process တွေ ရှေ့တိုး တခြား process တွေ run နေချိန် process တစ်ခုက ငတ်နေ
Livelock လုပ်နေပါတယ် (active) လုံးဝ မတိုးပါ Process တွေ state ပြောင်းနေပေမယ့် ဘာမှ မပြီးမြောက်

အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ

ဥပမာ 1: Dining Philosophers (ရိုးရှင်းအောင် လုပ်ထားတဲ့ ပုံစံ)

Dining Philosophers (စားပွဲဝိုင်းမှာ ထိုင်တဲ့ ဒဿနပညာရှင်တွေ ပြဿနာ) မှာ ဒဿနပညာရှင် ငါးယောက်က စားပွဲဝိုင်း တစ်ခုမှာ ဝိုင်းထိုင်နေကြပါတယ်။ ဘေးချင်းကပ် ပညာရှင် နှစ်ယောက်ကြားမှာ တူ တစ်ချောင်းစီ ရှိပါတယ် (တူ စုစုပေါင်း ငါးချောင်း)။ စားဖို့ ပညာရှင် တစ်ယောက်က ဘယ်ဘက် တူရော ညာဘက် တူပါ နှစ်ချောင်းလုံး လိုပါတယ်။

အခြေအနေ: ပညာရှင် ငါးယောက်လုံးက သူတို့ရဲ့ ဘယ်ဘက် တူကို တစ်ပြိုင်နက် ကောက်ယူလိုက်ကြပါတယ်။

ရလဒ်: Deadlock! ပညာရှင် တစ်ယောက်စီက တူ တစ်ချောင်းကို ကိုင်ထားပြီး သူ့ ညာဘက်က တူကို စောင့်နေပါတယ်။ အဲဒီ တူကို နောက် ပညာရှင်က ကိုင်ထားပါတယ်။

                 Phil 1
            C1            C2
       Phil 5                Phil 2
            C5            C3
          Phil 4 --- C4 --- Phil 3

ပုံထဲမှာ Phil က philosopher (ဒဿနပညာရှင်) ကို၊ C က chopstick (တူ) ကို ဆိုလိုပါတယ်။

တူ တစ်ချောင်းစီက ဘေးချင်းကပ် ပညာရှင် နှစ်ယောက်ကြားမှာ ရှိပါတယ်။ ပညာရှင် n ရဲ့ ဘယ်ဘက် တူက Cn ဖြစ်ပြီး ညာဘက် တူက စားပွဲဝိုင်း ပတ်လည်မှာ နောက်တစ်ချောင်း ဖြစ်ပါတယ် (Phil 5 အတွက်ဆိုရင် C1 ပါ)။

ပညာရှင် ကိုင်ထားတာ (ဘယ်ဘက်) စောင့်နေတာ (ညာဘက်) အဲဒီ တူကို ကိုင်ထားသူ
Phil 1 C1 C2 Phil 2
Phil 2 C2 C3 Phil 3
Phil 3 C3 C4 Phil 4
Phil 4 C4 C5 Phil 5
Phil 5 C5 C1 Phil 1

ပညာရှင် တစ်ယောက်စီက သူ့ ဘယ်ဘက် တူ (Cn) ကို ကိုင်ထားပြီး ညာဘက်က တူကို စောင့်နေပါတယ်။

အခြေအနေ လေးခုကို စစ်ကြည့်ခြင်း:

အခြေအနေ ဒီမှာ ဘယ်လို ဖြစ်နေလဲ
Mutual exclusion တူ တစ်ချောင်းကို တစ်ကြိမ်မှာ ပညာရှင် တစ်ယောက်ပဲ ကိုင်နိုင်ပါတယ်
Hold and wait ပညာရှင် တစ်ယောက်စီက ဘယ်ဘက် တူကို ကိုင်ထားရင်း ညာဘက် တူကို စောင့်နေပါတယ်
No preemption ပညာရှင် လက်ထဲက တူကို အတင်း ယူလို့ မရပါဘူး
Circular wait Phil 1 က Phil 2 ရဲ့ တူကို စောင့်၊ Phil 2 က Phil 3 ရဲ့ တူကို စောင့်၊ …၊ Phil 5 က Phil 1 ရဲ့ တူကို စောင့်နေပါတယ်

Prevention နည်းဗျူဟာ: ပညာရှင် တစ်ယောက် (ဥပမာ Phil 5) ကို ဘယ်ဘက် တူအစား ညာဘက် တူကို အရင် ကောက်ခိုင်းပါ။ ဒါက circular wait ကို ဖြတ်တောက်ပေးပါတယ်: Phil 5 က Phil 1 ကောက်မယ့် တူကိုပဲ လှမ်းယူမှာ ဖြစ်လို့ နှစ်ယောက်ထဲက တစ်ယောက်က ဘာမှ မကိုင်ထားဘဲ စောင့်ရပါမယ်။

ဥပမာ 2: Context Switch ကို အဆင့်ဆင့် လိုက်ကြည့်ခြင်း

Process နှစ်ခု (P1 နဲ့ P2) က CPU တစ်ခုတည်းကို မျှသုံးနေကြပါတယ်။ Timer interrupt ဖြစ်လာတဲ့အချိန်မှာ P1 က run နေပါတယ်။

မပြောင်းခင်:

အကွက် P1 (Running) P2 (Ready: PCB ထဲမှာ သိမ်းထား)
PC 100 200
R1 42 15
R2 7 3
State Running Ready

အဆင့် 1: P1 ရဲ့ state ကို သူ့ PCB ထဲ save လုပ်ခြင်း

OS က P1 ရဲ့ လက်ရှိ register တန်ဖိုးတွေ (PC=100, R1=42, R2=7) ကို P1 ရဲ့ PCB ထဲ copy ကူးပြီး P1 ရဲ့ state ကို Ready လို့ သတ်မှတ်ပါတယ်။

အဆင့် 2: P2 ရဲ့ state ကို သူ့ PCB ကနေ load လုပ်ခြင်း

OS က P2 ရဲ့ PCB ထဲက တန်ဖိုးတွေ (PC=200, R1=15, R2=3) ကို CPU register တွေထဲ load လုပ်ပြီး P2 ရဲ့ state ကို Running လို့ သတ်မှတ်ပါတယ်။

ပြောင်းပြီးနောက်:

အကွက် P1 (Ready: PCB ထဲမှာ သိမ်းထား) P2 (Running)
PC 100 200
R1 42 15
R2 7 3
State Ready Running

အခု CPU က address 200 မှာ ရှိတဲ့ P2 ရဲ့ နောက် instruction ကို execute လုပ်ပါတယ်။ P1 က ခဏ ရပ်ထားပေမယ့် သူ့ state ကို လုံလုံခြုံခြုံ သိမ်းထားပါတယ်: P1 က CPU ကို နောက်တစ်ခါ ပြန်ရတဲ့အခါ R1=42 နဲ့ R2=7 တို့နဲ့အတူ PC=100 ကနေ အတိအကျ ပြန်ဆက် run ပါလိမ့်မယ်။

Quick Check (အမြန် စစ်ဆေးမေးခွန်း)

Q1. Context switching ဆိုတာ ဘာလဲ။

Q2. ဒီထဲက ဘယ်ဟာက deadlock အတွက် မဖြစ်မနေ လိုအပ်တဲ့ အခြေအနေ မဟုတ် သလဲ။

Q3. Semaphore ဆိုတာ ဘာလဲ။

Q4. Multitasking နဲ့ multiprocessing ကြားက ကွာခြားချက်က ဘာလဲ။

Q5. OS ရဲ့ resource စီမံခန့်ခွဲမှုမှာ starvation ဆိုတာ ဘာလဲ။

Context Switch ကို Trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်) လုပ်ပါ

Process P1 run နေတုန်း timer interrupt ဖြစ်လာလို့ P2 ဆီ context switch ဖြစ်သွားပါတယ်။ State ဇယားထဲက ပျောက်နေတဲ့ တန်ဖိုးတွေကို ဖြည့်ပါ။ State အကွက်မှာ Ready ဒါမှမဟုတ် Running ကို English စကားလုံးနဲ့ ရိုက်ထည့်ပြီး Running အကွက်မှာ run နေတဲ့ process ရဲ့ နာမည် (P1 ဒါမှမဟုတ် P2) ကို ရိုက်ထည့်ပါ။

P1 ရဲ့ လက်ရှိ register တန်ဖိုးများ: PC=100, R1=42, R2=7။ P2 ရဲ့ PCB ထဲမှာ သိမ်းထားတာ: PC=200, R1=15, R2=3။

အဆင့်PCR1R2StateRunning (run နေတဲ့ process)
မပြောင်းခင် 100 42 7 Running P1
P1 ကို PCB ထဲ save လုပ် --
P2 ကို PCB ကနေ load လုပ်

Spot the Error (အမှား ရှာခြင်း)

ကျောင်းသား တစ်ယောက်က စာမေးပွဲ အဖြေမှာ deadlock အတွက် မဖြစ်မနေ လိုအပ်တဲ့ အခြေအနေ လေးခုကို စာရင်း ရေးထားပါတယ်။ အခြေအနေ တစ်ခုကို မှားပြီး ဖော်ပြထားပါတယ်။ မှားနေတဲ့ line ကို ရွေးပါ၊ ပြီးရင် ပြင်နည်းကို ရွေးပါ။

1The four necessary conditions for deadlock are: 21. Shared access - multiple processes can use the resource simultaneously 32. Hold and wait - a process holds one resource while waiting for another 43. No preemption - resources cannot be forcibly taken from a process 54. Circular wait - a chain of processes each waits for a resource held by the next

Line တွေရဲ့ အဓိပ္ပာယ်: (1) Deadlock အတွက် မဖြစ်မနေ လိုအပ်တဲ့ အခြေအနေ လေးခုက ဒါတွေပါ။ (2) 1. Shared access: process အများက resource ကို တစ်ပြိုင်နက် သုံးနိုင်တယ်။ (3) 2. Hold and wait: process တစ်ခုက resource တစ်ခုကို ကိုင်ထားရင်း နောက်တစ်ခုကို စောင့်တယ်။ (4) 3. No preemption: resource တွေကို process ဆီကနေ အတင်း ယူလို့ မရဘူး။ (5) 4. Circular wait: process တွေရဲ့ ကွင်းဆက်မှာ တစ်ခုစီက နောက်တစ်ခု ကိုင်ထားတဲ့ resource ကို စောင့်တယ်။

ဒီ line အတွက် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:

Fill in the Blanks (ကွက်လပ် ဖြည့်ခြင်း)

Multitasking နဲ့ resource စီမံခန့်ခွဲမှုအကြောင်း အောက်က ဖော်ပြချက်တွေကို ပြည့်စုံအောင် ဖြည့်ပါ။ စာကြောင်းတွေက English လို ဖြစ်လို့ ကွက်လပ်တွေကို English စကားလုံးနဲ့ ရိုက်ထည့်ပါ:

Concept Summary
===============
 occurs when the OS switches from one process to another.

A  is an integer variable used to signal between processes.

For deadlock to occur, all  conditions must hold simultaneously.

 means a process holds one resource while waiting for another.

 is when a process is indefinitely denied CPU time despite being ready.

စာကြောင်းတွေရဲ့ အဓိပ္ပာယ် (____ က ကွက်လပ်ပါ):
OS က process တစ်ခုကနေ နောက်တစ်ခုကို ပြောင်းတဲ့အခါ ____ ဖြစ်ပါတယ်။
____ ဆိုတာ process တွေကြား အချက်ပြဖို့ သုံးတဲ့ integer variable တစ်ခုပါ။
Deadlock ဖြစ်ဖို့ အခြေအနေ ____ ခုလုံး တစ်ပြိုင်နက် ရှိနေရပါမယ်။
____ ဆိုတာ process တစ်ခုက resource တစ်ခုကို ကိုင်ထားရင်း နောက်တစ်ခုကို စောင့်နေတာပါ။
____ ဆိုတာ process တစ်ခုက run ဖို့ အဆင်သင့် ဖြစ်နေပေမယ့် CPU အချိန်ကို အကန့်အသတ်မရှိ မရတာပါ။

Predict the Output (output ကို ကြိုခန့်မှန်းခြင်း)

Process A က File X ကို ကိုင်ထားပြီး Printer ကို တောင်းပါတယ်။ Process B က Printer ကို ကိုင်ထားပြီး File X ကို တောင်းပါတယ်။ Process နှစ်ခုလုံးက စောင့်နေတဲ့ resource ကို မရမချင်း လက်ရှိ ကိုင်ထားတဲ့ resource ကို ပြန်မလွှတ်ပါဘူး။

ဒါ deadlock ဖြစ်နေသလား။ (English လို Yes (ဟုတ်တယ်) ဒါမှမဟုတ် No (မဟုတ်ဘူး) လို့ ရိုက်ထည့်ပါ)

စနစ် တစ်ခုမှာ မျှသုံးတဲ့ resource တစ်ခုရဲ့ instance (resource အမျိုးအစား တစ်ခုထဲက ယူနစ် တစ်ခု) 2 ခု ရှိပါတယ်။ Process သုံးခုက ဒီ resource ကို လိုအပ်ပါတယ်:

  • P1 က လက်ရှိ instance 1 ခု ကိုင်ထားပါတယ်
  • P2 က လက်ရှိ instance 1 ခု ကိုင်ထားပါတယ်
  • P3 က instance 0 ခု ကိုင်ထားပြီး 1 ခု တောင်းပါတယ်

OS က P3 ရဲ့ တောင်းဆိုချက်ကို ဘေးကင်းစွာ ခွင့်ပြုနိုင်သလား။ (Yes ဒါမှမဟုတ် No လို့ ရိုက်ထည့်ပါ)

Practice Exercises (လေ့ကျင့်ခန်းများ)

Core (အခြေခံ အဆင့်)

  1. Context Switching: Context switch ဖြစ်နေစဉ် ဘာတွေ ဖြစ်သလဲဆိုတာ Explain (ရှင်းပြပါ) လုပ်ပါ။ အဖြေမှာ ဘယ် အချက်အလက်တွေကို save လုပ်လဲ၊ ဘယ်မှာ သိမ်းလဲ၊ context switching မှာ ဘာကြောင့် overhead ရှိလဲဆိုတာ describe (ဖော်ပြရှင်းပြပါ) လုပ်ပါ။

  2. Deadlock ရဲ့ အခြေအနေ လေးခု: Deadlock အတွက် မဖြစ်မနေ လိုအပ်တဲ့ အခြေအနေ လေးခုကို List (ရှင်းပြချက် မပါဘဲ အဖြေတိုတွေကို စာရင်းလိုက် ပေးပါ) လုပ်ပြီး describe လုပ်ပါ။ အခြေအနေ တစ်ခုစီအတွက် ဘာကို ဆိုလိုလဲ ရှင်းပြတဲ့ စာကြောင်း တစ်ကြောင်း ရေးပါ။

  3. Mutual Exclusion: Mutual exclusion ကို Define (အဓိပ္ပာယ်ကို တိတိကျကျ ဖော်ပြပါ) လုပ်ပြီး process အများက resource တစ်ခုကို မျှသုံးတဲ့အခါ ဘာကြောင့် လိုအပ်လဲဆိုတာ explain လုပ်ပါ။ Mutual exclusion မရှိရင် ဘာတွေ မှားသွားနိုင်လဲဆိုတဲ့ ဥပမာ တစ်ခု ပေးပါ။

Extension (တိုးချဲ့ အဆင့်)

  1. Dining Philosophers: Dining philosophers ပြဿနာက deadlock ကို ဘယ်လို ဖော်ပြသလဲဆိုတာ Explain လုပ်ပါ။ Deadlock အခြေအနေ လေးခု တစ်ခုစီက ဘယ်လို သက်ဆိုင်လဲဆိုတာ Identify (ဖြစ်နိုင်တဲ့ အဖြေတွေထဲက ရွေးပြီး ဖော်ပြပါ) လုပ်ပါ။ Prevention နည်းဗျူဟာ တစ်ခုကို Describe လုပ်ပြီး အဲဒါက ဘယ် အခြေအနေကို ဖယ်ရှားလဲဆိုတာ explain လုပ်ပါ။

  2. Deadlock ကို ကိုင်တွယ်တဲ့ နည်းဗျူဟာများ: မတူတဲ့ deadlock ကိုင်တွယ်ရေး နည်းဗျူဟာ သုံးခု (prevention၊ avoidance နဲ့ detection) ကို Compare and contrast (အားလုံးကို တစ်လျှောက်လုံး ကိုးကားပြီး တူတာနဲ့ ကွာတာကို ဖော်ပြပါ) လုပ်ပါ။ နည်းဗျူဟာ တစ်ခုစီအတွက် လုပ်ပုံကို describe လုပ်ပြီး အားသာချက် တစ်ခုနဲ့ အားနည်းချက် တစ်ခု ပေးပါ။

Challenge (စိန်ခေါ်မှု အဆင့်)

  1. ဆေးရုံ စနစ် ခွဲခြမ်းစိတ်ဖြာချက် (IB စာမေးပွဲ ပုံစံ၊ 8 marks): ဆေးရုံ စနစ် တစ်ခုမှာ printer 2 လုံးနဲ့ scanner 1 လုံးကို မျှသုံးနေတဲ့ process 3 ခု ရှိပါတယ်။
    • Process A က printer တစ်လုံးကို ကိုင်ထားပြီး scanner ကို လိုအပ်ပါတယ်။
    • Process B က scanner ကို ကိုင်ထားပြီး printer တစ်လုံး လိုအပ်ပါတယ်။
    • Process C က printer တစ်လုံးရော scanner ပါ လိုအပ်ပါတယ်။

    (a) ဒီအခြေအနေမှာ deadlock အခြေအနေ လေးခုထဲက ဘယ်ဟာတွေ ရှိနေလဲဆိုတာ Identify လုပ်ပါ။ [4 marks]

    (b) Process A နဲ့ Process B ကြားမှာ လက်ရှိ deadlock ရှိမရှိကို Determine (ဖြစ်နိုင်တဲ့ အဖြေ တစ်ခုတည်းကို ရှာထုတ်ပါ) လုပ်ပါ။ သင့်အဖြေကို Justify (ဘာကြောင့် ရွေးတာလဲ အကြောင်းပြချက်နဲ့ ပြပါ) လုပ်ပါ။ [2 marks]

    (c) Process သုံးခုလုံး ပြီးဆုံးနိုင်အောင် ဖြေရှင်းမယ့် နည်းဗျူဟာ တစ်ခုကို Suggest (ဖြစ်နိုင်တဲ့ ဖြေရှင်းနည်း တစ်ခုကို အကြံပြုပါ) လုပ်ပါ။ [2 marks]

    [4 marks] လို mark allocation (မေးခွန်း တစ်ခုစီအတွက် ပေးတဲ့ အမှတ်) တွေက IB စာမေးပွဲ ပုံစံအတိုင်း ပေးထားတာပါ: အဖြေကို ဘယ်လောက် အသေးစိတ် ရေးရမလဲ ပြတဲ့ လမ်းညွှန်အဖြစ် သုံးနိုင်ပါတယ်။

  2. Deadlock၊ Starvation နဲ့ Livelock: Deadlock၊ starvation နဲ့ livelock တို့ကြားက ကွာခြားချက်ကို Explain လုပ်ပါ။ တစ်ခုစီအတွက် လက်တွေ့ ဘဝက နှိုင်းယှဉ်ပြချက် (analogy) တစ်ခု ပေးပြီး ထိခိုက်နေတဲ့ process တွေက အလုပ်လုပ်နေလား (active)၊ block ဖြစ်နေလား ဆိုတာ describe လုပ်ပါ။ Livelock ကို deadlock ထက် ရှာတွေ့ဖို့ ဘာကြောင့် မကြာခဏ ပိုခက်လဲဆိုတာ Explain လုပ်ပါ။

ဆက်စပ် ခေါင်းစဉ်များ

  • အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: OS Fundamentals: process management (process တွေကို စီမံခန့်ခွဲခြင်း) က OS ရဲ့ အဓိက လုပ်ဆောင်ချက်တွေထဲက တစ်ခုပါ၊ process တွေနဲ့ သူတို့ရဲ့ state တွေကို နားလည်ထားဖို့ မရှိမဖြစ် လိုအပ်ပါတယ်
  • အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Scheduling: scheduling algorithm တွေက နောက် ဘယ် process run မလဲ ဆုံးဖြတ်ပါတယ်၊ scheduling ဆုံးဖြတ်ချက်တွေ ချတဲ့အခါ context switching ဖြစ်ပါတယ်
  • ဆက်စပ် ခေါင်းစဉ်: Polling and Interrupts: timer interrupt တွေက context switch တွေကို စတင်စေပါတယ်၊ interrupt တွေကို ကိုင်တွယ်တာက preemptive (run နေတဲ့ process ကို OS က အတင်း ရပ်ခိုင်းနိုင်တဲ့) multitasking အတွက် မရှိမဖြစ် လိုအပ်ပါတယ်
  • ဆက်စပ် ခေါင်းစဉ်: CPU Architecture: context switching က CPU register တွေကို save လုပ်ပြီး ပြန် load လုပ်ပါတယ်၊ multi-core processor တွေက တကယ့် parallel execution (multiprocessing) ကို ဖြစ်နိုင်စေပါတယ်
  • နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Control Systems (HL): real-time (ချက်ချင်း ဆက်တိုက်) control system (ထိန်းချုပ်ရေး စနစ်) တွေက deadlock ကို ရှောင်ရှားရပြီး အသက်အန္တရာယ်နဲ့ ဆိုင်တဲ့ လုပ်ဆောင်ချက်တွေအတွက် resource ကို အချိန်မီ ခွဲဝေပေးရပါတယ်

© EduCS.me. ကွန်ပျူတာသိပ္ပံ ပညာရေးအတွက် အရင်းအမြစ်တွေ စုထားတဲ့ နေရာပါ။ EduCS is an independent educational resource. It is not affiliated with, or endorsed by, the International Baccalaureate Organization. (EduCS ဟာ သီးခြား ပညာရေး အရင်းအမြစ်တစ်ခုပါ။ International Baccalaureate Organization နဲ့ ဆက်စပ်မှု မရှိသလို သူတို့ရဲ့ ထောက်ခံချက်လည်း မရှိပါဘူး။) ဆက်သွယ်ရန်

Just the Docs နဲ့ တည်ဆောက်ထားပါတယ်။