Polling and Interrupts (polling နဲ့ interrupt)

A1.3.4: Evaluate the use of polling and interrupt handling
မြန်မာလို: polling (စက်တွေကို အလှည့်ကျ စစ်ကြည့်ခြင်း) နဲ့ interrupt (CPU ကို ခဏ ရပ်ခိုင်းတဲ့ signal) တွေကို ကိုင်တွယ်ခြင်း (interrupt handling) ကို သုံးတာကို အကဲဖြတ်နိုင်ရပါမယ်။

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

Polling ဆိုတာ ဘာလဲ (A1.3.4)

Polling ဆိုတာ device (စက်ပစ္စည်း) တစ်ခုက အာရုံစိုက်ပေးဖို့ လိုမလို သိဖို့ CPU (ကွန်ပျူတာရဲ့ အဓိက processor) က အဲဒီ device ရဲ့ status register (စက်ရဲ့ လက်ရှိ အခြေအနေကို ပြတဲ့ register) ကို ထပ်ခါထပ်ခါ စစ်ကြည့်တဲ့ (poll လုပ်တဲ့) နည်းပါ။ CPU က ရပ်နားချိန် မရှိတဲ့ loop (ထပ်ခါထပ်ခါ run တဲ့ code အပိုင်း) တစ်ခုကို run နေပါတယ်: device ရဲ့ status ကို စစ်တယ်၊ အသစ် ဘာမှ မတွေ့ဘူး၊ ထပ်စစ်တယ်၊ ဒီလိုနဲ့ ထပ်ခါထပ်ခါ ဖြစ်နေပါတယ်။

Notification အသံ မြည်တာကို စောင့်မယ့်အစား message ရောက်မရောက် ဖုန်းကို စက္ကန့် အနည်းငယ်တိုင်း ထပ်ခါထပ်ခါ ဖွင့်ကြည့်နေတာနဲ့ တူပါတယ်။

Synchronous (CPU ရဲ့ အချိန်ဇယားအတိုင်း ဖြစ်တဲ့): စစ်ဆေးမှုတွေက CPU ရဲ့ ကိုယ်ပိုင် program ကနေ လာတာမို့ device မှာ အသစ် ရှိသည်ဖြစ်စေ မရှိသည်ဖြစ်စေ CPU ရဲ့ အချိန်ဇယားအတိုင်း ဖြစ်ပါတယ် (loop တစ်ပတ် ပတ်တိုင်း တစ်ကြိမ်၊ ဒါမှမဟုတ် timer နဲ့ millisecond (တစ်စက္ကန့်ရဲ့ တစ်ထောင်ပုံ တစ်ပုံ) အနည်းငယ်တိုင်း)
အကောင်အထည်ဖော်ရ ရိုးရှင်းခြင်း: status register ကို ဖတ်တဲ့ loop တစ်ခုပဲ လိုပါတယ်
အစဉ် ပုံသေ ဖြစ်ခြင်း: loop က device တွေကို ရေးထားတဲ့ အစဉ်အတိုင်း တစ်ခုပြီး တစ်ခု သွားစစ်တာမို့ အရေးပေါ် event (ဖြစ်ရပ်) ရှိတဲ့ device တစ်ခုက CPU က ပြောစရာ မရှိတဲ့ device တွေကို စစ်နေတုန်း သူ့အလှည့်ကို စောင့်ရပါတယ်
အလကား စစ်ဆေးမှုတွေမှာ CPU အချိန် ကုန်ခြင်း: စစ်ဆေးမှု အများစုက အသစ် ဘာမှ မတွေ့ပေမယ့် တစ်ကြိမ်စီတိုင်းက CPU အသုံးဝင်တဲ့ အလုပ်မှာ သုံးနိုင်ခဲ့မယ့် instruction (processor လုပ်ဆောင်ရမယ့် ညွှန်ကြားချက်) တွေကို သုံးနေရပါတယ်
တုံ့ပြန်မှု ပိုနှေးခြင်း: device ကို စစ်ပြီးပြီးချင်း ဖြစ်တဲ့ event ကို loop က ပြန်ရောက်လာမှပဲ သိပါတယ်၊ ဒါကြောင့် စောင့်ရတဲ့ အချိန်က loop ထဲက device အရေအတွက် များလေ၊ စစ်ဆေးမှုတွေကြား အချိန် ကြာလေ ပိုကြာလေ ဖြစ်ပါတယ်
ပါဝါ ပိုသုံးခြင်း: အဆက်မပြတ် polling (busy-waiting၊ loop က ချက်ချင်း ပြန်ပြန် စစ်နေတဲ့ ပုံစံ) မှာ CPU က loop ကို တစ်ချိန်လုံး run နေရလို့ ပါဝါ နည်းနည်းပဲ သုံးပြီး နားနေတဲ့ idle အခြေအနေကို မရောက်နိုင်ပါဘူး။ Timer နဲ့ polling လုပ်ရင် စစ်ဆေးမှုတွေကြားမှာ နားနိုင်ပေမယ့် စစ်ဆေးမှု တစ်ကြိမ်စီတိုင်းက CPU ကို နှိုးရပါတယ်

Polling loop (pseudocode):

while true:
    status = read(device_status_register)
    if status == READY:
        process_data()
    // otherwise, keep checking...

ပုံထဲက code ရဲ့ အဓိပ္ပာယ်: ဒါက polling loop ကို pseudocode (program ပုံစံ ရိုးရိုးစာနဲ့ ရေးတဲ့ algorithm) နဲ့ ရေးထားတာပါ။ while true က အမြဲ ပတ်နေတဲ့ loop ပါ၊ status = read(device_status_register) က device ရဲ့ status register ကို ဖတ်ပါတယ်၊ status က READY (အဆင်သင့်) ဖြစ်ရင် process_data() နဲ့ ဒေတာကို ကိုင်တွယ်ပါတယ်၊ // otherwise, keep checking... ဆိုတာ မဟုတ်ရင် ဆက်စစ်နေမယ်လို့ ဆိုလိုပါတယ်။

