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:
- orihinal:
- orihinal:
- ang aking personal na adaptasyon:
Iba pang parte:
Maaari mo ring tingnan ang aking channel sa =)
Tingnan natin ang pinakapangunahing abstraction na ibinibigay ng OS sa mga user: ang proseso. Ang kahulugan ng proseso ay medyo simple - ito ay tumatakbong programa. Ang programa mismo ay isang walang buhay na bagay na matatagpuan sa disk - ito ay isang hanay ng mga tagubilin at posibleng ilang static na data na naghihintay na ilunsad. Ang OS ang kumukuha ng mga byte na iyon at nagpapatakbo ng mga ito, na ginagawang kapaki-pakinabang ang programa.
Kadalasan, nais ng mga user na magpatakbo ng higit sa isang programa nang sabay-sabay, halimbawa, maaari kang magpatakbo ng browser, laro, media player, text editor, at mga katulad nito sa iyong laptop. Sa katunayan, ang isang karaniwang sistema ay maaaring magpatakbo ng sampu o daan-daang mga proseso nang sabay-sabay. Ang katotohanang ito ay ginagawang mas madaling gamitin ang system, hindi mo na kailangang mag-alala kung ang CPU ay libre, nagpapatakbo ka lang ng mga programa.
Itinaas nito ang problema: paano magbigay ng ilusyon ng maraming mga CPU? Paano malilikha ng OS ang ilusyon ng halos walang katapusang bilang ng mga CPU, kahit na mayroon ka lamang isang pisikal na CPU?
Ang OS ay lumilikha ng ilusyon na ito sa pamamagitan ng CPU virtualization. Sa pamamagitan ng pagsisimula ng isang proseso, pagkatapos ay itigil ito, pagsisimula ng isa pang proseso, at iba pa, ang OS ay maaaring mapanatili ang ilusyon na mayroong maraming mga virtual na CPU, kapag sa katunayan ay magkakaroon ng isa o higit pang mga pisikal na processor. Ang pamamaraan na ito ay tinatawag na paghahati ng mga mapagkukunan ng CPU ayon sa oras. Binibigyang-daan ng diskarteng ito ang mga user na magpatakbo ng maraming magkakasabay na proseso hangga't gusto nila. Ang halaga ng solusyon na ito ay pagganap - dahil kung ang CPU ay ibinabahagi ng ilang mga proseso, ang bawat proseso ay mapoproseso nang mas mabagal.
Upang ipatupad ang virtualization ng CPU, at lalo na para magawa ito nang maayos, kailangan ng OS ang parehong mababang antas at mataas na antas ng suporta. Ang mababang antas ng suporta ay tinatawag mga mekanismo ay mga mababang antas na pamamaraan o protocol na nagpapatupad ng kinakailangang bahagi ng functionality. Ang isang halimbawa ng naturang pag-andar ay ang paglipat ng konteksto, na nagbibigay sa OS ng kakayahang ihinto ang isang programa at magpatakbo ng isa pang programa sa processor. Ang time division na ito ay ipinatupad sa lahat ng modernong operating system.
Sa ibabaw ng mga mekanismong ito ay ilang logic na binuo sa OS, sa anyo ng "mga patakaran". Patakaran ay isang tiyak na algorithm sa paggawa ng desisyon para sa operating system. Ang ganitong mga patakaran, halimbawa, ay nagpapasya kung aling programa ang dapat na unang ilunsad (mula sa isang listahan ng mga utos). Kaya, halimbawa, ang problemang ito ay malulutas sa pamamagitan ng isang patakarang tinatawag scheduler (patakaran sa pag-iskedyul) at kapag pumipili ng solusyon, gagabayan ito ng data tulad ng: kasaysayan ng pagsisimula (kung aling programa ang pinakamatagal na inilunsad sa mga huling minuto), anong karga ang dala ng prosesong ito (kung anong mga uri ng mga programa ang inilunsad), mga sukatan ng pagganap (kung ang system man ay na-optimize para sa interactive na pakikipag-ugnayan o para sa throughput ) at iba pa.
Abstraksyon: proseso
Ang abstraction ng isang tumatakbong programa na isinagawa ng operating system ang tinatawag namin paraan. Tulad ng nabanggit kanina, ang isang proseso ay isang tumatakbong programa lamang, sa anumang agarang yugto ng panahon. Isang programa kung saan makakakuha tayo ng buod ng impormasyon mula sa iba't ibang mapagkukunan ng system na ina-access o naaapektuhan ng program na ito sa panahon ng pagpapatupad nito.
Upang maunawaan ang mga bahagi ng proseso, kailangan mong maunawaan ang mga estado ng system: kung ano ang maaaring basahin o baguhin ng programa sa panahon ng operasyon nito. Sa anumang oras, kailangan mong maunawaan kung aling mga elemento ng system ang mahalaga para sa pagpapatupad ng programa.
Ang isa sa mga halatang elemento ng sistema ay nagsasaad na kasama sa proseso ay память. Ang mga tagubilin ay matatagpuan sa memorya. Ang data na binabasa o isinusulat ng programa ay matatagpuan din sa memorya. Kaya, ang memorya na maaaring tugunan ng isang proseso (tinatawag na address space) ay bahagi ng proseso.
Bahagi rin ng estado ng system ang mga rehistro. Maraming mga tagubilin ang naglalayong baguhin ang halaga ng mga rehistro o pagbabasa ng kanilang halaga, at sa gayon ang mga rehistro ay nagiging mahalagang bahagi din ng pagpapatakbo ng proseso.
Dapat tandaan na ang estado ng makina ay nabuo din mula sa ilang mga espesyal na rehistro. Halimbawa, IP - pointer ng pagtuturo — isang pointer sa pagtuturo na kasalukuyang isinasagawa ng programa. meron din stack pointer at may kaugnayan dito frame pointer, na ginagamit upang pamahalaan ang: mga parameter ng function, mga lokal na variable at mga return address.
Sa wakas, madalas na ina-access ng mga program ang ROM (read-only memory). Ang impormasyong ito ng "I/O" (input/output) ay dapat na may kasamang listahan ng mga file na kasalukuyang bukas sa proseso.
Process API
Upang mapabuti ang ating pag-unawa sa kung paano gumagana ang proseso, pag-aralan natin ang mga halimbawa ng mga tawag sa system na dapat isama sa anumang interface ng operating system. Ang mga API na ito ay magagamit sa isang form o iba pa sa anumang OS.
● Lumikha (paglikha): Ang OS ay dapat magsama ng ilang paraan na nagbibigay-daan sa iyong lumikha ng mga bagong proseso. Kapag nagpasok ka ng isang command sa terminal o naglunsad ng isang application sa pamamagitan ng pag-double click sa isang icon, isang tawag ang ipinadala sa OS upang lumikha ng isang bagong proseso at pagkatapos ay ilunsad ang tinukoy na programa.
● Pag-aalis: Dahil mayroong isang interface para sa paglikha ng isang proseso, ang OS ay dapat ding magbigay ng kakayahang pilitin ang pag-alis ng isang proseso. Karamihan sa mga programa ay natural na magsisimula at magwawakas sa kanilang sarili habang tumatakbo ang mga ito. Kung hindi, nais ng user na mapatay sila at sa gayon ay magiging kapaki-pakinabang ang isang interface upang ihinto ang proseso.
● Maghintay (naghihintay): Minsan kapaki-pakinabang na maghintay para sa isang proseso upang makumpleto, kaya ang ilang mga interface ay ibinigay na nagbibigay ng kakayahang maghintay.
● Misc Control (various control): Bilang karagdagan sa pagpatay at paghihintay sa proseso, mayroon ding iba pang iba't ibang paraan ng pagkontrol. Halimbawa, karamihan sa mga operating system ay nagbibigay ng kakayahang mag-freeze ng isang proseso (ihinto ang pagpapatupad nito sa isang tiyak na panahon) at pagkatapos ay ipagpatuloy ito (ipagpatuloy ang pagpapatupad)
● katayuan (estado): Mayroong iba't ibang mga interface para sa pagkuha ng ilang impormasyon tungkol sa katayuan ng isang proseso, gaya ng kung gaano katagal ito tumatakbo o kung anong estado ito sa kasalukuyan.
Proseso ng Paglikha: Mga Detalye
Ang isa sa mga kagiliw-giliw na bagay ay kung paano eksaktong nababago ang mga programa sa mga proseso. Lalo na kung paano kinukuha at pinapatakbo ng OS ang programa. Paano eksaktong nalikha ang proseso.
Una sa lahat, dapat i-load ng OS ang program code at static na data sa memorya (sa puwang ng address ng proseso). Ang mga programa ay karaniwang matatagpuan sa isang disk o solid-state drive sa ilang executable na format. Kaya, ang proseso ng pag-load ng program at static na data sa memorya ay nangangailangan ng OS na mabasa ang mga byte mula sa disk at ilagay ang mga ito sa isang lugar sa memorya.
Sa mga unang operating system, ang proseso ng paglo-load ay ginawa nang buong pananabik, na nangangahulugan na ang buong code ay na-load sa memorya bago ang programa ay inilunsad. Ginagawa ito ng mga modernong operating system nang tamad, iyon ay, naglo-load ng mga piraso ng code o data lamang kapag kinakailangan ng programa ang mga ito sa panahon ng pagpapatupad nito.
Kapag na-load na ang code at static na data sa memorya ng OS, may ilan pang bagay na kailangang gawin bago tumakbo ang proseso. Ang ilang halaga ng memorya ay dapat na ilaan para sa stack. Ginagamit ng mga program ang stack para sa mga lokal na variable, mga parameter ng function, at mga return address. Inilalaan ng OS ang memorya na ito at ibinibigay ito sa proseso. Ang stack ay maaari ding ilaan sa ilang mga argumento, partikular na pinupunan nito ang mga parameter ng main() function, halimbawa ng array ng argc at argv.
Ang operating system ay maaari ring maglaan ng ilang memory sa program heap. Ang heap ay ginagamit ng mga programa upang tahasang humiling ng dynamic na inilalaan na data. Hinihiling ng mga programa ang puwang na ito sa pamamagitan ng pagtawag sa function malloc () at tahasan itong nililinis sa pamamagitan ng pagtawag sa function libre(). Ang heap ay kailangan para sa mga istruktura ng data tulad ng mga naka-link na sheet, hash table, puno at iba pa. Sa una, ang isang maliit na halaga ng memorya ay inilalaan sa heap, ngunit sa paglipas ng panahon, habang tumatakbo ang programa, ang heap ay maaaring humiling ng higit pang memorya sa pamamagitan ng API ng library na tinatawag na malloc(). Ang operating system ay kasangkot sa proseso ng paglalaan ng mas maraming memorya upang makatulong na matugunan ang mga tawag na ito.
Magsasagawa rin ang operating system ng mga gawain sa pagsisimula, lalo na ang mga nauugnay sa I/O. Halimbawa, sa mga UNIX system, ang bawat proseso bilang default ay may 3 open file descriptor, para sa karaniwang input, output, at error. Ang mga handle na ito ay nagpapahintulot sa mga program na basahin ang input mula sa terminal pati na rin ang pagpapakita ng impormasyon sa screen.
Kaya, sa pamamagitan ng paglo-load ng code at static na data sa memorya, paglikha at pagsisimula ng stack, at paggawa ng iba pang gawaing nauugnay sa pagsasagawa ng mga gawain sa I/O, inihahanda ng OS ang yugto para maisagawa ang proseso. Sa wakas, may natitira pang huling gawain: pagpapatakbo ng programa sa pamamagitan ng entry point nito, na tinatawag na main() function. Sa pamamagitan ng pagsasagawa ng main() function, inililipat ng OS ang kontrol ng CPU sa bagong likhang proseso, kaya magsisimulang mag-execute ang program.
Katayuan ng proseso
Ngayon na mayroon na tayong kaunting pag-unawa sa kung ano ang isang proseso at kung paano ito nalikha, ilista natin ang mga estado ng proseso kung saan ito maaaring maging. Sa pinakasimpleng anyo nito, ang isang proseso ay maaaring nasa isa sa mga estadong ito:
● Tumatakbo. Kapag tumatakbo, ang proseso ay tumatakbo sa processor. Nangangahulugan ito na ang mga tagubilin ay isinasagawa.
● Nakahanda. Sa handa na estado, ang proseso ay handa nang tumakbo, ngunit sa ilang kadahilanan ay hindi ito isinasagawa ng OS sa tinukoy na oras.
● Pinigilan. Sa naka-block na estado, ang isang proseso ay nagsasagawa ng ilang mga operasyon na pumipigil sa pagiging handa na isagawa hanggang sa mangyari ang ilang kaganapan. Ang isang karaniwang halimbawa ay kapag ang isang proseso ay nagpasimula ng isang operasyon ng IO, ito ay na-block upang ang ibang proseso ay maaaring gumamit ng processor.
Maaari mong isipin ang mga estadong ito sa anyo ng isang graph. Gaya ng nakikita natin sa larawan, maaaring magbago ang estado ng proseso sa pagitan ng RUNNING at READY sa pagpapasya ng OS. Kapag ang estado ng isang proseso ay nagbago mula sa READY na naging RUNNING, nangangahulugan ito na ang proseso ay nakaiskedyul na. Sa kabaligtaran ng direksyon - inalis mula sa layout. Sa sandaling na-BLOCK ang isang proseso, halimbawa, sinimulan ko ang isang operasyon ng IO, pananatilihin ito ng OS sa ganitong estado hanggang sa mangyari ang ilang kaganapan, halimbawa ang pagkumpleto ng IO. sa sandaling ito ang paglipat sa READY state at posibleng kaagad sa RUNNING state kung ang OS ang nagpasya.
Tingnan natin ang isang halimbawa kung paano gumagalaw ang dalawang proseso sa mga estadong ito. Upang magsimula, isipin natin na ang parehong mga proseso ay tumatakbo, at ang bawat isa ay gumagamit lamang ng CPU. Sa kasong ito, magiging ganito ang hitsura ng kanilang mga estado.
Sa sumusunod na halimbawa, ang unang proseso, pagkatapos ng ilang oras na pagtakbo, ay humihiling ng IO at pumasok sa BLOCKED na estado, na nagpapahintulot sa isa pang proseso na tumakbo (FIG 1.4). Nakikita ng OS na ang proseso 0 ay hindi gumagamit ng CPU at sinimulan ang proseso 1. Habang tumatakbo ang proseso 1, ang IO ay nakumpleto at ang katayuan ng proseso 0 ay nagbabago sa READY. Sa wakas, nakumpleto na ang proseso 1, at kapag nakumpleto na, ang proseso 0 ay magsisimula, ipapatupad, at tatapusin ang gawain nito.
Istraktura ng data
Ang OS mismo ay isang programa, at tulad ng iba pang programa, mayroon itong ilang pangunahing istruktura ng data na sumusubaybay sa iba't ibang nauugnay na piraso ng impormasyon. Upang subaybayan ang estado ng bawat proseso, susuportahan ng OS ang ilan listahan ng proseso para sa lahat ng proseso sa READY state at ilang karagdagang impormasyon para masubaybayan ang mga prosesong kasalukuyang tumatakbo. Gayundin, dapat subaybayan ng OS ang mga naka-block na proseso. Matapos makumpleto ang IO, dapat gisingin ng OS ang kinakailangang proseso at ilagay ito sa isang estado na handa nang tumakbo.
Halimbawa, dapat panatilihin ng OS ang estado ng mga rehistro ng processor. Sa sandaling huminto ang proseso, ang estado ng mga rehistro ay naka-imbak sa puwang ng address ng proseso, at sa sandaling magpapatuloy ang operasyon nito, ang mga halaga ng mga rehistro ay naibalik at sa gayon ay ipagpatuloy ang pagpapatupad ng prosesong ito.
Bilang karagdagan sa handa, na-block, tumatakbo na mga estado, mayroong ilang iba pang mga estado. Minsan, sa panahon ng paglikha, maaaring nasa INIT state ang isang proseso. Sa wakas, ang isang proseso ay maaaring ilagay sa FINAL na estado kapag ito ay nakumpleto na, ngunit ang impormasyon nito ay hindi pa na-clear. Sa mga sistema ng UNIX ang estado na ito ay tinatawag proseso ng zombie. Ang estado na ito ay kapaki-pakinabang para sa mga kaso kung saan ang proseso ng magulang ay gustong malaman ang return code ng isang bata, halimbawa, kadalasan ang 0 ay nagpapahiwatig ng tagumpay at ang 1 ay isang error, ngunit ang mga programmer ay maaaring mag-isyu ng karagdagang mga output code upang magpahiwatig ng iba't ibang mga problema. Kapag natapos na ang proseso ng magulang, gagawa ito ng panghuling tawag sa system, gaya ng wait(), para hintayin ang proseso ng bata na magwakas at magsenyas sa OS na maaari nitong i-clear ang anumang data na nauugnay sa winakasan na proseso.
Mga pangunahing punto ng panayam:
● paraan — ang pangunahing abstraction ng isang tumatakbong programa sa OS. Sa anumang oras, maaaring ilarawan ang isang proseso ayon sa estado nito: ang mga nilalaman ng memorya sa puwang ng address nito, ang mga nilalaman ng mga rehistro ng processor, kabilang ang pointer ng pagtuturo at stack pointer, at impormasyon ng IO, tulad ng mga bukas na file na binabasa o isinusulat.
● Process API binubuo ng mga tawag na maaaring gawin ng mga programa sa mga proseso. Kadalasan ang mga ito ay gumawa, magtanggal, o iba pang mga tawag.
● Ang proseso ay nasa isa sa maraming estado, kabilang ang pagtakbo, handa, hinarangan. Maaaring baguhin ng iba't ibang kaganapan gaya ng pag-iiskedyul, pagbubukod sa pag-iskedyul, o paghihintay ang estado ng isang proseso mula sa isa't isa.
● Listahan ng proseso naglalaman ng impormasyon tungkol sa lahat ng mga proseso sa system. Ang bawat entry dito ay tinatawag na process control block, na sa katotohanan ay isang istraktura na naglalaman ng lahat ng kinakailangang impormasyon tungkol sa isang partikular na proseso.
Pinagmulan: www.habr.com