I - O management — polling, interrupt-driven, DMA: Visual walkthrough

4.2.37 · D2 · Coding › Operating Systems › I - O management — polling, interrupt-driven, DMA

Step 1 — Do clocks, wildly out of step

KYA. Poore problem ko do timelines ke roop mein draw karo: ek CPU ke liye, ek device ke liye. Timeline bas ek horizontal line hai jahan left matlab pehle aur right matlab baad mein. Line pe ek chhota tick = "time ki ek chhoti unit guzri."

YE YAHAAN SE KYU shuru karte hain. Is page ka har cost formula actually "CPU ki timeline ka kitna hissa waste hota hai jab device ki timeline dheere dheere aage badhti hai." Agar tum dono timelines ko side by side dekh sako, toh formulas khud ban jaayenge. Yahi poora trick hai.

PICTURE. Figure mein, CPU ke ticks kaafi closely packed hain (fast); device ek ek "ready" pulse produce karta hai jo kaafi door right mein hai (slow). Amber gap dekho — woh gap hi dushman hai.

Figure — I - O management — polling, interrupt-driven, DMA

Step 2 — Polling: poora gap useless checks se bharo

KYA. CPU se sabse simple kaam karwao: ek loop mein baithke device ki status register padhta rahe (woh chhota box jo busy/ready kehta hai — dekho Memory-mapped I/O vs Port-mapped I/O ke liye ki CPU us box tak kaise pahunchta hai). Har loop pass mein $t_{p o l l}$ cost lagti hai. Hum tab tak loop karte hain jab tak amber gap khatam na ho.

KYU. Hum waste ko count karna chahte hain. Ye count karna ki $T_{d e v}$ gap mein kitne $t_{p o l l}$ -boxes fit hote hain, bas ek division hai — sabse natural sawaal jo "chhote boxes ek bade gap ko bharte hain" ki picture pooch sakti hai.

PICTURE. $T_{d e v}$ gap grey poll-boxes se edge-to-edge tile kiya gaya hai. Aakhiri box ko chhodkar har box ne device ko not ready paya → coloured wasted.

Edge case — ek fast device. Agar $T_{d e v}$ tiny hai (device almost hamesha ready), toh gap mein shayad sirf ek box aata hai. Tab polling almost kuch bhi waste nahi karti aur zero setup cost hoti hai — yeh woh ek case hai jahan polling jeet jaati hai. Picture se obvious hai: ek chhote gap mein zyada boxes nahi fit ho sakte.

Step 3 — Overlap ka idea: ghurna band karo, kaam karo

KYA. Gap ko checks se tile karne ki jagah, CPU ko $T_{d e v}$ ke dauran jaane do aur doosra useful kaam karne do. Jab device finish karta hai, woh ek interrupt fire karta hai (ek electrical "kandhe pe thapki" — dekho Interrupts and ISR) jo CPU ko thodi der ke liye waapis kheench laata hai.

YE TOOL KYU, POLLING NAHI. Polling ki khaami thi gap ko fill karna. Interrupt hume gap ko real kaam ke saath overlap karne deta hai, toh gap CPU ko kuch bhi cost nahi karta siwaaye us ek moment ke jab use wapas kheencha jaata hai. Hum ek bade waste ko ek chhote fixed fee ke liye trade kar rahe hain.

PICTURE. Device ki timeline mein abhi bhi wahi lamba gap hai, lekin CPU timeline ab useful work (cyan) se bhari hai, jisme ek single amber spike hai jahan interrupt land karta hai.

Step 4 — Kandhe ki thapki ghurne se kab behtar hai?

KYA. Dono costs ko ek data unit ke liye compare karo: polling poora gap $T_{d e v}$ jalata hai; interrupts ek spike $t_{in t}$ jalate hain.

KYU comparison. "Kaun behtar hai" hamesha ek sawaal hai ki kaun sa bar chhota hai. Toh hum do bars draw karte hain.

PICTURE. Do horizontal bars: ek lamba grey polling bar jis ki length $T_{d e v}$ hai, ek chhota amber interrupt bar jis ki length $t_{in t}$ hai. Winner woh hai jo chhota hai.

Slow device ke liye ( $T_{d e v}$ huge) lamba bar fee se kaafi bada hai → interrupts jeette hain. Yeh normal case hai (disks, keyboards).

Step 5 — Trap: ek fast device picture ko palat deta hai

KYA. Ab $T_{d e v}$ ko kaafi shrink karo: ek fast network card almost turant ready ho jaata hai, ek interrupt per byte fire karta hai millions of bytes per second pe.