အများ မှားတတ်တာက polling ကို “device က CPU ဆီ signal ပို့တယ်” လို့ ဖော်ပြတာပါ။ အဲဒါက polling မဟုတ်ဘဲ interrupt တွေကို ဖော်ပြတာပါ။ Polling မှာ စစ်ဆေးမှု တိုင်းကို CPU က စတင်ပါတယ်: device က ဘာမှ မလုပ်ဘဲ နေပါတယ်။

Interrupt ဆိုတာ ဘာလဲ (A1.3.4)

Interrupt ဆိုတာ device တစ်ခုက အာရုံစိုက်ပေးဖို့ လိုတဲ့အခါ device ကနေ CPU ဆီ ပို့တဲ့ signal ပါ။ CPU က အဆက်မပြတ် စစ်နေမယ့်အစား device က “အခု မင်း လိုတယ်” လို့ ပြောပါတယ်၊ လူရောက်လာရင် မြည်တဲ့ တံခါးခေါင်းလောင်းလိုပါပဲ၊ ဒါကြောင့် တံခါးကို ခဏခဏ သွားကြည့်နေစရာ မလိုပါဘူး။

Asynchronous (CPU ရဲ့ အချိန်ဇယားနဲ့ မဆိုင်ဘဲ ဖြစ်တဲ့): signal ဘယ်အချိန် ရောက်မလဲ ဆိုတာ device က ဆုံးဖြတ်တာမို့ CPU က run နေတဲ့ ဘယ် program ရဲ့ အလယ်မှာမဆို ရောက်လာနိုင်ပါတယ်၊ CPU ရဲ့ ကိုယ်ပိုင် အချိန်ဇယားထဲက ဘာကမှ အဲဒါ ဖြစ်မယ့် အချိန်ကို မသတ်မှတ်ပါဘူး
Hardware နည်းလမ်း: device က processor ဆီ interrupt request (interrupt တောင်းဆိုချက်) လို့ ခေါ်တဲ့ လျှပ်စစ် signal တစ်ခု ပို့တာမို့ device အလုပ်မရှိတုန်း စစ်ဆေးတဲ့ code တစ်ခုမှ run စရာ မလိုပါဘူး
ဦးစားပေး အဆင့်များ (priority levels): interrupt ထွက်လာတဲ့ နေရာ (source) တစ်ခုစီကို priority (ဦးစားပေး အဆင့်) သတ်မှတ်ပေးနိုင်တာမို့ interrupt နှစ်ခု တစ်ပြိုင်နက် ရောက်လာရင် ပိုအရေးကြီးတဲ့ တစ်ခု (ဥပမာ ပါဝါ ပြတ်တော့မယ်ဆိုတဲ့ သတိပေးချက်) ကို အရင် ကိုင်တွယ်ပါတယ်
Event တွေကြားမှာ CPU အားလပ်ခြင်း: CPU က တခြား အလုပ်တွေကို ဆက်လုပ်နေပြီး device တစ်ခုမှာ ပြောစရာ ရှိမှပဲ အဲဒီဆီ လှည့်လာရပါတယ်
တုံ့ပြန်မှု မြန်ခြင်း: နောက်တစ်ကြိမ် poll cycle (နောက်တစ်ပတ် စစ်ဆေးမှု) ကို စောင့်မယ့်အစား CPU က လက်ရှိ instruction ကို ပြီးတာနဲ့ တုံ့ပြန်ပါတယ်။ Priority ပိုမြင့်တဲ့ interrupt ကို ကိုင်တွယ်နေတုန်း ဒါမှမဟုတ် interrupt တွေကို ခဏ ပိတ်ထားတုန်း (မနှောင့်ယှက်ရမယ့် အလုပ် လုပ်နေစဉ် system က interrupt တွေကို ခဏ ပိတ်ထားနိုင်ပါတယ်) တုံ့ပြန်မှု နောက်ကျနိုင်ပါသေးတယ်
ပါဝါ နည်းနည်း သုံးခြင်း: interrupt တွေကြားမှာ CPU က ပါဝါ နည်းနည်းပဲ သုံးတဲ့ idle/sleep အခြေအနေကို ဝင်နိုင်ပါတယ်

Interrupt ကို ကိုင်တွယ်တဲ့ အထူး code ကို Interrupt Service Routine (ISR) (interrupt ကို ကိုင်တွယ်ဖို့ run တဲ့ သီးသန့် code) လို့ ခေါ်ပါတယ် (interrupt handler လို့လည်း ခေါ်ပါတယ်)။

Interrupt ကို ကိုင်တွယ်တဲ့ အဆင့်ဆင့်

Interrupt တစ်ခု ဖြစ်တဲ့အခါ CPU က အဲဒါကို လုံလုံခြုံခြုံ ကိုင်တွယ်ပြီး အရင် လုပ်နေတဲ့ အလုပ်ဆီ ပြန်သွားနိုင်ဖို့ တိကျတဲ့ အဆင့်ဆင့်ကို လိုက်နာပါတယ်။

Normal execution
    |
    v
[Interrupt signal received]
    |
    v
CPU finishes current instruction
    |
    v
CPU saves state (registers, PC) to stack
    |
    v
CPU identifies interrupt source
    |
    v
Jump to Interrupt Service Routine (ISR)
    |
    v
ISR handles the event
    |
    v
Restore saved state from stack
    |
    v
Resume normal execution

ပုံထဲက အဆင့်တွေရဲ့ အဓိပ္ပာယ်:

