Yntroduksje ta bestjoeringssystemen
Hoi Habr! Ik soe graach bringe jo oandacht in rige fan artikels-oersettingen fan ien nijsgjirrige literatuer yn myn miening - OSTEP. Dit materiaal besprekt frij djip it wurk fan unix-like bestjoeringssystemen, nammentlik wurk mei prosessen, ferskate planners, ûnthâld en oare ferlykbere komponinten dy't in moderne OS foarmje. Jo kinne hjir it orizjineel fan alle materialen sjen . Tink derom dat de oersetting ûnprofesjoneel makke is (hiel frij), mar ik hoopje dat ik de algemiene betsjutting behâlden haw.
Labwurk oer dit ûnderwerp is hjir te finen:
- oarspronklik:
- oarspronklik:
- myn persoanlike oanpassing:
Oare dielen:
Jo kinne ek kontrolearje út myn kanaal op =)
Litte wy nei de meast fûnemintele abstraksje sjen dy't it OS oan brûkers leveret: it proses. De definysje fan it proses is frij simpel - it is rinnende programma. It programma sels is in libbenleas ding dat op 'e skiif leit - it is in set ynstruksjes en mooglik wat statyske gegevens dy't wachtsje om te lansearjen. It is it OS dat dizze bytes nimt en se rint, it programma transformeart yn wat nuttichs.
Meastentiids wolle brûkers mear as ien programma tagelyk útfiere, bygelyks kinne jo in blêder, spultsje, mediaspieler, tekstbewurker en sa op jo laptop útfiere. Eins kin in typysk systeem tsien of hûnderten prosessen tagelyk útfiere. Dit feit makket it systeem makliker te brûken, jo moatte noait soargen meitsje oer oft de CPU fergees is, jo rinne gewoan programma's.
Dit makket it probleem op: hoe kinne jo de yllúzje fan in protte CPU's leverje? Hoe kin it OS de yllúzje meitsje fan in hast ûneinich oantal CPU's, sels as jo mar ien fysike CPU hawwe?
It OS makket dizze yllúzje troch CPU-virtualisaasje. Troch ien proses te begjinnen, dan te stopjen, in oar proses te begjinnen, ensafuorthinne, kin it OS de yllúzje behâlde dat d'r in protte firtuele CPU's binne, as d'r yn feite ien of mear fysike processors sille wêze. Dizze technyk wurdt neamd ferdieling fan CPU-boarnen troch tiid. Dizze technyk lit brûkers safolle tagelyk prosessen útfiere as se wolle. De kosten fan dizze oplossing binne prestaasjes - om't as de CPU wurdt dield troch ferskate prosessen, sil elk proses stadiger wurde ferwurke.
Om CPU-virtualisaasje út te fieren, en foaral om it goed te dwaan, hat it OS sawol leech- as heechnivo-stipe nedich. Low nivo stipe wurdt neamd meganismen binne metoaden of protokollen op leech nivo dy't it fereaske diel fan 'e funksjonaliteit ymplementearje. In foarbyld fan sa'n funksjonaliteit is kontekstwikseling, dy't it OS de mooglikheid jout om ien programma te stopjen en in oar programma op 'e prosessor út te fieren. Dizze tiiddieling wurdt ymplementearre yn alle moderne bestjoeringssystemen.
Boppe op dizze meganismen is wat logika ynboud yn it OS, yn 'e foarm fan "belied". belied is in bepaald beslútfoarmjende algoritme foar it bestjoeringssysteem. Sokke belied beslute bygelyks hokker programma earst (út in list mei kommando's) lansearre wurde moat. Sa, bygelyks, dit probleem wurdt oplost troch in belied neamd planner (skemabelied) en as jo in oplossing kieze, sil it liede troch sokke gegevens as: opstartskiednis (hokker programma waard yn 'e lêste minuten it langste lansearre), hokker lading dit proses draacht (hokker soarten programma's waarden lansearre), prestaasjesmetriken (oft it systeem is optimalisearre foar ynteraktive ynteraksje as foar trochfier) ensafuorthinne.
Abstraksje: proses
De abstraksje fan in rinnend programma útfierd troch it bestjoeringssysteem is wat wy neame proses. Lykas earder neamd, is in proses gewoan in rinnend programma, op elke instantane tiid. In programma wêrmei't wy gearfettingsynformaasje kinne krije fan ferskate systeemboarnen dy't dit programma tagong hat of beynfloedet tidens it útfieren.
Om de komponinten fan it proses te begripen, moatte jo de steaten fan it systeem begripe: wat it programma kin lêze of feroarje yn 'e operaasje. Op elk momint moatte jo begripe hokker eleminten fan it systeem wichtich binne foar de útfiering fan it programma.
Ien fan 'e foar de hân lizzende eleminten fan it systeem stelt dat it proses omfettet is память. Ynstruksjes lizze yn it ûnthâld. De gegevens dy't it programma lêst of skriuwt, sitte ek yn it ûnthâld. Sa is it ûnthâld dat in proses oanpakke kin (neamd adresromte) diel fan it proses.
Ek diel fan it systeem steat binne registers. In protte ynstruksjes binne rjochte op it feroarjen fan de wearde fan registers of it lêzen fan har wearde, en sa wurde registers ek in wichtich part fan 'e wurking fan it proses.
Dêrby moat opmurken wurde dat de masine steat wurdt ek foarme út guon spesjale registers. Bygelyks, IP - ynstruksje pointer - in oanwizer nei de ynstruksje dy't it programma op it stuit útfiert. Dêr is ek stack oanwizer en dêrmei besibbe frame pointer, dy't brûkt wurde om te behearjen: funksjeparameters, lokale fariabelen en weromadressen.
Uteinlik hawwe programma's faak tagong ta ROM (allinich lêzen ûnthâld). Dizze "I/O" (ynfier / útfier) ynformaasje moat in list befetsje mei bestannen dy't op it stuit iepen binne troch it proses.
Process API
Om ús begryp te ferbetterjen fan hoe't it proses wurket, litte wy foarbylden studearje fan systeemoproppen dy't moatte wurde opnommen yn elke ynterface foar bestjoeringssysteem. Dizze API's binne beskikber yn ien of oare foarm op elk OS.
● Meitsje (creation): It OS moat in metoade befetsje wêrmei jo nije prosessen kinne oanmeitsje. As jo in kommando ynfiere yn 'e terminal of in applikaasje starte troch te dûbelklikken op in ikoan, wurdt in oprop stjoerd nei it OS om in nij proses te meitsjen en dan it opjûne programma te starten.
● Ferwiderje: Om't der in ynterface is foar it meitsjen fan in proses, moat it OS ek de mooglikheid jaan om it fuortheljen fan in proses te twingen. De measte programma's sille fansels op har eigen begjinne en beëinigje as se rinne. Oars soe de brûker har graach kinne deadzje en dus soe in ynterface om it proses te stopjen nuttich wêze.
● Wachtsje (wachtsjen): Soms is it nuttich om te wachtsjen op in proses om te foltôgjen, sadat guon ynterfaces wurde levere dy't de mooglikheid jouwe om te wachtsjen.
● Misc kontrôle (ferskate kontrôle): Neist deadzjen en wachtsje op it proses, der binne ek oare ferskate kontrôle metoaden. De measte bestjoeringssystemen jouwe bygelyks de mooglikheid om in proses te befriezen (de útfiering dêrfan foar in bepaalde perioade stopje) en it dan opnij te meitsjen (trochgean mei útfiering)
● Status (steat): D'r binne ferskate ynterfaces foar it krijen fan wat ynformaasje oer de status fan in proses, lykas hoe lang it hat west of yn hokker steat it no is.
Proses Creation: Details
Ien fan 'e nijsgjirrige dingen is hoe krekt programma's wurde omfoarme ta prosessen. Benammen hoe't it OS it programma oppakt en rint. Hoe krekt it proses wurdt makke.
Alderearst moat it OS de programmakoade en statyske gegevens yn it ûnthâld lade (yn 'e prosesadresromte). Programma's wurde normaal pleatst op in skiif of solid-state drive yn guon útfierbere opmaak. Sa fereasket it proses fan it laden fan programma en statyske gegevens yn it ûnthâld dat it OS dizze bytes fan skiif lêze kin en se earne yn it ûnthâld pleatse.
Yn 'e iere bestjoeringssystemen waard it opstartproses grif dien, wat betsjut dat de heule koade yn it ûnthâld laden waard foardat it programma waard lansearre. Moderne bestjoeringssystemen dogge dit loai, dat is, it laden fan stikken koade of gegevens allinich as it programma se fereasket tidens har útfiering.
Sadree't de koade en statyske gegevens binne laden yn OS ûnthâld, der binne in pear mear dingen dy't moatte wurde dien foardat it proses kin rinne. Guon bedrach fan ûnthâld moat wurde tawiisd foar de stack. Programma's brûke de stapel foar lokale fariabelen, funksjeparameters en weromadressen. It OS allocates dit ûnthâld en jout it oan it proses. De stack kin ek wurde tawiisd mei guon arguminten, spesifyk follet it de parameters fan de wichtichste () funksje, bygelyks mei in array fan argc en argv.
It bestjoeringssysteem kin ek wat ûnthâld tawize oan 'e programma-heap. De heap wurdt brûkt troch programma's om eksplisyt dynamysk tawiisde gegevens oan te freegjen. Programma's freegje dizze romte troch de funksje op te roppen malloc () en wisket it eksplisyt troch de funksje op te roppen frij(). De heap is nedich foar gegevensstruktueren lykas keppele blêden, hashtabellen, beammen en oaren. Earst wurdt in lyts bedrach fan ûnthâld tawiisd oan 'e heap, mar oer de tiid, as it programma rint, kin de heap mear ûnthâld freegje fia de bibleteek API-oprop malloc (). It bestjoeringssysteem is belutsen by it proses fan it tawizen fan mear ûnthâld om dizze oproppen te foldwaan.
It bestjoeringssysteem sil ek inisjalisaasjetaken útfiere, benammen dy relatearre oan I/O. Bygelyks, op UNIX-systemen hat elk proses standert 3 iepen bestânbeskriuwers, foar standert ynfier, útfier en flater. Dizze hângrepen kinne programma's ynput fan 'e terminal lêze en ek ynformaasje werjaan op it skerm.
Sa, troch it laden fan koade en statyske gegevens yn it ûnthâld, it meitsjen en inisjalisearjen fan de stapel, en it dwaan fan oar wurk yn ferbân mei it útfieren fan I / O-taken, taret it OS it poadium op foar it útfieren fan it proses. Uteinlik is der noch ien lêste taak: it útfieren fan it programma fia syn yngongspunt, neamd de haadfunksje (). Troch it útfieren fan de haadfunksje () draacht it OS CPU-kontrôle oer nei it nij oanmakke proses, dus begjint it programma út te fieren.
Proses steat
No't wy wat begrip hawwe fan wat in proses is en hoe't it is makke, litte wy de prosesstaten listje wêryn it kin wêze. Yn syn ienfâldichste foarm kin in proses yn ien fan dizze steaten wêze:
● Te rinnen. By it útfieren rint it proses op 'e prosessor. Dit betsjut dat ynstruksjes wurde útfierd.
● klear. Yn 'e kleare steat is it proses klear om te rinnen, mar om ien of oare reden docht it OS it net op' e opjûne tiid.
● Blokkearre. Yn 'e blokkearre steat fiert in proses guon operaasjes út dy't foarkomme dat it ree is om út te fieren oant ien of oare evenemint bart. Ien mienskiplik foarbyld is as in proses in IO-operaasje inisjearret, wurdt it blokkearre sadat in oar proses de prosessor kin brûke.
Jo kinne dizze steaten yn 'e foarm fan in grafyk foarstelle. As wy kinne sjen yn 'e foto, kin de proses tastân feroarje tusken RUNNING en READY nei it ynsjoch fan it OS. As de steat fan in proses feroaret fan READY nei RUNNING, betsjut it dat it proses is pland. Yn 'e tsjinoerstelde rjochting - fuortsmiten fan' e yndieling. Op it stuit dat in proses BLOCKED wurdt, begjinne ik bygelyks in IO-operaasje, it OS sil it yn dizze steat hâlde oant der in evenemint bart, bygelyks it foltôgjen fan IO. op dit stuit de oergong nei de READY steat en mooglik fuortendaliks nei de RUNNING steat as it OS beslút.
Litte wy nei in foarbyld sjen fan hoe't twa prosessen troch dizze steaten bewegen. Om te begjinnen, lit ús yntinke dat beide prosessen rinne, en elk brûkt allinnich de CPU. Yn dit gefal sille har steaten der sa útsjen.
Yn it folgjende foarbyld freget it earste proses, nei in skoftke rinnen, IO en komt de BLOCKED-status yn, wêrtroch in oar proses kin rinne (FIG 1.4). It OS sjocht dat proses 0 de CPU net brûkt en begjint proses 1. Wylst proses 1 rint, wurdt IO foltôge en feroaret de status fan proses 0 nei READY. Uteinlik is proses 1 foltôge, en nei foltôging begjint proses 0, útfiert en einiget syn wurk.
Data struktuer
It OS sels is in programma, en krekt as elk oar programma hat it wat wichtige gegevensstruktueren dy't ferskate relevante stikken ynformaasje byhâlde. Om de steat fan elk proses te folgjen, sil it OS guon stypje proses list foar alle prosessen yn 'e READY-steat en wat ekstra ynformaasje om prosessen te folgjen dy't op it stuit rinne. Ek moat it OS blokkearre prosessen kontrolearje. Nei't IO foltôge is, moat it OS it fereaske proses wekker meitsje en it yn in steat sette klear om te rinnen.
Bygelyks, it OS moat de steat fan 'e prosessorregisters behâlde. Op it stuit dat it proses stopt, wurdt de steat fan 'e registers opslein yn' e adresromte fan it proses, en op it momint dat syn wurking trochgiet, wurde de wearden fan 'e registers werombrocht en sadwaande de útfiering fan dit proses trochgean.
Neist klearebare, blokkearre, rinnende steaten binne d'r guon oare steaten. Soms, op it momint fan skepping, kin in proses yn 'e INIT-status wêze. Uteinlik kin in proses yn 'e FINALE steat pleatst wurde as it al foltôge is, mar syn ynformaasje is noch net wiske. Op UNIX-systemen wurdt dizze steat neamd zombie proses. Dizze steat is nuttich foar gefallen dêr't in âlder proses wol witte it werom koade fan in bern, bygelyks, meastal 0 sinjalearret in súkses en 1 in flater, mar programmeurs kinne útjaan ekstra útfier koades foar in sinjalearjen ferskillende problemen. As it âlderproses beëiniget, makket it in lêste systeemoprop, lykas wachtsje (), om te wachtsjen op it bernproses om te beëinigjen en sinjaal oan it OS dat it alle gegevens kin wiskje dy't ferbûn binne mei it beëinige proses.
Wichtige punten fan 'e lêzing:
● proses - de wichtichste abstraksje fan in rinnend programma yn it OS. Op elts momint kin in proses beskreaun wurde troch syn steat: de ynhâld fan ûnthâld yn syn adresromte, de ynhâld fan prosessorregisters, ynklusyf ynstruksjeoanwizer en stackpointer, en IO-ynformaasje, lykas iepene triemmen dy't lêzen of skreaun wurde.
● Process API bestiet út oproppen dy't programma's kinne meitsje oan prosessen. Typysk binne dit oanmeitsjen, wiskjen of oare petearen.
● It proses is yn ien fan in protte steaten, ynklusyf rinnende, klear, blokkearre. Ferskate eveneminten lykas skema, útsûnderingen fan skema, of wachtingen kinne de steat fan in proses feroarje fan de iene nei de oare.
● Process list befettet ynformaasje oer alle prosessen yn it systeem. Elke yngong dêryn wurdt in proseskontrôleblok neamd, dy't yn werklikheid in struktuer is dy't alle nedige ynformaasje befettet oer in spesifyk proses.
Boarne: www.habr.com