CPU scheduling எப்படி வேலை செய்கிறது, மேலும் பொதுவான algorithms என்ன?

Question

IT Interview Practice · Accepted Answer

**CPU scheduling** என்பது தயார் நிலையில் உள்ள *எந்த* thread-க்கு CPU *அடுத்ததாக*, *எவ்வளவு நேரம்* கிடைக்கும் என்ற kernel-இன் முடிவு. வழக்கமாக cores-ஐ விட அதிக இயங்கக்கூடிய threads இருப்பதால், **scheduler** அவற்றை multiplex செய்து, போட்டியிடும் இலக்குகளை — **throughput**, **குறைந்த latency / response time**, மற்றும் **நியாயம் (fairness)** — சமநிலைப்படுத்த முயல்கிறது, அதே நேரம் **starvation**-ஐத் தவிர்க்கிறது.

## பொதுவான algorithms

```text
FCFS (first-come, first-served) → simple, but one long job blocks everyone (convoy effect)
SJF  (shortest job first)       → optimal avg wait, but needs to know job length; can starve long jobs
Round-robin (RR)                → each job a fixed TIME SLICE (quantum), cycle through → fair, good latency
Priority                        → highest priority first → can STARVE low priority (fix: aging)
MLFQ (multi-level feedback)     → several priority queues; jobs that use a full quantum sink,
                                  interactive jobs that yield stay high → approximates SJF without knowing lengths
```

**Round-robin** மைய கட்டுப்பாட்டு விசையை — **quantum** — விளக்குகிறது:

```text
quantum too SMALL → fair & responsive, but lots of context-switch overhead
quantum too LARGE → less overhead, but degrades toward FCFS (poor responsiveness)
```

## உண்மையான schedulers

Linux-இன் நீண்டகால இயல்புநிலை **CFS (Completely Fair Scheduler)**: நிலையான slices-க்குப் பதிலாக அது ஒவ்வொரு task-இன் **virtual runtime (vruntime)**-ஐக் கண்காணித்து, அதன் **nice** மதிப்பால் எடைபோடப்பட்டு, இதுவரை மிகக் குறைந்த CPU பெற்ற thread-ஐ எப்போதும் இயக்குகிறது — "ஒவ்வொருவரும் நியாயமான பங்கைப் பெறுகிறார்கள்" என்பதை தோராயமாக அமைக்கிறது. இது vruntime மூலம் ஒரு red-black tree-ஐ key செய்கிறது, எனவே அடுத்த task-ஐத் தேர்ந்தெடுப்பது O(log n). (புதிய kernels EEVDF-ஐப் பயன்படுத்துகின்றன, அதே fairness இலக்குடன் கூடிய, இறுக்கமான latency எல்லைகள் கொண்ட ஒரு செம்மைப்படுத்தல்.)

**Preemptive vs cooperative:** நவீன OSes **preemptive** — ஒரு timer interrupt scheduler-ஐ CPU-ஐ வலுக்கட்டாயமாகத் திரும்பப் பெற அனுமதிக்கிறது, எனவே ஒரு thread ஒரு core-ஐ முழுமையாக ஆக்கிரமிக்க முடியாது.

## இது ஏன் முக்கியம்

Scheduling பயனர்கள் உணரும் latency மற்றும் throughput-ஐ நேரடியாக வடிவமைக்கிறது. நீங்கள் trade-offs-ஐப் புரிந்துகொள்கிறீர்களா என்று பார்க்க interviewers இதை ஆராய்கிறார்கள் — ஒரு interactive workload ஏன் குறுகிய quanta அல்லது ஒரு priority boost விரும்புகிறது, priority scheduling starvation-ஐத் தடுக்க ஏன் **aging** தேவை, மேலும் MLFQ/CFS job lengths-ஐ முன்கூட்டியே அறியாமல் எப்படி நல்ல interactive நடத்தையைப் பெறுகின்றன. இது `nice`, real-time priorities-ஐ tune செய்வதற்கும், starve ஆன அல்லது laggy service-ஐக் கண்டறிவதற்கும் பின்னால் உள்ள சிந்தனை மாதிரியும் ஆகும்.

பொதுவான algorithms

உண்மையான schedulers

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்