Normal execution: ပုံမှန်အတိုင်း run နေတယ်
Interrupt signal received: interrupt signal ရောက်လာတယ်
CPU finishes current instruction: CPU က လက်ရှိ instruction ကို ပြီးအောင် လုပ်တယ်
CPU saves state (registers, PC) to stack: CPU က သူ့ state (register တွေထဲမှာ လက်ရှိ ရှိနေတဲ့ တန်ဖိုးများ) ကို stack (အပေါ်ကနေပဲ ထည့်၊ ထုတ်တဲ့ အထပ်) ထဲမှာ သိမ်းတယ်၊ register (CPU ထဲက အမြန်ဆုံး သိမ်းဆည်းရာ) တွေနဲ့ PC (program counter: နောက် run မယ့် instruction ရဲ့ address ကို သိမ်းထားတဲ့ register) ပါဝင်ပါတယ်
CPU identifies interrupt source: interrupt ဘယ်ကနေ လာလဲ CPU က ခွဲခြားသိတယ်
Jump to Interrupt Service Routine (ISR): ISR ဆီ ခုန်သွားတယ်
ISR handles the event: ISR က event ကို ကိုင်တွယ်တယ်
Restore saved state from stack: သိမ်းထားတဲ့ state ကို stack ထဲကနေ ပြန်ယူတယ်
Resume normal execution: ပုံမှန်အတိုင်း ဆက် run တယ်

CPU က state ကို ဘာကြောင့် သိမ်းရသလဲ။ ISR က သူ့အလုပ်အတွက် CPU ရဲ့ register တွေကို သုံးမှာပါ။ မူလ register တန်ဖိုးတွေကို မသိမ်းထားရင် ကြားဖြတ်ခံရတဲ့ program ရဲ့ ဒေတာတွေ ထပ်ရေးခံရပြီး ပျောက်သွားပါလိမ့်မယ်။ Stack က ဒီတန်ဖိုးတွေကို သိမ်းထားပြီး နောက်မှ ပြန်ယူဖို့ လုံခြုံတဲ့ နေရာ တစ်ခုကို ပေးပါတယ်။

Interrupt ကို ကိုင်တွယ်တဲ့ အဆင့်တိုင်းကို ဖော်ပြနိုင်ရမယ်၊ CPU က state ကို ဘာကြောင့် သိမ်းပြီး ပြန်ယူလဲ (ကြားဖြတ်ခံရတဲ့ process (run နေတဲ့ program) က ရပ်ခဲ့တဲ့ နေရာကနေ အတိအကျ ဆက်လုပ်နိုင်အောင်) ဆိုတာကိုလည်း ရှင်းပြနိုင်ရပါမယ်။ အခြေအနေ တစ်ခုမှာ interrupt တွေ ဘယ်လို အလုပ်လုပ်လဲ ဖော်ပြတဲ့အခါ ISR ရဲ့ လုပ်ဆောင်ချက်တွေကို အဲဒီ အခြေအနေနဲ့ အမြဲ ချိတ်ပြီး ပြောပါ: ဥပမာ Control Systems (ထိန်းချုပ်ရေး စနစ်များ) စာမျက်နှာက အားကစားရုံ ဥပမာမှာ ISR က “event ကို ကိုင်တွယ်တယ်” လို့ပဲ မပြောဘဲ blind (နေကာ လိပ်ကာ) တစ်ခု သူ့ လမ်းကြောင်းရဲ့ အဆုံးကို ရောက်တာနဲ့ အဲဒီ blind ရဲ့ motor ကို ပိတ်လိုက်ပါတယ်။

နှိုင်းယှဉ်ချက် ဇယား

အချက်	Polling	Interrupts
Timing (အချိန်)	Synchronous: CPU ရဲ့ အချိန်ဇယားအတိုင်း စစ်ပါတယ်	Asynchronous: device ရဲ့ event ဖြစ်တဲ့ အချိန်တိုင်း signal ရောက်လာပါတယ်
Mechanism (အလုပ်လုပ်ပုံ)	Software: CPU က run တဲ့ loop တစ်ခု (CPU က စတင်)	Hardware: device က ပို့တဲ့ signal တစ်ခု (device က စတင်)
Priority (ဦးစားပေးမှု)	မရှိပါ: device တွေကို ပုံသေ အစဉ်အတိုင်း စစ်ပါတယ်	Source တွေကို အဆင့် သတ်မှတ်နိုင်လို့ အရေးအကြီးဆုံးကို အရင် ကိုင်တွယ်ပါတယ်
CPU efficiency (CPU ကို ထိရောက်စွာ သုံးမှု)	CPU အချိန်က အများအားဖြင့် ဘာမှ မတွေ့တဲ့ စစ်ဆေးမှုတွေမှာ ကုန်ပါတယ်	Device တစ်ခုက CPU ကို လိုတဲ့အထိ CPU အချိန်ကို တခြား အလုပ်မှာ သုံးပါတယ်
Response speed (တုံ့ပြန်မှု မြန်နှုန်း)	ပိုနှေးပါတယ်: loop က သူ့ device ဆီ ရောက်တဲ့အထိ event က စောင့်ရပါတယ်	များသောအားဖြင့် မြန်ပါတယ်: စစ်ဆေးမှုကို စောင့်စရာ မလိုပါဘူး၊ ဒါပေမယ့် priority ပိုမြင့်တဲ့ interrupt က နှောင့်နှေးစေနိုင်ပါတယ်
Power consumption (ပါဝါ သုံးစွဲမှု)	ပိုများပါတယ်: အဆက်မပြတ် polling မှာ CPU က အလုပ်ရှုပ်နေပြီး timer နဲ့ polling မှာ စစ်ဆေးမှု တစ်ကြိမ်စီတိုင်း နိုးရပါတယ်	ပိုနည်းပါတယ်: event တွေကြားမှာ CPU က idle/sleep ဖြစ်နိုင်ပါတယ်
Predictability (ကြိုခန့်မှန်းနိုင်မှု)	Deterministic (ဘယ်လောက် ကြာမလဲ ကြိုသိနိုင်တဲ့) timing	Non-deterministic (ဘယ်လောက် ကြာမလဲ ကြိုမသိနိုင်တဲ့) timing (interrupt တွေ nest ဖြစ်နိုင်လို့ပါ၊ ဆိုလိုတာက interrupt တစ်ခုကို ကိုင်တွယ်နေတုန်း နောက်တစ်ခု ထပ်ဝင်လာနိုင်ပါတယ်)
Best for (အသင့်တော်ဆုံး)	မကြာခဏ ဖြစ်ပြီး ကြိုခန့်မှန်းလို့ရတဲ့ event တွေ (ဥပမာ sensor (ပတ်ဝန်းကျင် အပြောင်းအလဲကို ထောက်လှမ်းတဲ့ ကိရိယာ) ဒေတာကို ပုံမှန် ဖတ်ယူခြင်း)	ရံဖန်ရံခါမှ ဖြစ်ပြီး ကြိုမခန့်မှန်းနိုင်တဲ့ event တွေ (ဥပမာ keyboard input)

IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) ရဲ့ syllabus (သင်ရိုး) က polling နဲ့ interrupt ကို evaluate (အားသာချက်နဲ့ အားနည်းချက်တွေကို ချိန်ဆပြီး အကဲဖြတ်ပါ) လုပ်ခိုင်းပါတယ်: ဒါက ပေးထားတဲ့ အခြေအနေ တစ်ခုမှာ နည်းလမ်း တစ်ခုစီကို ဖော်ပြရုံ မဟုတ်ဘဲ ထောက်ခံတဲ့ ဘက်ရော ကန့်ကွက်တဲ့ ဘက်ကပါ ဆွေးနွေးနိုင်ရမယ်လို့ ဆိုလိုပါတယ်။

Polling ကို ဘယ်အချိန် သုံးမလဲ

အခြေအနေ တချို့မှာ polling က ပိုကောင်းတဲ့ ရွေးချယ်မှုပါ:

မကြာခဏ ဖြစ်တဲ့ event တွေ: millisecond တိုင်း sensor ကို ဖတ်ခြင်း (ဥပမာ ဒေတာက ပုံသေ၊ မြန်တဲ့ နှုန်းနဲ့ ရောက်လာတဲ့ real-time (ချက်ချင်း ဆက်တိုက်) အသံ စီမံဆောင်ရွက်ခြင်း)
အချိန်ကို ကြိုခန့်မှန်းနိုင်ဖို့ လိုတဲ့အခါ: deterministic ဖြစ်ဖို့ မရှိမဖြစ် လိုတဲ့ safety-critical (မှားယွင်းရင် အသက်အန္တရာယ် ဒါမှမဟုတ် ကြီးမားတဲ့ ဆုံးရှုံးမှု ဖြစ်နိုင်တဲ့) system တွေ (ဥပမာ စက်ရုံ လုပ်ငန်းစဉ် ထိန်းချုပ်ရေး)
ရိုးရှင်းတဲ့ embedded system (စက်ထဲ ထည့်ထားတဲ့ ကွန်ပျူတာငယ်) တွေ: interrupt hardware နည်းတဲ့ ဒါမှမဟုတ် မပါတဲ့ microcontroller (chip တစ်ခုတည်းပေါ်မှာ processor၊ memory နဲ့ input/output ပါတဲ့ ကွန်ပျူတာ အသေးလေး) တွေ
Debugging (program ထဲက အမှားကို ရှာပြီး ပြင်ခြင်း): asynchronous interrupt တွေက run နေတဲ့ အစဉ်ကို မနှောင့်ယှက်တော့လို့ code run ပုံကို လိုက်ကြည့်ရ ပိုလွယ်ပါတယ်

Interrupt ကို ဘယ်အချိန် သုံးမလဲ

အောက်ပါ အခြေအနေတွေမှာ interrupt က ပိုကောင်းတဲ့ ရွေးချယ်မှုပါ:

ရံဖန်ရံခါမှ ဖြစ်တဲ့ event တွေ: keyboard နှိပ်တာ၊ mouse click တွေ၊ printer က စက္ကူ ကုန်ပြီလို့ အသိပေးတာ (event တွေက ရှားရှားပါးပါး ဖြစ်ပြီး ဘယ်အချိန် ဖြစ်မလဲ ကြိုမသိနိုင်ပါဘူး)
ဘက်ထရီနဲ့ သုံးတဲ့ device တွေ: interrupt တွေကြားမှာ CPU က sleep ဖြစ်နိုင်ပါတယ် (smartphone၊ smartwatch၊ laptop)
I/O device (ဒေတာ အဝင်အထွက် စက်ပစ္စည်း) အများ: device တစ်ခုချင်းကို poll လုပ်ဖို့ CPU အချိန် မပေးရဘဲ device အများကြီးကို ထိရောက်စွာ ကိုင်တွယ်နိုင်ပါတယ်
Real-time တုံ့ပြန်နိုင်ဖို့: interrupt ကို priority မြင့်မြင့် ပေးထားရင် အရေးပေါ် event တွေကို မြန်မြန် တုံ့ပြန်နိုင်ပါတယ် (ဥပမာ စက်ရုံသုံး စက်ပစ္စည်းတွေက အရေးပေါ် ရပ်တန့် ခလုတ်)

လက်တွေ့ ဘဝက အခြေအနေများ

1. Smartphone

Smartphone တစ်လုံးက touch screen input၊ ဝင်လာတဲ့ notification တွေနဲ့ ဖုန်းခေါ်ဆိုမှုတွေအတွက် interrupt တွေကို သုံးပါတယ်။ ဒီ event တွေက ရံဖန်ရံခါမှ ဖြစ်ပြီး ကြိုမခန့်မှန်းနိုင်ပါဘူး။ ဖုန်းကို မသုံးဘဲ ထားတုန်း touch screen ကို polling နဲ့ တစ်စက္ကန့်ကို ထောင်ချီ စစ်နေရင် ဘက်ထရီ မြန်မြန် ကုန်သွားပါလိမ့်မယ်။ Interrupt တွေကြောင့် CPU က sleep ဖြစ်နေပြီး လိုမှပဲ နိုးပါတယ်။

2. Gaming PC

