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 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: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- orihinal: github.com/remzi-arpacidusseau/ostep-code
- ang aking personal na adaptasyon: github.com/bykvaadm/OS/tree/master/ostep

Maaari mo ring tingnan ang aking channel sa telegram =)

Pagpapatakbo ng programa

Ano ang mangyayari kapag tumatakbo ang isang programa? Ang isang tumatakbong programa ay gumagawa ng isang simpleng bagay - ito ay nagpapatupad ng mga tagubilin. Bawat segundo, milyun-milyon at kahit na posibleng bilyun-bilyong mga tagubilin ang kinukuha ng processor mula sa RAM, at ito naman ang nagde-decode sa kanila (halimbawa, kinikilala kung anong uri ang mga tagubiling ito) at isinasagawa ang mga ito. Maaaring ito ay pagdaragdag ng dalawang numero, pag-access sa memorya, pagsubok ng isang kundisyon, paglukso sa isang function, at iba pa. Pagkatapos ng isang pagtuturo, ang processor ay nagpapatuloy sa pagpapatupad ng isa pa. At kaya ang pagtuturo pagkatapos ng pagtuturo, ang mga ito ay isinasagawa hanggang sa matapos ang programa.
Ang halimbawang ito ay natural na isinasaalang-alang sa isang pinasimple na paraan - sa katunayan, upang pabilisin ang processor, pinapayagan ka ng modernong hardware na magsagawa ng mga tagubilin nang wala sa pagkakasunud-sunod, kalkulahin ang mga posibleng resulta, isagawa ang mga tagubilin nang sabay-sabay, at mga katulad na trick.

Modelo ng pagkalkula ng Von Neumann

Ang pinasimpleng anyo ng operasyon na aming inilarawan ay katulad ng Von Neumann na modelo ng computing. Si Von Neumann ay isa sa mga pioneer ng mga computer system, isa rin siya sa mga may-akda ng teorya ng laro. Habang tumatakbo ang programa, maraming iba pang mga kaganapan ang nangyayari, maraming iba pang mga proseso at third-party na lohika ang tumatakbo, ang pangunahing layunin nito ay upang gawing simple ang paglulunsad, pagpapatakbo at pagpapanatili ng system.
Mayroong isang set ng software na responsable para sa paggawa ng mga program na madaling patakbuhin (o kahit na nagpapahintulot sa maramihang mga programa na tumakbo nang sabay-sabay), na nagpapahintulot sa mga programa na magbahagi ng parehong memorya, pati na rin ang pakikipag-usap sa iba't ibang mga device. Ang ganitong set ng software (software) ay mahalagang tinatawag na operating system at kasama sa mga gawain nito ang pagsubaybay na gumagana nang tama at mahusay ang system, pati na rin ang pagtiyak ng kadalian ng pamamahala ng system na ito.

Operating system

Ang operating system, na dinaglat bilang OS, ay isang hanay ng mga magkakaugnay na programa na idinisenyo upang pamahalaan ang mga mapagkukunan ng computer at ayusin ang pakikipag-ugnayan ng user sa computer..
Nakakamit ng OS ang pagiging epektibo nito pangunahin sa pamamagitan ng pinakamahalagang pamamaraan - teknolohiya virtualization. Nakikipag-ugnayan ang OS sa isang pisikal na mapagkukunan (processor, memory, disk, atbp.) at binabago ito sa isang mas pangkalahatan, mas may kakayahan, at mas madaling gamitin na anyo ng sarili nito. Samakatuwid, para sa pangkalahatang pag-unawa, maaari mong halos ihambing ang isang operating system sa isang virtual machine.
Upang payagan ang mga user na magbigay ng mga utos sa operating system at sa gayon ay magamit ang mga kakayahan ng virtual machine (tulad ng pagpapatakbo ng isang programa, paglalaan ng memorya, pag-access sa isang file, at iba pa), ang operating system ay nagbibigay ng isang interface na tinatawag API (application programming interface) at kung saan maaaring tumawag. Ang isang karaniwang operating system ay nagbibigay-daan sa iyo na gumawa ng daan-daang mga tawag sa system.
Sa wakas, dahil pinapayagan ng virtualization na tumakbo ang maramihang mga program (kaya nagbabahagi ng CPU), at sabay-sabay na na-access ang kanilang mga tagubilin at data (kaya nagbabahagi ng memorya), at nag-access sa mga disk (kaya nagbabahagi ng mga I/O device) ), ang operating system ay tinatawag ding mapagkukunan. manager. Ang bawat processor, disk at memorya ay isang mapagkukunan ng system at sa gayon ang isa sa mga tungkulin ng operating system ay nagiging gawain ng pamamahala ng mga mapagkukunang ito, ginagawa ito nang mahusay, patas o, sa kabaligtaran, depende sa gawain kung saan ang operating system ay dinisenyo.

