Panimula sa Mga Operating System
Hello, Habr! Nais kong ipakita sa iyong pansin ang isang serye ng mga artikulo-pagsasalin ng isang panitikan na kawili-wili sa aking opinyon - OSTEP. Malalim na sinusuri ng materyal na ito ang gawain ng mga operating system na katulad ng unix, ibig sabihin, gumagana sa mga proseso, iba't ibang mga scheduler, memorya at iba pang katulad na mga bahagi na bumubuo sa isang modernong OS. Maaari mong makita ang orihinal ng lahat ng mga materyales dito . Pakitandaan na ang pagsasalin ay ginawa nang hindi propesyonal (medyo malaya), ngunit sana ay pinanatili ko ang pangkalahatang kahulugan.
Ang gawain sa laboratoryo sa paksang ito ay matatagpuan dito:
Iba pang parte:
Maaari mo ring tingnan ang aking channel sa =)
Pagpaplano: Multi-Level Feedback Queue
Sa panayam na ito ay pag-uusapan natin ang tungkol sa mga problema ng pagbuo ng isa sa mga pinakatanyag na diskarte sa
pagpaplano, na tinatawag na Multi-Level Feedback Queue (MLFQ). Ang MLFQ scheduler ay unang inilarawan noong 1962 ni Fernando J. CorbatΓ³ sa isang sistema na tinatawag na
Compatible Time-Sharing System (CTSS). Ang mga gawaing ito (kabilang ang mga susunod na gawain sa
Multics) ay kasunod na hinirang para sa Turing Award. Ang nagplano ay
pagkatapos ay napabuti at nakuha ang hitsura na makikita na sa
ilang modernong sistema.
Sinusubukan ng algorithm ng MLFQ na lutasin ang 2 pangunahing magkakapatong na problema.
Una, sinusubukan nitong i-optimize ang oras ng turnaround, na, tulad ng tinalakay natin sa nakaraang lecture, ay na-optimize sa pamamagitan ng paraan ng pagsisimula sa simula ng queue ang pinaka.
maikling gawain. Gayunpaman, hindi alam ng OS kung gaano katagal tatakbo ang isang partikular na proseso, at ito
kinakailangang kaalaman para sa pagpapatakbo ng SJF, STCF algorithm. Ikalawa, sinusubukan ng MLFQ
gawing tumutugon ang system para sa mga user (halimbawa, para sa mga nakaupo at
tumitig sa screen na naghihintay na makumpleto ang gawain) at sa gayon ay mabawasan ang oras
tugon. Sa kasamaang palad, ang mga algorithm tulad ng RR ay nagpapabuti sa oras ng pagtugon, ngunit labis
magkaroon ng masamang epekto sa sukatan ng oras ng turnaround. Kaya ang aming problema: Paano magdisenyo
isang scheduler na makakatugon sa aming mga kinakailangan nang walang nalalaman tungkol sa
ang likas na katangian ng proseso sa pangkalahatan? Paano matututunan ng scheduler ang mga katangian ng mga gawain,
na inilulunsad nito at sa gayon ay gumawa ng mas mahusay na mga desisyon sa pagpaplano?
Ang kakanyahan ng problema: Paano magplano ng pagtatakda ng mga gawain nang walang perpektong kaalaman?
Paano magdisenyo ng scheduler na sabay na nagpapaliit sa oras ng pagtugon
para sa mga interactive na gawain at kasabay nito ay pinapaliit ang oras ng turnaround nang hindi nalalaman
kaalaman sa oras ng pagsasagawa ng gawain?
Tandaan: natututo tayo sa mga nakaraang kaganapan
Ang MLFQ queue ay isang mahusay na halimbawa ng isang sistema na natututo mula sa
mga nakaraang kaganapan upang mahulaan ang hinaharap. Ang mga katulad na diskarte ay madalas
matatagpuan sa OS (At marami pang ibang sangay ng computer science, kabilang ang mga branch
mga hula sa hardware at mga algorithm ng pag-cache). Mga katulad na biyahe
ay na-trigger kapag ang mga gawain ay may mga yugto ng pag-uugali at sa gayon ay mahuhulaan.
Gayunpaman, dapat kang maging maingat sa pamamaraang ito dahil ang mga hula ay napakadali
maaaring lumabas na hindi tama at humantong sa sistema na gumawa ng mas masahol na desisyon kaysa
ay walang kaalaman sa lahat.
MLFQ: Mga Pangunahing Panuntunan
Tingnan natin ang mga pangunahing tuntunin ng MLFQ algorithm. At kahit na ang mga pagpapatupad ng algorithm na ito
Mayroong ilang, ang mga pangunahing diskarte ay magkatulad.
Sa pagpapatupad na aming titingnan, ang MLFQ ay magkakaroon ng ilan
magkahiwalay na mga pila, na ang bawat isa ay magkakaroon ng iba't ibang priyoridad. Kahit kailan,
isang gawain na handa para sa pagpapatupad ay nasa isang pila. Gumagamit ang MLFQ ng mga priyoridad,
upang magpasya kung aling gawain ang tatakbo para sa pagpapatupad, i.e. gawain na may mas mataas
priyoridad (gawain mula sa pila na may pinakamataas na priyoridad) ay unang ilulunsad
pila.
Siyempre, maaaring mayroong higit sa isang gawain sa isang naibigay na pila, kaya
kaya pareho sila ng priority. Sa kasong ito, gagamitin ang mekanismo
RR na mag-iskedyul ng pagtakbo sa mga gawaing ito.
Kaya nakarating tayo sa dalawang pangunahing tuntunin para sa MLFQ:
- Panuntunan1: Kung priority(A) > Priority(B), ang gawain A ay ilulunsad (B ay hindi)
- Panuntunan2: Kung priority(A) = Priority(B), A&B ay sisimulan gamit ang RR
Batay sa itaas, ang mga pangunahing elemento sa pagpaplano ng MLFQ
ay mga priyoridad. Sa halip na bigyan ng nakapirming priyoridad ang bawat isa
gawain, binabago ng MLFQ ang priyoridad nito depende sa naobserbahang pag-uugali.
Halimbawa, kung ang isang gawain ay patuloy na naghahagis ng trabaho sa CPU habang naghihintay ng input ng keyboard,
Pananatilihin ng MLFQ na mataas ang priyoridad ng proseso dahil ganyan
isang interactive na proseso ang dapat gumana. Kung, sa kabaligtaran, ang gawain ay patuloy at
gumagamit ng CPU nang husto sa mahabang panahon, ibababa ito ng MLFQ
ang prioridad. Kaya, pag-aaralan ng MLFQ ang pag-uugali ng mga proseso habang tumatakbo ang mga ito
at gumamit ng mga pag-uugali.
Gumuhit tayo ng isang halimbawa kung ano ang maaaring hitsura ng mga pila sa isang punto
oras at pagkatapos ay makakakuha ka ng isang bagay tulad nito:
Sa scheme na ito, 2 proseso A at B ang nasa pinakamataas na priyoridad na pila. Proseso
Ang C ay nasa gitna, at ang proseso D ay nasa pinakadulo ng pila. Ayon sa itaas
Ayon sa mga paglalarawan ng MLFQ algorithm, ang scheduler ay isasagawa ang mga gawain lamang na may pinakamataas
priority ayon sa RR, at ang mga gawain C, D ay mawawalan ng trabaho.
Naturally, ang isang static na snapshot ay hindi magbibigay ng kumpletong larawan kung paano gumagana ang MLFQ.
Mahalagang maunawaan nang eksakto kung paano nagbabago ang larawan sa paglipas ng panahon.
Pagsubok 1: Paano baguhin ang priyoridad
Sa puntong ito kailangan mong magpasya kung paano babaguhin ng MLFQ ang antas ng priyoridad
mga gawain (at sa gayon ang posisyon ng gawain sa pila) habang umuusad ito sa ikot ng buhay nito. Para sa
ito ay kinakailangan upang isaisip ang daloy ng trabaho: isang tiyak na halaga
mga interactive na gawain na may maikling runtime (at sa gayon ay madalas na pagpapalabas
CPU) at ilang matagal nang gawain na gumagamit ng CPU sa lahat ng kanilang oras ng pagtatrabaho, habang
Ang oras ng pagtugon ay hindi mahalaga para sa mga ganitong gawain. At sa ganitong paraan maaari mong gawin ang iyong unang pagsubok
ipatupad ang MLFQ algorithm na may mga sumusunod na patakaran:
- Rule3: Kapag ang isang gawain ay pumasok sa system, ito ay inilalagay sa queue na may pinakamataas
- priority.
- Rule4a: Kung ginagamit ng isang gawain ang buong window ng oras na inilaan dito, pagkatapos ay ito
- nababawasan ang priority.
- Rule4b: Kung ang isang Gawain ay naglalabas ng CPU bago mag-expire ang window ng oras nito, kung gayon ito
- nananatiling may parehong priyoridad.
Halimbawa 1: Isang matagal na gawain
Tulad ng makikita sa halimbawang ito, ang gawain sa pagpasok ay itinakda na may pinakamataas
priority. Pagkatapos ng time window na 10ms, ang proseso ay ibababa sa priyoridad
tagaplano. Pagkatapos ng susunod na window, ang gawain ay sa wakas ay na-demote sa
pinakamababang priyoridad sa system, kung saan ito nananatili.
Halimbawa 2: Naghatid ng maikling gawain
Ngayon tingnan natin ang isang halimbawa kung paano susubukan ng MLFQ na lapitan ang SJF. Sa ganyan
halimbawa, dalawang gawain: A, na isang matagalang gawain na patuloy
sumasakop sa CPU at B, na isang maikling interactive na gawain. Kumbaga
na si A ay matagal nang nagtatrabaho sa oras na dumating ang gawain B.
Ipinapakita ng graph na ito ang mga resulta ng senaryo. Gawain A, tulad ng anumang gawain,
Ang paggamit ng CPU ay nasa pinakailalim. Darating ang Gawain B sa oras na T=100 at darating
inilagay sa pinakamataas na priyoridad na pila. Dahil ang oras ng pagpapatakbo nito ay maikli, kung gayon
makukumpleto ito bago makarating sa huling pila.
Mula sa halimbawang ito, ang pangunahing layunin ng algorithm ay dapat na maunawaan: dahil ang algorithm ay hindi
alam kung ang isang gawain ay mahaba o maikli, pagkatapos ay una sa lahat ay ipinapalagay niya na ang gawain
maikli at binibigyan ito ng pinakamataas na priyoridad. Kung ito ay talagang maikling gawain, kung gayon
mabilis itong matatapos, kung hindi man, kung ito ay isang mahabang gawain, ito ay mabagal
priority down at malapit nang patunayan na siya ay talagang isang mahabang gawain na hindi
nangangailangan ng tugon.
Halimbawa 3: Paano ang I/O?
Ngayon tingnan natin ang isang halimbawa ng I/O. Gaya ng nakasaad sa panuntunan 4b,
kung ilalabas ng isang proseso ang processor nang hindi ginagamit ang lahat ng oras ng processor nito,
pagkatapos ay nananatili ito sa parehong antas ng priyoridad. Ang layunin ng panuntunang ito ay medyo simple
- kung ang interactive na trabaho ay gumaganap ng maraming I/O operations, halimbawa, paghihintay
mula sa user key o pagpindot ng mouse, ang ganitong gawain ay magpapalaya sa processor
bago ang inilaan na bintana. Hindi namin nais na ibaba ang priyoridad ng naturang gawain,
at sa gayon ito ay mananatili sa parehong antas.
Ipinapakita ng halimbawang ito kung paano gagana ang algorithm sa mga naturang proseso - interactive na trabaho B, na nangangailangan lamang ng CPU para sa 1ms bago isagawa
I/O na proseso at matagal nang Job A, na gumugugol ng lahat ng oras nito sa paggamit ng CPU.
Pinapanatili ng MLFQ ang proseso B sa pinakamataas na priyoridad dahil nagpapatuloy ito
ilabas ang CPU. Kung ang B ay isang interactive na gawain, kung gayon ang algorithm ay nakamit
Ang iyong layunin ay mabilis na magpatakbo ng mga interactive na gawain.
Mga problema sa kasalukuyang MLFQ algorithm
Sa mga nakaraang halimbawa, gumawa kami ng pangunahing bersyon ng MLFQ. At parang siya
ginagawa ang trabaho nito nang maayos at tapat, na namamahagi ng oras ng CPU nang patas sa pagitan
mahahabang gawain at nagpapahintulot sa maikli o mataas na dami ng mga gawain
gumana sa I/O nang mabilis. Sa kasamaang palad, ang pamamaraang ito ay naglalaman ng ilan
malubhang problema.
Una, ang problema ng kagutuman: kung ang sistema ay maraming interactive
mga gawain, pagkatapos ay ubusin nila ang lahat ng oras ng processor at sa gayon ay hindi isa sa loob ng mahabang panahon
ang gawain ay hindi maisakatuparan (sila ay nagugutom).
Ikalawa, ang mga matalinong gumagamit ay maaaring sumulat ng kanilang mga programa upang iyon
lokohin ang scheduler. Ang panlilinlang ay namamalagi sa paggawa ng isang bagay upang pilitin
Binibigyan ng scheduler ang proseso ng mas maraming oras ng CPU. Algorithm iyon
inilarawan sa itaas ay medyo mahina sa mga katulad na pag-atake: bago ang window ng oras ay praktikal
natapos, kailangan mong magsagawa ng I/O operation (sa ilan, kahit anong file)
at sa gayon ay palayain ang CPU. Ang ganitong pag-uugali ay magpapahintulot sa iyo na manatili sa pareho
ang pila mismo at muli ay makakakuha ng mas malaking porsyento ng oras ng CPU. Kung gagawin mo
ito ay tama (halimbawa, isagawa ang 99% ng oras ng window bago ilabas ang CPU),
ang ganitong gawain ay maaaring monopolyo lamang ang processor.
Sa wakas, maaaring baguhin ng isang programa ang pag-uugali nito sa paglipas ng panahon. Yung mga gawain
na ginamit ang CPU ay maaaring maging interactive. Sa aming halimbawa, katulad
ang mga gawain ay hindi makakatanggap ng pagtratong nararapat sa kanila mula sa scheduler gaya ng gagawin ng iba
(paunang) interactive na mga gawain.
Tanong para sa madla: anong mga pag-atake sa scheduler ang maaaring isagawa sa modernong mundo?
Pagsubok 2: Pagtaas ng priyoridad
Subukan nating baguhin ang mga patakaran at tingnan kung maiiwasan natin ang mga problema
pag-aayuno. Ano ang maaari naming gawin upang matiyak na nauugnay
Ang mga gawain ng CPU ay makakakuha ng kanilang oras (kahit na hindi mahaba).
Bilang isang simpleng solusyon sa problema, maaari kang magmungkahi ng pana-panahon
itaas ang priyoridad ng lahat ng naturang gawain sa system. Maraming paraan
Upang makamit ito, subukan nating ipatupad ang isang bagay na simple bilang isang halimbawa: isalin
lahat ng mga gawain ay agad na binibigyan ng pinakamataas na priyoridad, kaya ang bagong panuntunan:
- Panuntunan5: Pagkatapos ng isang tiyak na panahon S, ilipat ang lahat ng mga gawain sa system sa pinakamataas na pila.
Nilulutas ng aming bagong panuntunan ang dalawang problema nang sabay-sabay. Una, ang mga proseso
ay garantisadong hindi magugutom: ang mga gawain na nasa pinakamataas na priyoridad ay hahatiin
Oras ng CPU ayon sa RR algorithm at sa gayon ang lahat ng mga proseso ay matatanggap
oras ng CPU. Pangalawa, kung ilang proseso na dati nang ginamit
ang processor lamang ang nagiging interactive, mananatili ito sa pila na may pinakamataas
priyoridad pagkatapos makatanggap ng isang beses na pagtaas sa priyoridad hanggang sa pinakamataas.
Tingnan natin ang isang halimbawa. Sa sitwasyong ito, isaalang-alang ang isang proseso gamit
CPU at dalawang interactive, maikling proseso. Sa kaliwa sa figure, ipinapakita ng figure ang pag-uugali nang walang priyoridad na promosyon, at sa gayon ang matagal na gawain ay magsisimulang magutom pagkatapos ng dalawang interactive na gawain na dumating sa system. Sa figure sa kanan, ang isang pagtaas ng priyoridad ay ginagawa tuwing 50ms at sa gayon ang lahat ng mga proseso ay garantisadong makakatanggap ng oras ng CPU at ilulunsad sa pana-panahon. Ang 50ms sa kasong ito ay kinuha bilang isang halimbawa; sa katotohanan ang bilang na ito ay bahagyang mas mataas.
Malinaw, ang pagdaragdag ng pana-panahong pagtaas ng oras na humahantong sa S
isang lohikal na tanong: anong halaga ang dapat itakda? Isa sa pinarangalan
Tinawag ng mga system engineer na si John Ousterhout ang mga naturang dami sa mga system bilang voo-doo
pare-pareho, dahil nangangailangan sila ng black magic para sa tama
nagpapakita. At, sa kasamaang palad, ang S ay may ganoong amoy. Kung itinakda mo rin ang halaga
magsisimulang magutom ang malalaking - mahabang gawain. At kung itinakda mo ang halaga ng masyadong mababa,
Ang mga interactive na gawain ay hindi makakatanggap ng tamang oras ng CPU.
Pagsubok 3: Mas mahusay na Accounting
Ngayon ay mayroon tayong isa pang problemang dapat lutasin: kung paano hindi
payagan ang aming scheduler na lokohin? Ang mga taong dapat sisihin sa posibilidad na ito ay
panuntunan 4a, 4b, na nagpapahintulot sa isang trabaho na mapanatili ang priyoridad, na nagpapalaya sa processor
bago mag-expire ang inilaang oras. Paano haharapin ito?
Ang solusyon sa kasong ito ay maaaring ituring na isang mas mahusay na accounting ng oras ng CPU sa bawat isa
antas ng MLFQ. Sa halip na kalimutan ang oras na ginamit ng programa
processor para sa inilaang panahon, dapat itong isaalang-alang at i-save. Pagkatapos
naubos na ng proseso ang inilaan nitong oras, dapat itong ibaba sa susunod
antas ng priyoridad. Ngayon hindi mahalaga kung paano gagamitin ng proseso ang oras nito - kung paano
patuloy na nagko-compute sa processor o bilang isang bilang ng mga tawag. kaya,
ang panuntunan 4 ay dapat na muling isulat sa sumusunod na anyo:
- Panuntunan4: Matapos maubos ng isang gawain ang inilalaang oras nito sa kasalukuyang pila (kahit gaano karaming beses nitong pinalaya ang CPU), ang priyoridad ng gawaing iyon ay ibinababa (ito ay bumababa sa pila).
Tingnan natin ang isang halimbawa:
Β»
Ipinapakita ng figure kung ano ang mangyayari kung susubukan mong lokohin ang scheduler, tulad ng
kung ito ay kasama ang mga naunang tuntunin 4a, 4b ang resulta sa kaliwa ay makukuha. Maligayang bago
ang panuntunan ay ang resulta sa kanan. Bago ang proteksyon, anumang proseso ay maaaring tumawag sa I/O bago makumpleto at
kaya dominahin ang CPU, pagkatapos paganahin ang proteksyon, anuman ang pag-uugali
I/O, bababa pa rin siya sa pila at sa gayon ay hindi niya magagawang hindi tapat
sakupin ang mga mapagkukunan ng CPU.
Pagpapabuti ng MLFQ at iba pang mga problema
Sa mga pagpapabuti sa itaas ay may mga bagong problema: isa sa mga pangunahing
Mga Tanong - paano i-parameter ang naturang scheduler? Yung. Magkano ang dapat
pila? Ano ang dapat na laki ng window ng programa sa loob ng pila? Paano
Ang priyoridad ng programa ay dapat na madalas na taasan upang maiwasan ang gutom at
isaalang-alang ang pagbabago sa pag-uugali ng programa? Walang simpleng sagot sa mga tanong na ito
sagot at mga eksperimento lamang na may mga load at kasunod na configuration
ang tagaplano ay maaaring humantong sa ilang kasiya-siyang balanse.
Halimbawa, pinapayagan ka ng karamihan sa mga pagpapatupad ng MLFQ na magtalaga ng iba
agwat ng oras para sa iba't ibang pila. Karaniwang mataas ang priyoridad na pila
ang mga maikling agwat ay inireseta. Ang mga pila na ito ay binubuo ng mga interactive na gawain,
paglipat sa pagitan ng kung saan ay medyo sensitibo at dapat tumagal ng 10 o mas kaunti
MS. Sa kabaligtaran, ang mga queue na mababa ang priyoridad ay binubuo ng mga pangmatagalang gawain na gumagamit
CPU. At sa kasong ito, ang mga mahabang agwat ng oras ay magkasya nang husto (100ms).
Sa halimbawang ito mayroong 2 gawain na nagtrabaho sa mataas na priyoridad na pila 20
ms, nahahati sa 10ms windows. 40ms sa gitnang pila (20ms window) at nasa mababang priyoridad
Ang window ng queue time ay naging 40ms kung saan natapos ng mga gawain ang kanilang trabaho.
Ang pagpapatupad ng Solaris OS ng MLFQ ay isang klase ng mga scheduler ng pagbabahagi ng oras.
Magbibigay ang tagaplano ng isang hanay ng mga talahanayan na eksaktong tumutukoy sa nararapat
ang priyoridad ng proseso ay nagbabago sa kurso ng buhay nito, kung ano ang dapat na laki
nakalaan na window at kung gaano kadalas kailangan mong itaas ang mga priyoridad sa gawain. Tagapangasiwa
maaaring makipag-ugnayan ang mga system sa talahanayang ito at maging sanhi ng pag-uugali ng scheduler
iba. Bilang default, ang talahanayang ito ay may 60 queue na may unti-unting pagtaas
laki ng window mula 20ms (high priority) hanggang ilang daang ms (low priority), at
din sa pagpapalakas ng lahat ng mga gawain isang beses bawat segundo.
Ang ibang mga tagaplano ng MLFQ ay hindi gumagamit ng talahanayan o anumang partikular
mga panuntunan na inilarawan sa panayam na ito, sa kabaligtaran, kinakalkula nila ang mga priyoridad gamit
mga pormula sa matematika. Halimbawa, ang FreeBSD scheduler ay gumagamit ng formula para sa
kalkulahin ang kasalukuyang priyoridad ng isang gawain batay sa kung gaano katagal ang proseso
ginamit na CPU. Bilang karagdagan, ang paggamit ng CPU ay nabubulok sa paglipas ng panahon, at iba pa
Kaya, ang pagtaas ng priyoridad ay medyo naiiba kaysa sa inilarawan sa itaas. Ito ay totoo
tinatawag na decay algorithm. Mula noong bersyon 7.1, ginamit ng FreeBSD ang ULE scheduler.
Sa wakas, maraming mga scheduler ang may iba pang mga tampok. Halimbawa, ang ilan
Inilalaan ng mga scheduler ang pinakamataas na antas para sa pagpapatakbo ng operating system at sa gayon
Kaya, walang proseso ng user ang makakatanggap ng pinakamataas na priyoridad sa
sistema. Pinapayagan ka ng ilang system na magbigay ng payo para tumulong
ang tagaplano ay maaaring magtakda ng mga priyoridad nang tama. Halimbawa, gamit ang command maganda
maaari mong dagdagan o bawasan ang priyoridad ng isang gawain at sa gayon ay dagdagan o
bawasan ang mga pagkakataon ng programa na gumamit ng oras ng CPU.
MLFQ: Buod
Inilarawan namin ang isang diskarte sa pagpaplano na tinatawag na MLFQ. Pangalan niya
nakapaloob sa prinsipyo ng operasyon - mayroon itong ilang mga pila at gumagamit ng feedback
upang matukoy ang priyoridad ng gawain.
Ang huling anyo ng mga patakaran ay ang mga sumusunod:
- Panuntunan1: Kung priority(A) > Priority(B), ang gawain A ay ilulunsad (B ay hindi)
- Panuntunan2: Kung priority(A) = Priority(B), A&B ay sinimulan gamit ang RR
- Panuntunan3: Kapag ang isang gawain ay pumasok sa system, ito ay inilalagay sa pinakamataas na priyoridad na pila.
- Panuntunan4: Matapos maubos ng isang gawain ang inilalaang oras nito sa kasalukuyang pila (kahit gaano karaming beses nitong pinalaya ang CPU), ang priyoridad ng gawaing iyon ay ibinababa (ito ay bumababa sa pila).
- Panuntunan5: Pagkatapos ng isang tiyak na panahon S, ilipat ang lahat ng mga gawain sa system sa pinakamataas na pila.
Ang MLFQ ay kawili-wili para sa sumusunod na dahilan - sa halip na nangangailangan ng kaalaman tungkol sa
likas na katangian ng gawain nang maaga, pinag-aaralan ng algorithm ang nakaraang pag-uugali ng gawain at mga set
mga priyoridad nang naaayon. Kaya, sinusubukan niyang umupo sa dalawang upuan nang sabay-sabay - upang makamit ang pagiging produktibo para sa maliliit na gawain (SJF, STCF) at matapat na tumakbo nang mahaba,
Mga trabahong naglo-load ng CPU. Samakatuwid, maraming mga sistema, kabilang ang BSD at ang kanilang mga derivatives,
Gumagamit ang Solaris, Windows, Mac ng ilang anyo ng algorithm bilang scheduler
MLFQ bilang baseline.
Mga karagdagang materyales:
- (computing)
Pinagmulan: www.habr.com