Gaming PC တစ်လုံးက keyboard နဲ့ mouse input အတွက် interrupt တွေကို သုံးပါတယ်: CPU ရဲ့ မြန်နှုန်းနဲ့ ယှဉ်ရင် player က key တွေကို ရှားရှားပါးပါးပဲ နှိပ်ပါတယ်။ GPU (ဂရပ်ဖစ် processor) က render (ပုံဖော်) လုပ်ပြီးသား frame (screen ပေါ်မှာ တစ်ကြိမ် ပြတဲ့ ပုံ တစ်ပုံ) တွေကို display memory (screen ပေါ် ပြမယ့် ပုံကို သိမ်းတဲ့ memory) ဆီ ရွှေ့ဖို့ Direct Memory Access (DMA) (CPU ကို မဖြတ်ဘဲ memory ထဲ ဒေတာကို တိုက်ရိုက် ရွှေ့တဲ့ နည်း) ကို သုံးပါတယ်၊ ပြီးတော့ CPU ကို စောင့်မနေစေဘဲ ရွှေ့ပြီးတဲ့အခါ CPU ဆီ interrupt တစ်ခု ပို့ပါတယ်။

3. စက်ရုံက Sensor Network

စက်ရုံ တစ်ရုံက 100 millisecond တိုင်း ပုံမှန် ယူတဲ့ အပူချိန် sensor ဖတ်ချက်တွေအတွက် polling ကို သုံးပါတယ်။ ဖတ်ချက်တွေက အဆက်မပြတ် ဖြစ်ပြီး ကြိုခန့်မှန်းလို့ ရပါတယ်၊ ပြီးတော့ အန္တရာယ်ရှိတဲ့ အပူချိန် ပြောင်းလဲမှုတွေကို အချိန်ခြား အတိအကျမှာ သိရှိဖို့ system က deterministic timing လိုပါတယ်။ Polling က ဖတ်ချက်တွေကို တိတိကျကျ သိထားတဲ့ အချိန်တွေမှာ ယူတာကို သေချာစေပါတယ်။

4. Smartwatch Fitness Tracker (ကိုယ်လက်လှုပ်ရှားမှု မှတ်တဲ့ smartwatch)

Smartwatch တစ်လုံးက နှလုံးခုန်နှုန်း sensor (ဖတ်ချက်တွေကို အချိန်အပိုင်းအခြားနဲ့ပဲ ယူ) နဲ့ accelerometer (ရွေ့လျားမှုကို တိုင်းတဲ့ sensor) ရဲ့ wake-on-motion (လှုပ်ရှားမှု ရှိမှ CPU ကို နှိုးပေးခြင်း: user က လက်ကောက်ဝတ်ကို မလှုပ်မချင်း CPU က sleep ဖြစ်နေ) အတွက် interrupt တွေကို သုံးပါတယ်။ ဒါက ဘက်ထရီ သက်တမ်းကို အရှည်ဆုံး ဖြစ်စေပါတယ်: CPU က တစ်ကြိမ်မှာ စက္ကန့် အတော်ကြာ deep sleep (နက်နက် အိပ်နေတဲ့) အခြေအနေမှာ ရှိနေနိုင်ပြီး sensor interrupt တစ်ခု ထွက်လာမှပဲ နိုးပါတယ်။

စာမေးပွဲ မေးခွန်းတွေမှာ event တွေ ဖြစ်တဲ့ အကြိမ်ရေ နဲ့ ပါဝါ ကန့်သတ်ချက် တွေကို အမြဲ အရင် စဉ်းစားပါ။ ဒီ အချက် နှစ်ခုက polling နဲ့ interrupt ထဲက ဘယ်ဟာ ပိုသင့်တော်လဲ ဆိုတာကို များသောအားဖြင့် ဆုံးဖြတ်ပေးပါတယ်။

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

ဥပမာ 1: ကျောင်းရဲ့ Web Server အတွက် Polling နဲ့ Interrupt ကို အကဲဖြတ်ခြင်း

ကျောင်း တစ်ကျောင်းက စာမေးပွဲ ရလဒ်တွေကို တင်ထားတဲ့ web server (ဝဘ်စာမျက်နှာတွေကို ပို့ပေးတဲ့ server) တစ်ခုကို run ထားပါတယ်။ ရလဒ်ထုတ်တဲ့ နေ့မှာ server က တစ်စက္ကန့်ကို request (တောင်းဆိုချက်) ထောင်ချီ ရပါတယ်။ ရလဒ်ထုတ်တဲ့ နေ့ မဟုတ်ရင်တော့ traffic (network ပေါ်က ဒေတာ အသွားအလာ) အလွန် နည်းပါတယ်: တစ်မိနစ်ကို request အနည်းငယ်လောက်ပဲ ဖြစ်နိုင်ပါတယ်။

အလုပ်အများဆုံး အချိန် (ရလဒ်ထုတ်တဲ့ နေ့): Polling က ပိုကောင်းနိုင်ပါတယ်။ Event တွေက အရမ်း မကြာခဏ ဖြစ်လို့ interrupt တစ်ခုစီအတွက် CPU ရဲ့ register တွေကို သိမ်းပြီး ပြန်ယူရတဲ့ overhead (အပို ကုန်ကျတဲ့ အချိန်နဲ့ အလုပ်) က loop ထဲမှာ request အသစ်တွေကို ရိုးရိုး စစ်တဲ့ ကုန်ကျစရိတ်ထက် ပိုများသွားပါတယ်။ CPU က ဘယ်လိုပဲ ဖြစ်ဖြစ် event တွေကို အဆက်မပြတ်နီးပါး ကိုင်တွယ်နေရမှာမို့ polling ရဲ့ “အလကား ကုန်တဲ့ cycle (CPU ရဲ့ clock pulse တစ်ချက်စာ အချိန်)” တွေက အနည်းဆုံးပါ။

ပုံမှန် အချိန်တွေမှာ: Interrupt တွေက ပိုကောင်းပါတယ်။ တစ်မိနစ်ကို request အနည်းငယ်ပဲ ရှိတဲ့အခါ polling က CPU cycle အများစုကို queue (အရင်ထည့်တာ အရင်ထွက်တဲ့ တန်း) အလွတ်ကို စစ်ရင်း အလကား ဖြုန်းပါလိမ့်မယ်။ Interrupt တွေကြောင့် CPU က တခြား အလုပ်တွေ (backup (အရန် မိတ္တူ) တွေ၊ update တွေ) ကို လုပ်နေနိုင်ပြီး request ရောက်လာမှပဲ တုံ့ပြန်ပါတယ်။