Virtualization ng CPU

Isaalang-alang ang sumusunod na programa:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

Hindi ito nagsasagawa ng anumang mga espesyal na aksyon; sa katunayan, ang lahat ng ginagawa nito ay tumawag ng isang function magsulid(), na ang gawain ay paikot na suriin ang oras at bumalik pagkatapos lumipas ang isang segundo. Kaya, walang katapusang inuulit nito ang string na ipinasa ng user bilang argumento.
Patakbuhin natin ang program na ito at ipasa ang simbolo na "A" bilang argumento. Ang resulta ay hindi partikular na kawili-wili - ang system ay nagpapatupad lamang ng isang programa na pana-panahong nagpapakita ng simbolo na "A" sa screen.
Ngayon, subukan natin ang opsyon kapag maraming mga pagkakataon ng parehong programa ang inilunsad, ngunit nagpapakita ng iba't ibang mga titik, upang gawin itong mas malinaw. Sa kasong ito, ang resulta ay bahagyang naiiba. Sa kabila ng katotohanan na mayroon kaming isang processor, ang programa ay tumatakbo nang sabay-sabay. Paano ito nangyayari? Ngunit lumalabas na ang operating system, hindi nang walang tulong ng mga kakayahan ng hardware, ay lumilikha ng isang ilusyon. Ang ilusyon na mayroong maraming virtual processor sa system, na ginagawang isang pisikal na processor ang isang theoretically infinite number at sa gayon ay nagpapahintulot sa mga program na tila tumakbo nang sabay-sabay. Ang ilusyong ito ay tinatawag Virtualization ng CPU.
Ang larawang ito ay nagtataas ng maraming mga katanungan, halimbawa, kung maraming mga programa ang gustong tumakbo nang sabay, kung gayon alin ang ilulunsad? Ang "mga patakaran" ng OS ang may pananagutan sa isyung ito. Ginagamit ang mga patakaran sa maraming lugar sa OS at sinasagot ang mga tanong na tulad nito, pati na rin ang pagiging pangunahing mekanismo na ipinapatupad ng OS. Kaya ang papel ng OS bilang isang resource manager.

Virtualization ng memorya

Ngayon tingnan natin ang memorya. Ang pisikal na modelo ng memorya sa mga modernong sistema ay kinakatawan bilang isang byte array. Upang basahin mula sa memorya kailangan mong tukuyin cell addresspara ma-access ito. Upang magsulat o mag-update ng data, dapat mo ring tukuyin ang data at ang address ng cell kung saan ito isusulat.
Ang mga pag-access sa memorya ay nangyayari palagi sa panahon ng pagpapatupad ng programa. Iniimbak ng isang programa ang buong istraktura ng data nito sa memorya at ina-access ito sa pamamagitan ng pagpapatupad ng iba't ibang mga tagubilin. Samantala, ang mga tagubilin ay nakaimbak din sa memorya, kaya naa-access din ito para sa bawat kahilingan para sa susunod na pagtuturo.

Tinatawagan si malloc()