KYU YE DIKHAO. Contract kehta hai har case cover karo, degenerate wala bhi jahan hamara naya tool ulta pad jaata hai. Agar nahi dikhaya, toh reader baad mein ambush ho jayega.

PICTURE. CPU timeline ab amber interrupt spikes ke ek jungle mein badal gayi hai jo itni tightly packed hain ki beech mein almost koi cyan work-time nahi bachi. $t_{in t}$ fee, $N$ baar pay ki gayi, poori line kha gayi hai.

Step 6 — DMA: poora block delegate karo, end mein ek thapki lo

KYA. Ek naya hardware piece add karo, DMA controller, jo har byte ko device aur memory ke beech khud memory bus ke zariye move karta hai. CPU sirf (1) use ek address aur count $N$ deke program karta hai, phir (2) ek single interrupt pata hai jab count zero ho jaata hai.

KYU YE TOOL. Steps 2–5 mein CPU ne personally har byte ko touch kiya → cost $N$ ke saath scale hoti hai. Scaling todne ke liye CPU ko per-byte loop se bilkul bahar nikaalna padega. Delegation ek aisi cheez hai jo yahi karti hai.

PICTURE. Device↔memory arrow ab DMA box ke through jaata hai, CPU ko bypass karta hua. CPU timeline almost poori cyan work hai, end mein ek single amber spike hai labeled "count = 0, done".

Step 7 — Ek honest catch: cycle stealing

KYA. DMA controller aur CPU ek memory bus share karte hain. Ek cycle mein sirf ek hi use kar sakta hai. Jab DMA ek word ke liye bus grab karta hai, CPU ko woh cycle wait karni padti hai.

KYU YE INCLUDE KARO. "DMA CPU ko 100% free kar deta hai" ek tempting jhooth hai. Bus ek shared road hai, aur bus arbitration decide karta hai kise milti hai.

PICTURE. Ek bus road; DMA aur CPU baar baar baari lete hain. Kuch CPU ticks greyed-out ("stalled") hain exactly jahan ek DMA word ghus gaya.

Ek-picture summary

KYA. Teeno CPU timelines stack kiye gaye, usi $N$ -byte job ke liye: polling (fully wasted), interrupt (spikes ka jungle), DMA (almost poori useful work + ek end spike). Yeh single frame hi derivation hai.

Formula Woh result jo humne zero se build kiya

Method	CPU cost for $N$ bytes	scaling
Polling	$N$ moves $+ \frac{T _{d e v}}{t _{p o l l}}$ wasted polls	$O (N)$ + waste
Interrupt	$N \cdot t_{in t}$	$O (N)$
DMA	$t_{se t u p} + t_{in t}$	$O (1)$

Recall Feynman: poora walkthrough simple words mein

Do clocks tick karte hain — ek fast CPU aur ek slow device — aur unke beech ka gap woh jagah hai jahan saari takleef rehti hai. Polling us gap ko bekar "ready ho gaye?" checks se bharta hai: count karo kitne checks gap mein fit hote hain aur wahi tumhara waste hai. Interrupts kehte hain: wahaan khade mat raho, kaam karo, khatam hone par kandhe pe thapki dunga — brilliant hai jab gap lamba ho, lekin agar device fast hai toh tum par million baar thapki padegi aur thapkiyan tumhe duba denge. DMA ek helper hire karta hai jo poora block khud move karta hai aur tumhe end mein exactly ek baar thapki maarta hai — toh chahe kitne bhi bytes hon, tumhari cost basically flat rehti hai. Ek aur baat: helper aur tum ek hallway (bus) share karte ho, toh kabhi kabhi jab woh guzarta hai toh tumhe ek beat rukna padta hai. Yahi poori kahani hai — polling $O (N)$ -with-waste, interrupts $O (N)$ , DMA $O (1)$ .

Recall Quick self-check

Kis method ki CPU cost block size $N$ ke saath nahi badhti? ::: DMA — yeh $O (1)$ hai, ek setup plus ek completion interrupt. Interrupts polling se kyun haar sakte hain? ::: Ek fast device har byte pe ek interrupt fire karta hai; $N \cdot t_{in t}$ CPU ko overwhelm kar deta hai. Step 1 mein amber gap kya hai? ::: $T_{d e v}$ , woh time jo slow device ko ready hone mein lagta hai.

Related deep vault reading: Device Drivers, Disk Scheduling, CPU utilization and throughput.