နိဂုံး: hybrid (ရောစပ်) နည်းလမ်းက အကောင်းဆုံးပါ: server က ပုံမှန် load (အလုပ်ဝန်) မှာ interrupt-driven I/O (interrupt နဲ့ ဒေတာ အဝင်အထွက်ကို ကိုင်တွယ်ခြင်း) ကို သုံးပြီး traffic က threshold (သတ်မှတ်ထားတဲ့ အမှတ်) ကို ကျော်တဲ့အခါ polling mode ကို ပြောင်းပါတယ်။ ခေတ်သစ် စွမ်းဆောင်ရည်မြင့် network driver (network card ကို ထိန်းချုပ်တဲ့ software) တွေ (ဥပမာ Linux NAPI) က တကယ်ကို ဒီလို အလုပ်လုပ်ပါတယ်။

ဥပမာ 2: Interrupt ကို ကိုင်တွယ်တဲ့ အဆင့်ဆင့်ကို Trace လုပ်ခြင်း

အခြေအနေ: CPU က Process A (spreadsheet (ဇယားကွက် စာရင်း software) တွက်ချက်မှု တစ်ခု၊ instruction 47 မှာ ရောက်နေ) ကို run နေတုန်း user က key တစ်ခုကို နှိပ်ပါတယ်။

အဆင့်	ဘာဖြစ်လဲ	အသေးစိတ်
1	Keyboard controller (keyboard ကို ထိန်းချုပ်တဲ့ chip) က interrupt signal ပို့ပါတယ်	Control bus (control signal တွေ သွားတဲ့ bus) ပေါ်က hardware interrupt line ကို ဖွင့်လိုက်ပါတယ် (assert)
2	CPU က လက်ရှိ instruction ကို ပြီးအောင် လုပ်ပါတယ်	Process A ရဲ့ instruction 47 ပုံမှန်အတိုင်း ပြီးဆုံးပါတယ်
3	CPU က Process A ရဲ့ state ကို သိမ်းပါတယ်	Register တွေကို (PC = 48 အပါအဝင်) stack ပေါ်ကို push (stack ရဲ့ အပေါ်ဆုံးမှာ ထည့်ခြင်း) လုပ်ပါတယ်
4	CPU က interrupt source ကို ခွဲခြားသိပါတယ်	Keyboard ISR ရဲ့ address ကို ရှာဖို့ interrupt vector table (interrupt တစ်ခုစီရဲ့ ISR address တွေကို စုထားတဲ့ ဇယား) ကို ကြည့်ပါတယ်
5	CPU က keyboard ISR ဆီ ခုန်သွားပါတယ်	PC ကို ISR ရဲ့ memory address (memory ထဲက နေရာ လိပ်စာ) အဖြစ် သတ်မှတ်ပါတယ်
6	ISR က key code ကို ဖတ်ပါတယ်	ISR က keyboard ရဲ့ data register (စက်ကနေ ဝင်လာတဲ့ ဒေတာကို ခဏ ကိုင်ထားတဲ့ register) ကနေ scan code (key တစ်ခုစီကို ကိုယ်စားပြုတဲ့ code နံပါတ်) ကို ဖတ်ပါတယ်
7	ISR က key ကို input buffer (ဖတ်ဖို့ ကျန်နေတဲ့ input ကို ခဏ သိမ်းထားတဲ့ နေရာ) ထဲ သိမ်းပါတယ်	Application က နောက်မှ ဖတ်နိုင်အောင် character (စာလုံး ဒါမှမဟုတ် သင်္ကေတ) ကို OS ရဲ့ input buffer ထဲ ထည့်ပါတယ်
8	CPU က Process A ရဲ့ state ကို ပြန်ယူပါတယ်	Register တွေကို stack ကနေ pop (stack ရဲ့ အပေါ်ဆုံးကနေ ဖယ်ထုတ်ခြင်း) လုပ်ပါတယ်၊ PC ကို 48 အဖြစ် ပြန်ထားပါတယ်
9	Process A ဆက် run ပါတယ်	ဘာမှ မဖြစ်ခဲ့သလိုပဲ instruction 48 ကနေ ဆက် run ပါတယ်

အဓိက အချက်: Process A က ကြားဖြတ်ခံရမှန်း လုံးဝ မသိပါဘူး။ သူ့ဘက်ကနေ ကြည့်ရင် CPU က ကြားဖြတ်မှု မရှိဘဲ instruction တစ်ခုပြီး တစ်ခု ဆက် run နေခဲ့သလိုပါပဲ။

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

Q1. Polling ရဲ့ အဓိက အားနည်းချက်က ဘာလဲ။

Q2. Interrupt Service Routine (ISR) ဆိုတာ ဘာလဲ။

Q3. ဘက်ထရီနဲ့ သုံးတဲ့ device အတွက် ဘယ်နည်းလမ်းက ပိုကောင်းသလဲ။

Q4. Polling latency (တောင်းဆိုမှုနဲ့ တုံ့ပြန်မှုကြား နှောင့်နှေးချိန်) က interrupt latency ထက် ဘာကြောင့် ပိုကြိုခန့်မှန်းလို့ ရသလဲ။

Q5. ဘယ်အခြေအနေမှာ polling က interrupt ထက် ပိုကောင်းသလဲ။

Trace the Interrupt (interrupt ကို တစ်ဆင့်ချင်း လိုက်ကြည့်ခြင်း)

Disk I/O ပြီးကြောင်း အသိပေးတဲ့ interrupt (disk ကနေ ဒေတာ ဖတ်တာ ဒါမှမဟုတ် ရေးတာ ပြီးပြီလို့ ပြောတဲ့ interrupt) တစ်ခု ထွက်လာတဲ့အချိန် Process B က run နေပါတယ်။ Interrupt ကို ကိုင်တွယ်တဲ့ အဆင့် တစ်ခုစီမှာ ဘာဖြစ်လဲ ဖြည့်ပါ။

ဇယားထဲက စာတွေကို English လို ထားထားပြီး ကွင်းထဲမှာ အဓိပ္ပာယ် ပေးထားပါတယ်။ ကွက်လပ်တွေကိုလည်း ဇယားထဲက တခြား English စာတွေလို ပုံစံမျိုးနဲ့ English လို ရိုက်ထည့်ပါ။