Isaalang-alang ang sumusunod na programa, na naglalaan ng isang lugar ng memorya gamit ang tawag malloc () (https://youtu.be/jnlKRnoT1m0):

Ang programa ay gumagawa ng ilang bagay. Una, naglalaan ito ng ilang memorya (linya 7), pagkatapos ay i-print ang address ng inilaan na cell (linya 9), nagsusulat ng zero sa unang puwang ng inilalaan na memorya. Susunod, ang programa ay pumapasok sa isang loop kung saan dinadagdagan nito ang halaga na nakaimbak sa memorya sa address sa variable na "p". Ipinapakita rin nito ang mismong process ID. Ang process ID ay natatangi para sa bawat tumatakbong proseso. Sa paglunsad ng ilang kopya, makakatagpo tayo ng isang kawili-wiling resulta: Sa unang kaso, kung wala tayong gagawin at maglulunsad lamang ng ilang kopya, ang mga address ay magkakaiba. Ngunit hindi ito nahuhulog sa ilalim ng aming teorya! Totoo, dahil ang mga modernong distribusyon ay may memory randomization na pinagana bilang default. Kung hindi mo ito pinagana, makukuha namin ang inaasahang resulta - ang mga address ng memorya ng dalawang sabay na tumatakbong mga programa ay magkakasabay.

Ang resulta ay ang dalawang independiyenteng programa ay gumagana sa kanilang sariling mga pribadong puwang ng address, na kung saan ay nakamapa ng operating system sa pisikal na memorya.. Samakatuwid, ang paggamit ng mga address ng memorya sa loob ng isang programa ay hindi makakaapekto sa iba sa anumang paraan, at ang bawat programa ay tila may sariling piraso ng pisikal na memorya, na ganap na magagamit nito. Ang katotohanan, gayunpaman, ay ang pisikal na memorya ay isang nakabahaging mapagkukunan na pinamamahalaan ng operating system.

Hindi pagbabago

Ang isa pang mahalagang paksa sa loob ng mga operating system ay hindi pagbabago. Ginagamit ang terminong ito kapag pinag-uusapan ang mga problema sa system na maaaring mangyari kapag nagtatrabaho sa maraming bagay nang sabay-sabay sa loob ng isang programa. Ang mga problema sa pagkakapare-pareho ay nangyayari sa loob mismo ng operating system. Sa mga nakaraang halimbawa na may memorya at processor virtualization, napagtanto namin na ang OS ay namamahala ng maraming bagay sa parehong oras - inilulunsad ang unang proseso, pagkatapos ay ang pangalawa, at iba pa. Sa lumalabas, ang pag-uugali na ito ay maaaring humantong sa ilang mga problema. Halimbawa, ang mga modernong multi-threaded na programa ay nakakaranas ng mga ganitong kahirapan.

Isaalang-alang ang sumusunod na programa:

Ang programa sa pangunahing function ay lumilikha ng dalawang thread gamit ang tawag Pthread_create(). Sa halimbawang ito, ang isang thread ay maaaring isipin bilang isang function na tumatakbo sa parehong memory space sa tabi ng iba pang mga function, na may malinaw na higit sa isang function na tumatakbo sa parehong oras. Sa halimbawang ito, ang bawat thread ay nagsisimula at nagsasagawa ng isang function worker() na kung saan ay dinadagdagan lamang ang variable,.

Patakbuhin natin ang program na ito na may argumento na 1000. Gaya ng nahulaan mo, ang resulta ay dapat na 2000, dahil dinagdagan ng bawat thread ang variable nang 1000 beses. Gayunpaman, ang lahat ay hindi gaanong simple. Subukan nating patakbuhin ang programa na may isang order ng magnitude na higit pang mga pag-uulit.

Sa pamamagitan ng pag-input ng isang numero, halimbawa, 100000, inaasahan naming makita ang bilang na 200000 sa output. Gayunpaman, sa pamamagitan ng pagpapatakbo ng numerong 100000 nang ilang beses, hindi lamang namin makikita ang tamang sagot, ngunit makakatanggap din kami ng iba't ibang mga maling sagot. Ang sagot ay nakasalalay sa katotohanan na ang pagtaas ng isang numero ay nangangailangan ng tatlong operasyon - pagkuha ng numero mula sa memorya, pagdaragdag nito, at pagkatapos ay isulat ang numero pabalik. Dahil ang lahat ng mga tagubiling ito ay hindi isinasagawa nang atomically (lahat ng sabay-sabay), ang mga kakaibang bagay na tulad nito ay maaaring mangyari. Ang problemang ito ay tinatawag sa programming kondisyon ng lahi - kondisyon ng lahi. Kapag ang hindi kilalang pwersa sa hindi kilalang sandali ay maaaring makaapekto sa pagpapatupad ng alinman sa iyong mga operasyon.

Pinagmulan: www.habr.com