Interrupt ကို ကိုင်တွယ်ပုံ Trace

Disk controller (disk ကို ထိန်းချုပ်တဲ့ chip) က ဒေတာ လွှဲပြောင်းတာ ပြီးပြီလို့ signal ပို့တဲ့အချိန် Process B က instruction 34 ကို run နေပါတယ်။ ပျောက်နေတဲ့ တန်ဖိုးတွေကို ဖြည့်ပြီး interrupt ကို ကိုင်တွယ်တဲ့ အဆင့်ဆင့်ကို trace လုပ်ပါ။

အဆင့်	Action (လုပ်ဆောင်ချက်)	CPU State (CPU ရဲ့ အခြေအနေ)
1	Disk controller sends interrupt signal (disk controller က interrupt signal ပို့တယ်)
2		Running Process B (Process B ကို run နေတယ်)
3		Saving state (state ကို သိမ်းနေတယ်)
4	Jump to disk ISR (disk ISR ဆီ ခုန်သွားတယ်)
5		Running ISR (ISR ကို run နေတယ်)
6		Restoring state (state ကို ပြန်ယူနေတယ်)
7	Resume Process B (Process B ကို ဆက် run တယ်)

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

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

1POLLING 2In polling, the device sends a signal to the CPU when it needs attention. 3This is simple to implement and gives predictable timing. 4However, it wastes CPU cycles when no events are occurring.

Line တွေရဲ့ အဓိပ္ပာယ်: (1) POLLING (ခေါင်းစဉ်)၊ (2) Polling မှာ device က အာရုံစိုက်ပေးဖို့ လိုတဲ့အခါ CPU ဆီ signal ပို့ပါတယ်၊ (3) ဒါက အကောင်အထည်ဖော်ရ ရိုးရှင်းပြီး ကြိုခန့်မှန်းလို့ရတဲ့ timing ကို ပေးပါတယ်၊ (4) ဒါပေမယ့် event တစ်ခုမှ မဖြစ်တဲ့အခါ CPU cycle တွေကို ဖြုန်းပါတယ်။

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

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

ကွက်လပ်ပါတဲ့ စာကြောင်းတွေက English နဲ့ ဖြစ်ပြီး ကွက်လပ်တွေကိုလည်း English စကားလုံးနဲ့ ရိုက်ထည့်ရပါမယ်။ POLLING vs INTERRUPTS က ခေါင်းစဉ်ပါ။ စာကြောင်းတွေရဲ့ အဓိပ္ပာယ်က အောက်ပါအတိုင်းပါ:

…… မှာ CPU က device ရဲ့ status register ကို ထပ်ခါထပ်ခါ စစ်ပါတယ်။
Interrupt တစ်ခု ထွက်လာတဲ့အခါ CPU က …… လို့ ခေါ်တဲ့ အထူး code အစု တစ်ခုကို run ပါတယ်။
Interrupt ကို မကိုင်တွယ်ခင် CPU က သူ့ လက်ရှိ state ကို …… ရပါမယ်။
…… ဖြစ်ပြီး ကြိုခန့်မှန်းလို့ ရတဲ့ event တွေအတွက် polling က ပိုကောင်းပါတယ်။
CPU က sleep ဖြစ်နိုင်လို့ ……-powered device (…… နဲ့ အလုပ်လုပ်တဲ့ device) တွေအတွက် interrupt တွေက ပိုကောင်းပါတယ်။

Polling နဲ့ interrupt handling အကြောင်း အောက်ပါ ဖော်ပြချက်တွေကို ပြည့်စုံအောင် ဖြည့်ပါ:

POLLING vs INTERRUPTS
=====================
In , the CPU repeatedly checks a device's status register.

When an interrupt fires, the CPU runs a special routine called an .

The CPU must  its current state before handling an interrupt.

Polling is better for events that are  and predictable.

Interrupts are better for -powered devices because the CPU can sleep.

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

System တစ်ခုမှာ device နှစ်ခု ရှိပါတယ်:

Keyboard: တစ်စက္ကန့်ကို event 5 ခုခန့် ထုတ်ပါတယ်
Sensor: တစ်စက္ကန့်ကို event 1000 ခုခန့် ထုတ်ပါတယ်

ဘယ် device က polling ကို သုံးသင့်သလဲ။ (Device နာမည်ကို English လို ရိုက်ထည့်ပါ)

Laptop တစ်လုံးက ဘက်ထရီနဲ့ run နေပါတယ်။ User က document တစ်ခုကို ဖတ်နေပါတယ်: စက္ကန့် 30 ကြာအောင် စာရိုက်တာ၊ mouse ရွှေ့တာ မရှိပါဘူး။

ဒီ idle (အလုပ်မရှိဘဲ နားနေတဲ့) ကာလအတွင်း ဘယ် I/O ကိုင်တွယ်ပုံ နည်းလမ်းက CPU ကို ပါဝါ အများဆုံး ချွေတာနိုင်စေသလဲ။ (နည်းလမ်းရဲ့ နာမည်ကို English လို ရိုက်ထည့်ပါ)

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

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

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

အဓိပ္ပာယ် ဖွင့်ပြီး နှိုင်းယှဉ်ပါ: polling နဲ့ interrupt handling ကို ကိုယ့်စကားနဲ့ကိုယ် Define (အဓိပ္ပာယ်ကို တိတိကျကျ ဖော်ပြပါ) လုပ်ပါ။ နည်းလမ်း တစ်ခုစီရဲ့ အားသာချက် တစ်ခုစီ ပေးပါ။
Interrupt အဆင့်ဆင့်: CPU က word processor (စာစီစာရိုက် software) ကို run နေတုန်း mouse click interrupt တစ်ခု ထွက်လာတဲ့အခါ ဖြစ်တဲ့ interrupt ကိုင်တွယ်ပုံ အဆင့်ဆင့်ကို Describe (ဖော်ပြရှင်းပြပါ) လုပ်ပါ။ မတူတဲ့ အဆင့် အနည်းဆုံး ခြောက်ခုကို Name (နာမည် ဖော်ပြပါ) လုပ်ပါ။
Polling ကို သုံးတဲ့ အခြေအနေများ: interrupt ထက် polling က ပိုကောင်းတဲ့ အခြေအနေ နှစ်ခုကို State (ဖော်ပြပါ)။ တစ်ခုစီအတွက် polling က ဘာကြောင့် ပိုကောင်းတဲ့ ရွေးချယ်မှု ဖြစ်လဲ Explain (ရှင်းပြပါ) လုပ်ပါ။

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

အခြေအနေ သုံးခုအတွက် အကဲဖြတ်ပါ: အောက်ပါ တစ်ခုစီအတွက် polling နဲ့ interrupt ထဲက ဘယ်ဟာ ပိုသင့်တော်လဲ Evaluate လုပ်ပါ။ Event အကြိမ်ရေ၊ CPU overhead နဲ့ ပါဝါ သုံးစွဲမှုကို ကိုးကားပြီး သင့်အဖြေကို Justify (ဘာကြောင့် ရွေးတာလဲ အကြောင်းပြချက်နဲ့ ပြပါ) လုပ်ပါ:
- (a) Desktop ကွန်ပျူတာ တစ်လုံးရဲ့ keyboard input
- (b) နျူကလီးယား ဓာတ်ပေါင်းဖို တစ်ခုထဲက အပူချိန် sensor ဖတ်ချက်များ (50ms တိုင်း ဖတ်)
- (c) တစ်စက္ကန့်ကို packet 10,000 လက်ခံနေရတဲ့ အလုပ်များတဲ့ web server ပေါ်က network card
Latency ကို ခွဲခြမ်းစိတ်ဖြာခြင်း: interrupt latency က polling latency ထက် ဘာကြောင့် ကြိုခန့်မှန်းရ ပိုခက်လဲ Explain လုပ်ပါ။ သင့်အဖြေမှာ interrupt ကိုင်တွယ်ရာမှာ ပါဝင်တဲ့ အဆင့်တွေနဲ့ အဲဒီ အဆင့်တွေ ကြာချိန် ဘယ်လို ကွာခြားနိုင်လဲ ဆိုတာကို ကိုးကားပါ။

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

မောင်းသူမဲ့ ကား အကဲဖြတ်ချက်: မောင်းသူမဲ့ ကား (self-driving car) တစ်စီးမှာ sensor အများကြီး ပါပါတယ်: LIDAR (laser နဲ့ အကွာအဝေး တိုင်းတဲ့ sensor) (တစ်စက္ကန့်ကို ဖတ်ချက် 60)၊ camera တွေ (တစ်စက္ကန့်ကို frame 30) နဲ့ အရေးပေါ် ဘရိတ် ခလုတ် (ရှားရှားပါးပါးပဲ နှိပ်ပေမယ့် 1 millisecond အတွင်း တုံ့ပြန်ရမယ်)။ Sensor တစ်ခုစီအတွက် polling နဲ့ interrupt ထဲက ဘယ်ဟာ ပိုသင့်တော်လဲ Evaluate လုပ်ပါ။ သင့်အဖြေမှာ performance (စွမ်းဆောင်ရည်) နဲ့ ဘေးကင်းရေး အကျိုးဆက် နှစ်ခုလုံးကို ထည့်စဉ်းစားပါ။
စာမေးပွဲ ပုံစံ 4 မှတ် မေးခွန်း: ဘက်ထရီနဲ့ သုံးတဲ့ laptop တစ်လုံးပေါ်က keyboard input ကို စီမံဖို့ polling နဲ့ interrupt handling ကို Compare and contrast (နှစ်ခုလုံးကို တစ်လျှောက်လုံး ထည့်ပြီး တူတာတွေနဲ့ ကွာတာတွေကို ဖော်ပြပါ) လုပ်ပါ။ သင့်အဖြေမှာ နည်းလမ်း တစ်ခုစီရဲ့ အဓိပ္ပာယ်၊ ဒီအခြေအနေအတွက် ဘယ်ဟာ ပိုသင့်တော်လဲ ဆိုတဲ့ အကဲဖြတ်ချက်နဲ့ အကြောင်းပြချက် ခိုင်လုံတဲ့ နိဂုံး ပါရပါမယ်။ [4 marks]

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

အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: OS Fundamentals (operating system ရဲ့ အခြေခံများ): OS (operating system: ကွန်ပျူတာကို စီမံတဲ့ အဓိက software) က polling နဲ့ interrupt တွေကို သုံးပြီး device I/O ကို စီမံပါတယ်
အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: CPU Architecture (CPU ရဲ့ ဖွဲ့စည်းပုံ): interrupt တွေက FDE cycle (ညွှန်ကြားချက်ကို ယူ၊ နားလည်၊ လုပ်ဆောင်တဲ့ စက်ဝန်း) နဲ့ ဆက်စပ်ပါတယ်၊ CPU က register တွေနဲ့ stack ကို သုံးပြီး state ကို သိမ်း/ပြန်ယူပါတယ်
ဆက်စပ် ခေါင်းစဉ်: Scheduling (ဘယ် process ကို CPU အချိန် ပေးမလဲ ဆုံးဖြတ်ခြင်း): interrupt တွေက context switch (process တစ်ခုကနေ တစ်ခုကို CPU ပြောင်းခြင်း) တွေနဲ့ scheduling ကို ပြန်လုပ်တာတွေကို စတင်စေနိုင်ပါတယ်
နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Multitasking (အလုပ် အများကို တစ်ပြိုင်နက်လို လုပ်ခြင်း) (HL၊ Higher Level: IB သင်တန်းမှာ ပိုနက်နက်ရှိုင်းရှိုင်း လေ့လာရတဲ့ အဆင့်): multitasking OS အလုပ်လုပ်ဖို့ interrupt handling က မရှိမဖြစ် လိုအပ်ပါတယ်
နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Control Systems (HL): control system တွေက sensor ဒေတာ ရယူဖို့ polling ရော interrupt ပါ သုံးပါတယ်