Conceptul de proces. Subsistemul sistemului de operare pentru managementul proceselor. Stări de proces. Context și proces de gestionare. Subsistemul de management al proceselor Principii de management al memoriei

Sistemul de management al sarcinilor asigură trecerea acestora prin computer. În funcție de starea procesului, trebuie să aloce una sau alta resursă. De exemplu, un nou proces trebuie să fie plasat în memorie prin alocarea unui spațiu de adrese; includeți în lista sarcinilor care concurează pentru timpul procesorului.

Unul dintre principalele subsisteme ale unui sistem de operare multiprogram care afectează direct funcționarea unui computer este subsistemul de gestionare a proceselor și firelor. Se ocupă de crearea și distrugerea lor și, de asemenea, distribuie timpul procesorului între procesele și firele de execuție existente simultan în sistem.

Când mai multe sarcini rulează simultan pe un sistem, deși firele de execuție sunt create și executate asincron, este posibil ca acestea să fie nevoite să interacționeze, de exemplu, atunci când fac schimb de date. Prin urmare, sincronizarea firelor este una dintre cele funcții importante subsisteme de management al proceselor și firelor.

Comunicarea între procese se realizează folosind variabile partajate și operații de bază speciale numite primitivi.

Subsistemul de gestionare a proceselor și a firelor de execuție are capacitatea de a efectua următoarele operațiuni asupra proceselor:

– crearea (producerea icrelor)/distrugerea unui proces;

– întrerupeți/reluați procesul;

– blocarea/trezirea procesului;

– începe procesul;

– schimbarea priorității procesului;

Subsistemul de gestionare a proceselor și firelor este responsabil pentru furnizarea proceselor cu resursele necesare. Sistemul de operare menține în memorie structuri speciale de informații, în care înregistrează ce resurse sunt alocate fiecărui proces. O resursă poate fi atribuită unui proces pentru utilizare exclusivă sau pentru utilizare partajată cu alte procese. Unele dintre resurse sunt alocate unui proces atunci când este creat, iar unele sunt alocate dinamic pe baza solicitărilor din timpul de execuție. Resursele pot fi alocate unui proces pentru întreaga sa viață sau doar pentru o anumită perioadă. Atunci când efectuează aceste funcții, subsistemul de management al proceselor interacționează cu alte subsisteme OS responsabile de gestionarea resurselor, cum ar fi subsistemul de gestionare a memoriei, subsistemul de intrare/ieșire și sistemul de fișiere.

1. Crearea și ștergerea proceselor și firelor

A crea un proces înseamnă în primul rând a crea mânerul procesului, care reprezintă una sau mai multe structuri de informații care conțin toate informațiile despre procesul necesare sistemului de operare pentru a-l gestiona. Această problemă a fost discutată în detaliu mai devreme, acum amintim doar că astfel de informații pot include, de exemplu, un identificator de proces, date despre locația modulului executabil în memorie, gradul de privilegiu al procesului (prioritate și drepturi de acces), etc.

Crearea unui proces presupune încărcarea codurilor și datelor programului executabil al procesului de pe disc în RAM. În acest caz, subsistemul de management al proceselor interacționează cu subsistemul de gestionare a memoriei și sistemul de fișiere. Într-un sistem cu mai multe fire, atunci când este creat un proces, sistemul de operare creează cel puțin un fir de execuție pentru fiecare proces. Când se creează un fir, la fel ca atunci când se creează un proces, sistemul de operare generează o structură specială de informații - un descriptor de fir, care conține identificatorul firului, date despre drepturile de acces și prioritate, starea firului etc. Odată creat, un fir (sau proces) este într-o stare gata de rulare (sau într-o stare inactivă dacă despre care vorbim despre OS cu scop special).

Sarcinile sunt create și șterse pe baza solicitărilor adecvate din partea utilizatorilor sau a altor sarcini. O sarcină poate genera o nouă sarcină - în multe sisteme, un fir poate contacta sistemul de operare cu o solicitare de a crea un așa-numit. fluxuri de copii. Sarcina generatoare este numită „strămoș” sau „părinte”, iar sarcina copil este numită „descendent” sau „sarcină copil”. Un „strămoș” își poate suspenda sau șterge sarcina copil, în timp ce un „copil” nu poate gestiona „strămoșul”.

Diferite sisteme de operare structurează relația dintre firele de execuție copii și părinții lor în mod diferit. În unele sisteme de operare, execuția lor este sincronizată (după ce firul părinte se termină, toți copiii săi sunt scoși din execuție), în altele, copiii sunt executați asincron față de firul părinte.

După finalizarea procesului, sistemul de operare „curăță urmele” prezenței sale în sistem - închide toate fișierele cu care a funcționat procesul, eliberează zonele de RAM alocate pentru coduri, date și structurile de informații de sistem ale procesului. Cozile OS și listele de resurse care conțineau referințe la procesul care se încheie sunt corectate.

2. Procese de programare și expediere și fire

Strategia de planificare determină ce procese sunt selectate pentru a fi executate pentru atingerea scopului. Strategiile pot fi diferite, de exemplu:

– dacă este posibil, finalizați calculele în aceeași ordine în care au fost începute;

– acordați preferință proceselor mai scurte;

– furnizați tuturor utilizatorilor (sarcini ale utilizatorului) aceleași servicii, inclusiv același timp de așteptare.

Pe parcursul vieții unui proces, execuția firelor sale poate fi întreruptă și continuată de mai multe ori.

Ca urmare, trecerea de la execuția unui fir la altul se realizează planificareȘi expediere.

Planificare firele de execuție sunt implementate pe baza informațiilor stocate în proces și descriptori de fire. La programare, se pot lua în considerare prioritatea firelor de execuție, timpul de așteptare în coadă, timpul de execuție acumulat, intensitatea accesului I/O și alți factori. Sistemul de operare programează firele de execuție, indiferent dacă aparțin aceluiași proces sau diferit. Planificarea este înțeleasă ca sarcina de a selecta un astfel de set de procese astfel încât acestea să intre în conflict cât mai puțin posibil în timpul execuției și să utilizeze sistemul de calcul cât mai eficient posibil.

În diverse surse de informare există diverse interpretări conceptele de „planificare” şi „dispecerare”. Astfel, unii autori împart planificarea în pe termen lung (global) și pe termen scurt (dinamic, adică cea mai eficientă distribuție actuală), iar cea din urmă se numește dispecerizare. Potrivit altor surse, dispecerizarea este înțeleasă ca implementarea unei decizii luate în faza de planificare. Vom rămâne cu această opțiune.

Planificare include rezolvarea a două probleme:

determinarea momentului de timp pentru schimbarea firului activ;

selectarea unui fir de executat dintr-o coadă de fire gata.

Există mulți algoritmi de planificare care rezolvă aceste probleme în moduri diferite. Caracteristicile de planificare sunt cele care determină specificul sistemului de operare. Să ne uităm la ele puțin mai târziu.

În majoritatea sistemelor de operare, programarea este efectuată dinamic, adică deciziile se iau în timpul lucrului pe baza unei analize a situației actuale. Firele și procesele apar la momente aleatorii și se termină imprevizibil.

Static tipul de programare poate fi utilizat în sisteme specializate în care întregul set de sarcini care se execută simultan este definit în prealabil (sisteme în timp real). Planificatorul creează un program bazat pe cunoașterea caracteristicilor unui set de sarcini. Acest program este apoi folosit de sistemul de operare pentru programare.

Expediere constă în implementarea soluţiei găsite ca urmare a planificării, i.e. la trecerea unui proces la altul. Expedierea se reduce la următoarele:

salvarea contextului firului curent care trebuie schimbat;

lansarea unui nou thread pentru execuție.

Contextul firului reflectă, în primul rând, starea hardware-ului computerului la momentul întreruperii (valoarea contorului programului, conținutul registrelor scop general, modul de funcționare al procesorului, steaguri, măști de întrerupere și alți parametri), în al doilea rând, parametrii mediului de operare (legături către fișiere deschise, date despre operațiuni I/O neterminate, coduri de eroare efectuate de un anumit fir de apeluri de sistem etc.).

În contextul unui fir de execuție, putem distinge o parte care este comună tuturor firelor de execuție ale unui anumit proces (legături către fișiere deschise) și o parte care se referă doar la un fir dat (conținutul registrelor, contorul programului, modul procesor). De exemplu, în mediul NetWare există trei tipuri de contexte - context global (context de proces), context de grup de fire și context individual de fire. Relația dintre datele acestor contexte este similară cu relația dintre variabilele globale și locale dintr-un program. Organizarea ierarhică a contextelor accelerează comutarea firelor: la trecerea de la un fir al unui grup la unul al altui grup în cadrul aceluiași proces, contextul global nu se schimbă, ci doar contextul grupului se schimbă. Comutarea globală a contextului are loc numai atunci când se trece de la firul unui proces la firul altui proces.

3. Algoritmi de planificare

Din punctul de vedere al soluționării primei probleme de programare (selectarea momentului de timp pentru a schimba firul activ), algoritmii de programare sunt împărțiți în două clase mari - algoritmi preventivi și non-preemptivi:

nerepresiv– firul activ se poate executa până când el însuși transferă controlul către sistem astfel încât să selecteze un alt thread gata din coadă;

deplasarea– sistemul de operare decide să schimbe sarcina care se execută și comută procesorul pe un alt thread.

Principala diferență dintre acești algoritmi de programare este gradul de centralizare a mecanismului de planificare a firelor. Să luăm în considerare principalele caracteristici, avantaje și dezavantaje ale fiecărei clase de algoritmi.

Algoritmi non-preemptivi. Programul de aplicație, după ce a primit controlul de la sistemul de operare, determină el însuși momentul finalizării următorului ciclu de execuție a acestuia și abia apoi transferă controlul către sistemul de operare folosind un apel de sistem. În consecință, controlul utilizatorului asupra aplicației este pierdut pentru o perioadă de timp arbitrară. Dezvoltatorii trebuie să țină cont de acest lucru și să creeze aplicații astfel încât să funcționeze „pe părți”, întrerupând periodic și transferând controlul către sistem, de exemplu. În timpul dezvoltării, sunt îndeplinite și funcțiile unui planificator.

Avantaje această abordare:

– se exclude întreruperea fluxului într-un moment incomod;

– se rezolvă problema utilizării simultane a datelor, deoarece în timpul fiecărui ciclu de execuție, sarcina le folosește exclusiv și este sigur că nimeni altcineva nu le poate schimba;

– viteză mai mare de comutare de la stream la stream.

Dezavantaje sunt dezvoltarea dificilă a programului și cerințele crescute pentru calificările programatorului, precum și posibilitatea ca un fir să preia procesorul în cazul în care accidental sau intenționat buclă.

Algoritmi preventivi– un tip de programare ciclică sau circulară, în care sistemul de operare însuși decide dacă întrerupe aplicația activă și comută procesorul de la o sarcină la alta în conformitate cu unul sau altul criteriu. Într-un sistem cu astfel de algoritmi, programatorul nu trebuie să-și facă griji cu privire la faptul că aplicația sa va fi executată simultan cu alte sarcini. Exemplele includ sistemele de operare UNIX, Windows NT/2000, OS/2. Algoritmii acestei clase sunt concentrați pe execuția de înaltă performanță a aplicațiilor.

Algoritmii preventivi se pot baza pe conceptul de cuantizare sau pe un mecanism prioritar.

Algoritmi bazați pe cuantizare. Fiecare fir de execuție are o porțiune continuă limitată de timp de procesor (valoarea sa nu trebuie să fie mai mică de 1 ms - de obicei câteva zeci de ms). Un fir este mutat dintr-o stare de rulare într-o stare de pregătire dacă cuantumul este epuizat. Quanta poate fi aceeași pentru toate fluxurile sau diferită.

Atunci când se alocă cuante unui fir, pot fi utilizate diferite principii: aceste cuante pot avea o valoare fixă ​​sau se pot modifica în diferite perioade ale vieții firului. De exemplu, pentru un anumit flux, primul cuantum poate fi destul de mare, iar fiecare cuantă ulterioară alocată acestuia poate avea o durată mai scurtă (reducere la limitele specificate). Acest lucru creează un avantaj pentru fire mai scurte, iar sarcinile de lungă durată se deplasează modul de fundal. Un alt principiu se bazează pe faptul că procesele care efectuează frecvent operațiuni I/O nu utilizează pe deplin intervalele de timp alocate acestora. Pentru a compensa această nedreptate, se poate forma o coadă separată din astfel de procese, care are privilegii față de alte fire. Când se selectează următorul fir de execuție, această coadă este mai întâi scanată și numai dacă este goală, se selectează un fir de execuție din coada generală gata de execuție.

Acești algoritmi nu folosesc nicio informație anterioară despre sarcini. Diferențierea serviciului în acest caz se bazează pe „istoria existenței” fluxului în sistem.

Din punctul de vedere al celei de-a doua probleme de programare (principiul alegerii executării firului următor), algoritmii pot fi, de asemenea, împărțiți condiționat în clase: algoritmi fără prioritate și algoritmi prioritari. Cu întreținerea fără prioritate, următoarea sarcină este selectată într-o anumită ordine prestabilită, fără a lua în considerare importanța lor relativă și timpul de întreținere. La implementarea disciplinelor prioritare, unor sarcini li se acordă prioritate pentru a intra în starea de execuție.

Acum să ne uităm la unele dintre cele mai comune discipline de planificare.

Serviciu primul venit, primul servit. Procesorul este alocat folosind principiul FIFO (First In First Out), adică în ordinea în care sunt primite cererile de serviciu. Această abordare vă permite să implementați strategia de „terminare a calculelor în ordinea în care apar, ori de câte ori este posibil”. Acele sarcini care au fost blocate în timpul execuției, după ce au intrat în starea gata, sunt puse în coadă în fața acelor sarcini care nu au fost încă executate. Astfel, sunt create două cozi: una a sarcinilor care nu au fost încă executate, iar cealaltă a sarcinilor care au trecut din starea în așteptare.

Această disciplină este implementată ca non-preemptivă atunci când sarcinile eliberează procesorul în mod voluntar.

Demnitate Acest algoritm este ușor de implementat. Dezavantaj– sub sarcină mare, sarcinile scurte sunt forțate să aștepte în sistem pentru o lungă perioadă de timp. Următoarea abordare elimină acest dezavantaj.

Cel mai scurt proces este servit primul. Conform acestui algoritm, firul de execuție cu timpul estimat minim necesar pentru a-și finaliza activitatea este atribuit lângă execuție. Aici, se acordă preferință firelor care mai au puțin timp înainte de a se finaliza. Acest lucru reduce numărul de sarcini în așteptare în sistem. Dezavantaj este necesitatea de a cunoaște din timp timpii estimați, ceea ce nu este întotdeauna posibil. Ca o aproximare aproximativă, în unele cazuri puteți folosi timpul petrecut ultima dată de fir primind controlul.

Algoritmul aparține categoriei de non-preemptive, fără prioritate.

Algoritmii numiți pot fi utilizați pentru modurile de operare în lot, atunci când utilizatorul nu se așteaptă ca sistemul să răspundă. Pentru calculul interactiv, este necesar în primul rând să se asigure un timp de răspuns acceptabil și un serviciu egal pentru sistemele cu mai multe terminale. Pentru sistemele cu utilizator unic, este de dorit ca acele programe cu care lucrează direct să aibă cel mai bun timp reacții decât locurile de muncă de fundal. În plus, unele aplicații, deși rulează fără interacțiune directă cu utilizatorul, trebuie să li se garanteze în continuare că vor primi partea lor din timpul procesorului (de exemplu, un program de e-mail). Pentru rezolvarea unor astfel de probleme se folosesc metode de servicii prioritare și conceptul de cuantizare.

Disciplina caruselului, sau circular – R.R.(Round Robin). Această disciplină se referă la algoritmi preventivi și se bazează pe cuantizare. Fiecare sarcină primește timpul procesorului în porțiuni - cuante. După sfârșitul cuantumului de timp, sarcina este scoasă din procesor și plasată la sfârșitul cozii de procese gata de execuție, iar următoarea sarcină este acceptată pentru service de către procesor. Pentru o funcționare optimă a sistemului, este necesar să se selecteze corect legea conform căreia se alocă secțiunile de timp sarcinilor.

Valoarea cuantică este aleasă ca un compromis între timpul de răspuns acceptabil al sistemului la solicitările utilizatorilor (astfel încât cele mai simple cereri ale acestora să nu cauzeze așteptări lungi) și costurile generale ale sarcinilor care se schimbă frecvent. Când este întrerupt, sistemul de operare trebuie să salveze o cantitate suficient de mare de informații despre procesul curent, să pună mânerul sarcinii anulate într-o coadă și să încarce contextul noii sarcini. Cu o porțiune de timp mică și comutări frecvente, ponderea relativă a acestor cheltuieli generale va deveni mare, iar acest lucru va degrada performanța sistemului în ansamblu. Dacă intervalul de timp este mare și coada de sarcini gata crește, răspunsul sistemului va deveni slab.

În unele sisteme de operare, este posibil să se specifice în mod explicit valoarea unei secțiuni de timp sau intervalul permis al valorilor sale. De exemplu, în OS/2, fișierul CONFIG.SYS utilizează operatorul TIMESLICE pentru a specifica valorile minime și maxime pentru o secțiune de timp: TIMESLICE=32.256 indică faptul că intervalul de timp poate fi modificat de la 32 la 256 milisecunde.

Această disciplină de serviciu este una dintre cele mai comune. În unele cazuri, când sistemul de operare nu acceptă în mod explicit disciplina de programare round-robin, o astfel de întreținere poate fi organizată artificial. De exemplu, unele RTOS folosesc programarea cu priorități absolute, iar când prioritățile sunt egale, se aplică principiul de așteptare. Adică, doar o sarcină cu o prioritate mai mare poate elimina o sarcină din execuție. Dacă este necesar, organizați serviciul în mod egal și egal, de ex. Pentru a se asigura că toate lucrările primesc aceleași intervale de timp, operatorul de sistem poate implementa el însuși o astfel de întreținere. Pentru a face acest lucru, este suficient să atribuiți aceleași priorități tuturor sarcinilor utilizatorului și să creați o sarcină cu prioritate ridicată, care nu ar trebui să facă altceva decât să fie programată pentru execuție pe un cronometru la intervale de timp specificate. Această sarcină va elimina doar aplicația curentă din execuție, se va muta la sfârșitul cozii, iar sarcina în sine va părăsi imediat procesorul și o va da următorului proces din coadă.

În cea mai simplă implementare, disciplina serviciului carusel presupune că toate locurile de muncă au aceeași prioritate. Dacă este necesar să se introducă un mecanism de deservire cu prioritate, de obicei sunt organizate mai multe cozi, în funcție de priorități, iar deservirea unei cozi cu prioritate inferioară se efectuează numai atunci când coada cu prioritate mai mare este goală. Acest algoritm este utilizat pentru programarea în sistemele OS/2 și Windows NT.

Planificarea in functie de prioritati.

Un concept important care stă la baza multor algoritmi preventivi este serviciul preventiv. Astfel de algoritmi folosesc informațiile găsite în descriptorul de flux - prioritatea acestuia. Diferite sisteme definesc prioritatea în mod diferit. În unele sisteme, valoarea cu cea mai mare prioritate poate fi considerată numeric cea mai mare valoare, în altele - dimpotrivă, cea mai mare prioritate este considerat zero.

De obicei, prioritatea unui fir este direct legată de prioritatea procesului în care rulează firul. Prioritatea procesului atribuite de sistemul de operare atunci când este creat, ținând cont dacă procesul este unul de sistem sau unul de aplicație, care este starea utilizatorului care a lansat procesul și dacă a existat o instrucțiune explicită de utilizator pentru a atribui o anumită prioritate la proces. Valoarea priorității este inclusă în mânerul procesului și este utilizată atunci când se atribuie prioritate firelor sale. Dacă un fir de execuție nu este inițiat de o comandă de utilizator, ci ca urmare a unui alt fir de execuție a unui apel de sistem, atunci sistemul de operare trebuie să țină cont de parametrii apelului de sistem pentru a-i atribui prioritate.

Atunci când planificați întreținerea programului conform algoritmilor descriși anterior, poate apărea o situație când unele sarcini de control sau management nu pot fi implementate pentru o perioadă lungă de timp din cauza încărcării în creștere a sistemului (în special în RTOS). Mai mult decât atât, consecințele datorate îndeplinirii premature a unor astfel de sarcini pot fi mai grave decât din cauza eșecului de finalizare a unor programe cu o prioritate mai mare. În acest caz, ar fi indicat să se schimbe temporar prioritatea sarcinilor „de urgență” (cele al căror timp de procesare a expirat), iar după execuție, să se restabilească valoarea anterioară. Introducerea mecanismelor pentru schimbarea dinamică a priorităților face posibilă implementarea unui răspuns mai rapid al sistemului la solicitările scurte ale utilizatorilor (ceea ce este important în timpul lucrului interactiv), dar, în același timp, garantează îndeplinirea oricăror solicitări.

Deci prioritatea ar putea fi static(fix) sau dinamic(schimbarea sistemului în funcție de situația din acesta). Așa-zisul prioritatea firului de bază depinde direct de prioritatea de bază a procesului care a generat-o. În unele cazuri, sistemul poate crește prioritatea unui fir de execuție (și în diferite grade), de exemplu, dacă intervalul de timp al procesorului care i-a fost alocat nu a fost utilizat în totalitate, sau poate reduce prioritatea în caz contrar. De exemplu, sistemul de operare acordă prioritate mai mult thread-urilor care așteaptă intrarea de la tastatură și mai puțin thread-urilor care efectuează operațiuni pe disc. În unele sisteme care utilizează un mecanism de prioritate dinamică, se folosesc formule destul de complexe pentru modificarea priorității, care implică valorile priorităților de bază, gradul de încărcare a sistemului informatic, valoarea inițială a priorității specificată de utilizator etc. .

Există două tipuri de programare prioritară: întreținere cu prioritati relativeși serviciul cu prioritati absolute. În ambele cazuri, selecția unui fir de execuție se realizează în același mod - firul cu cea mai mare prioritate este selectat, iar momentul schimbării firului activ este determinat diferit. Într-un sistem cu prioritate relativă, firul activ rulează până când părăsește procesorul (fie așteaptă, apare o eroare, fie firul se termină). Într-un sistem cu priorități absolute, întreruperea firului activ, pe lângă motivele indicate, apare și dacă în coada de fire gata apare un fir cu o prioritate mai mare decât cel activ. Apoi firul de rulare este întrerupt și pus în stare gata.

Un sistem cu programare cu prioritate relativă minimizează costurile de comutare, dar o singură sarcină poate ocupa procesorul mult timp. Acest mod de serviciu nu este potrivit pentru sistemele de partajare a timpului și în timp real, dar în sistemele de procesare batch (de exemplu, OS/360) este utilizat pe scară largă. Programarea cu prioritate absolută este potrivită pentru sistemele de management al facilităților în care răspunsul rapid la evenimente este important.

Tip de planificare mixt utilizat în multe sisteme de operare: algoritmii de planificare bazați pe priorități sunt combinați cu conceptul de cuantizare.

DEZVOLTAREA UNUI MODUL DE SISTEM DE OPERARE DE FORMARE

Instrucțiuni

pentru proiectarea cursurilor în disciplină

„OS”

pentru studenti formă zilnică Instruire

directii

INTRODUCERE. 4

1. Secțiunea teoretică. 4

1.1. Subsistemul de control al procesului. 4

1.1.1. Context și proces de gestionare. 5

1.1.2. Algoritmi de planificare a proceselor. 6

1.1.3. Algoritmi de programare preventivă și non-preemptivă. 9

1.1.4. Modelul procesului și funcțiile subsistemului de management al proceselor al sistemului de operare educațional 12

1.2. Subsistemul de gestionare a memoriei.. 17

1.2.1. Distribuția paginilor. 18

1.2.2. Distribuția pe segmente. 22

1.2.3. Distribuție pe segmente de pagină. 23

1.2.4. Algoritmi de înlocuire a paginii. 24

1.3. Gestionarea fișierelor. treizeci

1.3.1. Nume de fișiere. treizeci

1.3.2. Tipuri de fisiere. 32

1.3.3. Organizarea fizică și adresa dosarului. 33

2. Procedura de finalizare a proiectului de curs. 38

3. Opțiuni pentru sarcini. 39

Bibliografie 42

ANEXA A... 43

INTRODUCERE

Scopul proiectului de curs: studierea fundamentelor teoretice ale construirii modulelor sistemului de operare. Dobândiți abilități practice în dezvoltarea unui program care face parte din sistemul de operare.

Secțiunea teoretică

Funcțiile sistemului de operare al unui computer autonom sunt de obicei grupate fie în funcție de tipurile de resurse locale pe care le gestionează sistemul de operare, fie în funcție de sarcini specifice care se aplică tuturor resurselor. Uneori, astfel de grupuri de funcții sunt numite subsisteme. Cele mai importante subsisteme sunt subsistemele de gestionare a proceselor, memoriei, fișierelor și dispozitivelor externe, iar subsistemele comune tuturor resurselor sunt interfața cu utilizatorul, protecția datelor și subsistemele de administrare.

Subsistemul de control al procesului

Cea mai importantă parte a sistemului de operare, care afectează direct funcționarea computerului, este subsistemul de control al procesului. Pentru fiecare proces nou creat, sistemul de operare generează structuri de informații de sistem care conțin date despre nevoile procesului de resurse ale sistemului informatic, precum și despre resursele efectiv alocate acestuia. Astfel, un proces poate fi definit și ca o aplicație pentru consumarea resurselor sistemului.

Pentru ca un proces să fie executat, sistemul de operare trebuie să îi atribuie o zonă de RAM în care vor fi localizate codurile și datele procesului și, de asemenea, să îi ofere suma necesară Timp CPU. În plus, procesul poate avea nevoie de acces la resurse precum fișiere și dispozitive I/O.

Într-un sistem multitasking, un proces poate fi în una dintre cele trei stări principale:

RUNNING - starea activă a unui proces, în timpul căreia procesul are toate resursele necesare și este executat direct de procesor;

ASTEPTARE este starea pasiva a unui proces, procesul este blocat, nu poate fi executat din motive interne, asteapta sa apara un eveniment, de exemplu, finalizarea unei operatii I/O, primirea unui mesaj de la altul proces sau eliberarea unei resurse de care are nevoie;

READY este, de asemenea, o stare pasivă a unui proces, dar în acest caz procesul este blocat din cauza unor circumstanțe externe acestuia: procesul are toate resursele necesare pentru el, este gata de executat, dar procesorul este ocupat cu executarea unui alt proces.

Pe parcursul ciclului de viață, fiecare proces trece de la o stare la alta în conformitate cu algoritmul de planificare a procesului implementat într-un sistem de operare dat. Un grafic tipic al stării procesului este prezentat în Figura 1.1.

Figura 1.1 — Graficul stării procesului într-un mediu multitasking

Într-un sistem cu un singur procesor, poate exista un singur proces în starea RUNNING, iar în fiecare dintre stările AȘTEPTARE și READY pot exista mai multe procese aceste procese formează cozi de procese de așteptare, respectiv gata.

Ciclu de viață procesul începe cu starea READY, când procesul este gata de executat și își așteaptă rândul. Când este activat, procesul intră în starea RUNNING și rămâne în el până când fie eliberează procesorul însuși, intră în starea AȘTEPTARE pentru un eveniment, fie este evacuat forțat din procesor, de exemplu, din cauza epuizării timpului procesorului. cuantumul alocat acestui proces. În acest din urmă caz, procesul revine la starea READY. Procesul trece la această stare din starea AȘTEPTARE după ce apare evenimentul așteptat.

Articole de citit:

Bazele programării. Administrarea procesului

Unul dintre principalele subsisteme ale oricărui sistem de operare multiprogram modern care afectează direct funcționarea computerului este subsistemul de gestionare a proceselor și firelor. Principalele funcții ale acestui subsistem:

crearea de procese și fire;

asigurarea proceselor și thread-urilor cu resursele necesare;

izolarea procesului;

programarea execuției proceselor și firelor de execuție (în general, ar trebui să vorbim și despre programarea sarcinilor);

expedierea firului;

organizarea comunicării între procese;

sincronizarea proceselor și a firelor de execuție;

terminarea și distrugerea proceselor și firelor.

1. Cinci evenimente principale duc la crearea unui proces:

îndeplinirea cererii unui proces în derulare de a crea un proces;

o cerere de utilizator pentru a crea un proces, cum ar fi atunci când se conectează interactiv;

inițiați o lucrare în lot;

crearea de către sistemul de operare a unui proces necesar pentru funcționarea oricăror servicii.

De obicei, atunci când sistemul de operare pornește, sunt create mai multe procese. Unele dintre ele sunt procese cu prioritate ridicată care interacționează cu utilizatorii și efectuează munca atribuită. Procesele rămase sunt procese de fundal, nu sunt asociate cu anumiți utilizatori, dar efectuează funcții speciale - de exemplu, legate de e-mail, pagini Web, ieșire către sigiliu, transfer de fișier De rețea, lansarea periodică a programelor (de exemplu, defragmentarea discului) etc. Procesele de fundal sunt numite demoni.

Se poate crea un nou proces De cererea procesului curent. Crearea de noi procese este utilă în cazurile în care sarcina efectuată poate fi cel mai ușor formată ca un set de procese înrudite, dar totuși independente, care interacționează. În sistemele interactive utilizator poate lansa un program tastând o comandă pe tastatură sau făcând dublu clic pe pictograma programului. În ambele cazuri se creează un nou proces și lansa sunt programe in el. ÎN sisteme de procesare în loturi pe mainframe, utilizatorii trimit un job (eventual folosind acces la distanță), iar sistemul de operare creează un nou proces și începe următorul job din coadă când resursele necesare sunt eliberate.

2. Din punct de vedere tehnic, în toate aceste cazuri, un nou proces se formează în același mod: procesul curent execută sistemul. cerere pentru a crea un nou proces. Subsistemul de gestionare a proceselor și firelor este responsabil pentru furnizarea proceselor cu resursele necesare. Sistemul de operare menține în memorie structuri speciale de informații, în care înregistrează ce resurse sunt alocate fiecărui proces. Poate atribui resurse unui proces pentru utilizare exclusivă sau pentru utilizare partajată cu alte procese. Unele dintre resurse sunt alocate procesului atunci când este creat, iar unele sunt alocate dinamic De anchete în perioada de graţie. Resursele pot fi alocate unui proces pentru întreaga sa viață sau doar pentru o anumită perioadă. La îndeplinirea acestor funcții, subsistemul de control al procesului interacționează cu alte subsisteme OS responsabile managementul resurselor, cum ar fi subsistemul de gestionare a memoriei, subsistem de intrare/ieșire, Sistemul de fișiere.

3. Pentru a preveni interferarea cu procesele alocare resurselorși, de asemenea, nu ar putea deteriora codurile și datele celuilalt, Cea mai importantă sarcină a sistemului de operare este izolarea unui proces de altul. Pentru aceasta sistem de operare oferă fiecărui proces un spațiu separat de adrese virtuale, astfel încât niciun proces să nu poată accesa direct comenzile și datele altui proces.

4. Într-un sistem de operare în care există procese și fire de execuție, un proces este considerat o solicitare de a consuma toate tipurile de resurse, cu excepția unui singur - timpul procesorului. Acest lucru este cel mai important resursă distribuite de sistemul de operare între alte unități de lucru - fire, care și-au primit numele datorită faptului că reprezintă secvențe (fire de execuție) de comenzi. Ca urmare, trecerea de la execuția unui fir la altul se realizeazăplanificare Șiexpediere . Loc de munca De Determinarea momentului în care firul curent ar trebui întrerupt și firul care ar trebui să fie lăsat să ruleze se numește programare. Programarea firelor se face pe baza informațiilor stocate în descriptori de proces și fir. La planificare, se ia în considerare prioritatea firului, timpul lor de așteptare la coadă, acumulat perioada de graţie, intensitatea accesului I/O și alți factori.

5. Dispeceratul consta in implementarea solutiei gasite ca urmare a planificarii, i.e. în comutarea procesorului de la un thread la altul. Expedierea are loc în trei etape:

salvarea contextului firului curent;

lansarea unui nou thread pentru execuție.

6. Când un sistem rulează simultan mai multe sarcini independente, apar probleme suplimentare. Deși firele de execuție apar și se execută sincron, este posibil să fie nevoie să interacționeze, de exemplu, la schimbul de date. Pentru a comunica între ele, procesele și firele de execuție pot folosi o gamă largă de capabilități: canale (în UNIX), cutii poștale ( Windows), apel de procedură la distanță, prize (in Windows conectați procese pe diferite mașini). Potrivirea vitezelor firelor este, de asemenea, foarte importantă pentru a preveni condițiile de cursă (unde mai multe fire încearcă să schimbe la fel fişier), blocaje și alte coliziuni care apar atunci când resursele sunt partajate.

7. Sincronizare firele de execuție este una dintre cele mai importante funcții ale subsistemului de gestionare a proceselor și a firelor de execuție. Sistemele de operare moderne oferă o varietate de mecanisme de sincronizare, inclusiv semafoare, mutexuri, regiuni critice și evenimente. Toate acestea mecanisme lucrează cu fire, nu cu procese. De aceea când curgere blocuri pe un semafor, alte fire din acest proces pot continua să ruleze.

8. De fiecare dată când procesul se încheie, – și acest lucru se întâmplă din cauza unuia dintre următoarele evenimente: normal Ieșire, Ieșire De greşeală, Ieșire De eroare fatală, distrugere de către un alt proces - sistemul de operare ia măsuri pentru a „curăța urmele” prezenței sale în sistem. Subsistemul de management al procesului închide toate fișierele cu care a lucrat procesul, eliberând zone de RAM alocate pentru coduri, date și structurile de informații de sistem ale procesului. Efectuat corecţie tot felul de cozi de OS și listă resurse care conțineau link-uri către procesul care se încheie.

Subsistemul de control al procesului

Un program lansat pentru execuție generează unul sau mai multe proceselor(sau sarcini). Subsistemul de control al procesului controlează:

Crearea și ștergerea proceselor

Distribuția resurselor sistemului (memorie, resurse de calcul) între procese

Sincronizarea proceselor

Comunicarea intraprocesuala

Evident, în general, numărul de procese active depășește numărul de procesoare de pe computer, dar în orice moment, pe fiecare procesor poate rula un singur proces. Sistemul de operare gestionează accesul proceselor la resursele de calcul, creând în același timp sentimentul de multitasking.

O sarcină specială de kernel numită administrator sau planificator procese (scheduler), rezolvă conflictele dintre procesele aflate în competiție pentru resursele sistemului (procesor, memorie, dispozitive de intrare/ieșire). Planificatorul începe procesul de execuție, asigurându-se că procesul nu preia exclusiv resursele partajate de sistem. Un proces eliberează procesorul în timp ce așteaptă o operațiune lungă de I/O sau după ce a trecut o porțiune de timp. În acest caz, planificatorul selectează următorul proces cu cea mai mare prioritate și îl pornește pentru execuție.

Modul de gestionare a memoriei oferă plasarea memoriei RAM pentru sarcinile aplicației. RAM este o resursă costisitoare și, în general, rareori există „prea mult”. Dacă nu există suficientă memorie pentru toate procesele, nucleul mută părți ale procesului sau mai multe procese în memoria secundară (de obicei într-o zonă specială hard disk), eliberând resurse pentru procesul de rulare. Toate sisteme moderne implementează așa-numitul memorie virtuala: Procesul rulează în propriul spațiu de adrese logic, care poate fi semnificativ mai mare decât memoria fizică disponibilă. Gestionarea memoriei virtuale a unui proces este de asemenea responsabilitatea modulului de gestionare a memoriei.

Modul de comunicare interproces este responsabil pentru notificarea proceselor despre evenimente folosind semnale și oferirea capacității de a transfera date între diferite procese.

Acest text este un fragment introductiv. Din cartea Structura internă a Microsoft Windows (cap. 8-11) autor Marcu Rusinovici

Din cartea Arhitectura sistemului de operare UNIX autorul Bach Maurice J

CAPITOLUL 10. SUBSISTEMUL DE GESTIUNE I/O Subsistemul de gestionare a I/O permite proceselor să comunice cu dispozitive periferice, cum ar fi unitățile de disc și de bandă, terminale, imprimante și rețele, pe de o parte, și cu modulele nucleului,

De pe serverul de carte DIY Linux autor

5.1.1. Schema generală de management al procesului Fiecare proces poate genera un proces complet identic folosind fork(). Un proces părinte poate aștepta ca toate procesele sale secundare să finalizeze execuția folosind apelul de sistem wait. În orice moment procesul

Din cartea AS/400 Basics de Soltis Frank

5.3. Comenzi de control al proceselor Comanda ps Comanda ps este concepută pentru a afișa informații despre procesele care rulează în prezent. Această comandă are mulți parametri, despre care puteți citi în manual (man ps). Aici le voi descrie doar pe cele mai des folosite

Din cartea Programming in Ruby [Ideologia limbajului, teoria și practica aplicației] de Fulton Hal

Despre subsistemul de memorie Una dintre cele mai mari probleme ale oricărui procesor este menținerea lui ocupată. Performanța procesorului a crescut enorm în ultimii ani, dublându-se în medie la fiecare doi ani. Performanța memoriei și I/O nu poate ține pasul

Din cartea Linux: Ghid complet autor Kolisnichenko Denis Nikolaevici

Managementul proceselor Timpul este mijlocul prin care Natura împiedică totul să se întâmple odată. În calculatoare, procesele servesc ca astfel de mijloace. Un proces este un program care rulează. Constă dintr-un program executabil, date de program și unele informații

Din cartea Programare pentru Linux. Abordare profesională de Mitchell Mark

14.1.3. Manipularea proceselor În această secțiune vom discuta despre manipularea procesului, deși crearea unui nou proces nu implică neapărat rularea unui program extern. Principala modalitate de a crea un nou proces este metoda fork, al cărei nume este în conformitate cu

Din cartea Sistem de operare UNIX autor Robachevsky Andrey M.

9.2. Comenzi de control al procesului 9.2.1. Ierarhia proceselor: ps și pstree Știți deja că comanda ps vă permite să vizualizați informații despre toate procesele care rulează în sistem în acest moment (secțiunea 3.2). Cu comutatorul -f, această comandă afișează atât PID-ul procesului în sine, cât și PPID-ul părintelui său,

Din cartea autorului

3.1. Familiarizarea cu procesele Utilizatorul trebuie doar să se conecteze la sistem pentru ca procesele să înceapă să se execute. Chiar dacă utilizatorul nu lansează nimic, ci doar stă în fața ecranului și bea cafea. există încă o licărire de viață în sistem. Orice program care rulează

Din cartea autorului

Subsistemul de fișiere Subsistemul de fișiere oferă o interfață unificată pentru accesarea datelor aflate pe unitățile de disc și dispozitivele periferice. Aceleași funcții open(2), read(2), write(2) pot fi utilizate atât la citirea, cât și la scrierea datelor pe disc și

Din cartea autorului

Subsistemul de intrare/ieșire Subsistemul I/O execută cereri de la subsistemul de fișiere și de la subsistemul de control al procesului pentru a accesa dispozitivele periferice (discuri, benzi, terminale etc.). Oferă tamponarea de date necesară și

Din cartea autorului

Din cartea autorului

Capitolul 3 Subsistemul de management al proceselor Inima sistemului de operare UNIX este subsistemul de management al proceselor. Aproape toate acțiunile nucleului sunt legate de procese, fie că este vorba despre deservirea unui apel de sistem, generarea unui semnal, alocarea memoriei, procesarea

Din cartea autorului

Capitolul 4 Subsistemul de fișiere Majoritatea datelor din sistemul de operare UNIX sunt stocate în fișiere, organizate într-un arbore și situate pe un mediu de stocare. De obicei, acesta este un hard local (adică situat pe același computer cu sistemul de operare însuși).

Din cartea autorului

Capitolul 5 Subsistemul I/O Arhitectura actuală I/O este ascunsă de procesul de aplicare prin mai multe interfețe. Una dintre ele, interfața sistemului de fișiere, a fost discutată în capitolul anterior. Interacțiunea cu resursele de la distanță este asigurată de rețea

Din cartea autorului

Subsistemul STREAMS Arhitectura subsistemului stream I/O STREAM a fost descrisă pentru prima dată în Ritchie, D.M., „A Stream Input-Output System,” AT&T Bell Laboratories Technical Journal, Vol. 63, Nr. 8, Oct. 1984) în 1984. Doi ani mai târziu, acest sistem a fost implementat în

Inima sistemului de operare UNIX este subsistemul de management al proceselor. Aproape toate activitățile nucleului sunt legate de proces, fie că este vorba despre deservirea unui apel de sistem, generarea unui semnal, alocarea memoriei, gestionarea excepțiilor cauzate de execuția procesului sau furnizarea de servicii I/O solicitate de un proces de aplicație.
Toată funcționalitatea sistemului de operare este determinată în cele din urmă de execuția anumitor procese, la fel cum nivelurile de rulare ale sistemului nu sunt altceva decât o formă convenabilă de definire a unui grup de procese care rulează. Capacitatea de a terminal sau de a accesa în rețea sistemul, diverse servicii tradiționale pentru UNIX - un sistem de imprimare, arhive FTP la distanță, e-mail și un sistem de conferințe de presă - toate acestea sunt rezultatul anumitor procese. Procesele din UNIX sunt legate în mod inerent de două dintre cele mai importante resurse ale sistemului: procesorul și memoria RAM. De regulă, nu există niciodată „multe” dintre aceste resurse, iar în sistemul de operare există o competiție activă pentru dreptul de a deține procesorul și memoria. Și, deoarece UNIX este un sistem multitasking de uz general, sarcina de a distribui în mod echitabil această resursă între sarcini de diferite clase și cu cerințe diferite nu este banală.
Deoarece un program lansat pentru execuție generează unul sau mai multe
procese (sau sarcini). Subsistemul de control al procesului controlează:

• Crearea și ștergerea proceselor
• Distribuția resurselor sistemului (memorie, resurse de calcul) între procese
• Sincronizarea proceselor
• Comunicarea intraprocesuala

Este evident că, în cazul general, numărul de procese active depășește numărul de procesoare de calculator,
dar la un moment dat, pe fiecare procesor poate rula un singur proces. Sistemul de operare controlează accesul proceselor la resursele de calcul,
creând sentimentul de multi-tasking. O sarcină specială a nucleului numită planificator de procese rezolvă conflictele dintre procesele care concurează pentru resursele sistemului (CPU, memorie, dispozitive I/O). Planificatorul începe procesul de execuție, asigurându-se că procesul nu preia exclusiv resursele partajate de sistem. Un proces eliberează procesorul în timp ce așteaptă o operațiune lungă de I/O sau dupăcuantumul de timp. În acest caz, programatorul selectează următorul proces cu cea mai mare prioritate și începeacesta pentru executare.

Modul de gestionare a memoriei oferă alocarea RAM pentru sarcinile aplicației Dacă nu există suficientă memorie pentru toate procesele, nucleul mută părți ale procesului
sau procese multiple în memoria secundară (de obicei, o zonă specială a hard disk-ului), eliberând resurse pentru procesul de rulare.

Toate sistemele moderne implementează ceea ce se numește memorie virtuală: procesul rulează în propriul spațiu de adrese logic, care poate fi semnificativ mai mare decât memoria fizică disponibilă. Gestionarea memoriei virtuale a unui proces este, de asemenea, responsabilitatea modulului de gestionare a memoriei.
Modul de comunicare interproces este responsabil pentru notificarea proceselor despre evenimente folosind semnale și oferirea capacității de a transfera date între diferite procese.

Bazele controlului procesului

Un proces UNIX este o imagine executabilă a unui program care include o mapare de memorie a fișierului executabil obținut ca rezultat al compilării, de exemplu. o există traduceri ale modulelor de program, limbi de nivel înalt, în module de program echivalente ale limbiinivel scăzut, așa:stivă, cod de bibliotecă și date, precum și o serie de structuri de date kernel necesare pentru a controla procesul, care este destul de punct important pentru înțelegerea în continuare a principiilor distribuției memoriei, ca una dintre cele mai importante resurse în „concurența” proceselor, adică datele sunt structurate!, în mod convențional:

• Stiva (din curent ) - o zonă de memorie în care programul stochează informații despre funcțiile apelate, argumentele acestora și fiecare variabilă locală din funcții. Mărimea zonei se poate modifica pe măsură ce programul rulează. Când sunt apelate funcții, stiva crește, iar când este finalizată, scade.
• Heap (a preda ) este o zonă de memorie în care un program poate face tot ce dorește. Dimensiunea zonei poate varia. Programatorul are posibilitatea de a folosi o parte din memoria heap folosind funcția malloc(), iar apoi această zonă de memorie este mărită. Resursele sunt returnate folosind free() , după care heap-ul este redus.
• Cod (pentru a codifica segmentul ) este o zonă de memorie în care sunt stocate instrucțiunile de mașină ale unui program compilat. Sunt generate de compilator, dar pot fi scrise și manual. Rețineți că această zonă de memorie poate fi, de asemenea, împărțită în trei părți (text, date și BSS). Această zonă de memorie are o dimensiune fixă ​​determinată de compilator.UNIX. Programare profesionala art 259

Acest lucru va predetermina (printre altele) apariția (existența) segmentelor și paginilor. Un proces folosește diverse resurse de sistem în timpul execuției - memorie, procesor, servicii de subsistem de fișiere și servicii de subsistem de intrare/ieșire. Adevărul dur al oricărui sistem de calcul modern este că un procesor poate deservi doar un proces pe unitatea de timp, care, la rândul său, predeterminatapariţia (existenţa) unui „planificator”, prin intermediul căruiaSistemul de operare UNIX oferă iluzia mai multor procese care rulează simultan prin distribuirea eficientă a resurselor de sistem între procesele active, împiedicând în același timp oricare dintre ele să monopolizeze utilizarea acelor resurse.

Noul sistem de operare UNIX prevedea executarea a doar două procese, câte unul pentru fiecare terminal conectat la PDP-7. Un an mai târziu, pe același PDP-7, numărul de procese a crescut considerabil, a apărut un apel de sistem furculiţă. Prima ediție a UNIX a introdus apelul ex, dar sistemul de operare permitea totuși să fie plasat în memorie un singur proces odată. Odată cu implementarea unui subsistem hardware de gestionare a memoriei pe PDP-11, sistemul de operare a fost modificat pentru a permite încărcarea simultană a mai multor procese în memorie, reducând astfel timpul necesar pentru stocarea unei imagini de proces în memoria secundară (pe disc) și citiți-l când procesul a continuat să se execute. Cu toate acestea, până în 1972, UNIX nu putea fi numit un sistem cu adevărat multitasking, deoarece operațiunile I/O au rămas sincrone, iar alte procese nu se puteau executa până când „colegul” lor nu a finalizat operațiunea I/O. Adevăratul multitasking a apărut doar când codul UNIX a fost rescris în C în 1973. De atunci, fundamentele managementului proceselor au rămas practic neschimbate.

Execuția procesului poate avea loc în două moduri - în modul kernel ( modul kernel) sau în modul task ( modul utilizator). În modul task, procesul execută instrucțiuni ale programului de aplicație care sunt permise la nivelul de securitate neprivilegiat al procesorului. În acest caz, structurile de date ale sistemului nu sunt disponibile procesului. Când un proces trebuie să primească servicii de kernel, efectuează un apel de sistem care execută instrucțiuni de kernel care sunt la nivelul privilegiat.

Deși instrucțiunile nucleului sunt executate, ele fac acest lucru în numele procesului care a efectuat apelul de sistem. Execuția procesului trece apoi în modul kernel. În acest fel, nucleul sistemului își protejează propriul spațiu de adrese de accesul de către un proces de aplicație, care ar putea încălca integritatea structurilor de date ale nucleului și ar putea duce la distrugerea sistemului de operare.

Mai mult, unele instrucțiuni ale procesorului, de exemplu, schimbarea registrelor legate de gestionarea memoriei, pot fi executate doar în modul kernel.
În consecință, imaginea procesului constă din două părți: date mod nucleu și date mod task. O imagine de proces în modul task constă dintr-un segment de cod, date, stivă, biblioteci și alte structuri de date pe care le poate accesa direct. O imagine a procesului în modul kernel constă din structuri de date care nu sunt accesibile unui proces în modul sarcină care sunt utilizate de nucleu pentru a controla procesul. Acestea includ date dictate de hardware, cum ar fi stările de registru, tabele de mapare a memoriei etc., precum și structurile de date necesare nucleului pentru a servi procesul. În general, în modul kernel, un proces poate accesa orice zonă de memorie.

Structuri de date de proces

Fiecare proces este reprezentat în sistem de două structuri principale de date procȘi utilizator,

descrise, respectiv, în dosare sys/proc.hȘi sys/utilizator.h. Conținutul și formatul acestor structuri variază între versiunile UNIX.

....................................................................................................

https://m.habr.com/ru/company/*nix<-----------
….................................................................................................
În orice moment, structurați datele proc pentru toate procesele trebuie să fie prezente în memorie, deși structurile de date rămase, inclusiv imaginea procesului, pot fi mutate în memoria secundară, zona de swap. Acest lucru permite nucleului să aibă la îndemână informațiile minime necesare pentru a localiza datele rămase relevante pentru proces, chiar dacă nu sunt în memorie. Structura proc este o intrare în tabelul de procese ale sistemului, care, așa cum tocmai am observat, este întotdeauna în RAM. Intrarea din acest tabel pentru procesul care rulează curent este adresată de variabila de sistem curproc. De fiecare dată când există o schimbare de context în care resursele CPU sunt transferate către altul
proces, valoarea variabilei se modifică în consecință curproc, care indică acum structură proc proces activ. A doua structură menționată utilizator, numit si zona u sau u-bloc, conține date suplimentare de proces care sunt solicitate de nucleu numai în timpul execuției procesului (adică atunci când procesorul execută instrucțiuni de proces în modul kernel sau task). Spre deosebire de structura proc, adresată de indicator curproc, date utilizator sunt puse
(mai precis, afișate) într-un anumit loc din memoria virtuală a nucleului și sunt adresate unei variabile u. Cele două structuri principale de date de proces și modul în care nucleul UNIX le abordează sunt prezentate mai jos.
ÎN zona u Sunt stocate date care sunt utilizate de multe subsisteme ale nucleului și nu numai pentru controlul procesului. În special, conține informații despre descriptorii fișierelor deschise, dispoziția semnalului, statisticile de execuție a procesului și valorile registrului salvat atunci când execuția procesului este suspendată. Evident, un proces nu ar trebui să poată modifica aceste date într-un mod arbitrar, astfel încât u-area este protejată de acces în modul task. După cum se poate observa din figură, zona u conține, de asemenea, o stivă de dimensiuni fixe, stivă de sistem sau stivă de nucleu. Când un proces rulează în modul kernel, sistemul de operare folosește această stivă mai degrabă decât stiva normală a procesului.

Stări de proces

Ciclul de viață al unui proces poate fi împărțit în mai multe stări. Trecerea unui proces de la o stare la alta are loc in functie de aparitia anumitor evenimente in sistem.

• 1. Procesul rulează în modul task. În acest caz, procesorul execută instrucțiunile de aplicare ale acestui proces.
• 2. Procesul rulează în modul kernel. În acest caz, procesorul execută instrucțiuni de sistemnucleul sistemului de operare în numele procesului.
• 3 . Procesul nu rulează, dar este gata să ruleze de îndată ce programatorulîl va selecta (starea rulabilă) Procesul este în coada de execuție și are toateresursele de care are nevoie, cu excepția celor de calcul.
• 4. Procesul este într-o stare de somn (adormit), așteaptă ceva indisponibilun moment dat al unei resurse, cum ar fi finalizarea unei operațiuni I/O.
• 5. Procesul revine din modul kernel în modul task, dar nucleul îl întrerupe și produceschimbarea contextului pentru a rula un proces cu prioritate mai mare.
• 6. Procesul a fost creat doar de furk și este în tranzițiestare: există, dar nu este pregătit să ruleze și nu este în stare de repaus.
• 7. Procesul a executat apelul de sistem de ieșire și a intrat în starezombie (zombi, defunct). Nu există niciun proces ca atare, dar înregistrările rămân,care conțin codul de returnare și statisticile temporare ale execuției acestuia, disponibile procesului părinte.Această stare este starea finală din ciclul de viață al procesului.

Trebuie remarcat că nu toate procesele trec prin întregul set de stări prezentate mai sus Procesul își începe calea de viață din stare 6 când procesul părinte efectuează un apel de sistem furculiţă(). După ce crearea procesului este complet finalizată, procesul încheie „copilul” apelului și intră în stare 3 gata de lansare, așteptându-l
cozi de execuție. Când planificatorul selectează un proces de executat, acesta intră în stare 1 și rulează în modul task. Execuția în modul Task se termină ca urmare a unui apel de sistem sau a unei întreruperi, iar procesul intră în modul kernel, unde este executat apelul de sistem sau codul de întrerupere. După aceasta, procesul poate reveni din nou la modul task. Cu toate acestea, în timpul executării unui apel de sistem în modul kernel, un proces poate avea nevoie de o resursă care nu este disponibilă în prezent. Pentru a aștepta accesul la o astfel de resursă, procesul apelează funcția kernel dormi()și intră într-o stare de somn 4 . În acest caz, procesul eliberează în mod voluntar resurse de calcul, care sunt furnizate următorului proces cu cea mai mare prioritate. Când o resursă devine disponibilă, nucleul „trezește procesul” folosind funcția trezeşte-te()îl pune în coadă pentru execuție și procesul intră în starea „gata de rulare”. 3 .
Când un proces este furnizat cu resurse de calcul, are loc o schimbare de context, în urma căreia imaginea sau contextul procesului curent este salvată, iar controlul este transferat către unul nou. O schimbare de context poate avea loc, de exemplu, dacă un proces intră în stare de repaus sau dacă un proces cu o prioritate mai mare decât cel curent este gata de rulare. În acest din urmă caz, nucleul nu poate întrerupe imediat procesul curent și nu poate efectua o schimbare de context. Faptul este că schimbarea contextului atunci când este executată în modul kernel poate duce la o încălcare a integrității sistemului însuși.
Prin urmare, schimbarea contextului este amânată până când procesul trece de la modul kernel la modul task, când toate operațiunile sistemului s-au finalizat și structurile de date ale nucleului sunt într-o stare normală.
Astfel, după ce programatorul a selectat un proces de rulat, acesta din urmă își începe
execuție în modul kernel, unde completează comutarea contextului. Condiție suplimentară
procesul depinde de istoricul său: dacă procesul tocmai a fost creat sau a fost întrerupt, revenind la modul task, intră imediat în acel mod. Dacă un proces începe execuția după o stare de repaus, acesta continuă să se execute în modul kernel, completând apelul de sistem. Rețineți că un astfel de proces poate fi întrerupt după finalizarea apelului de sistem în timpul tranziției de la modul kernel la modul task dacă există un proces cu prioritate mai mare în coadă. UNIX 4xBSD definește stări suplimentare de proces, în primul rând legate de sistemul de control al jobului și de interacțiunea procesului cu terminalul. Un proces poate fi pus într-o stare „oprit” folosind semnale de oprire SIGSTOP, SIGTTIN sau SIGTTOU. Spre deosebire de alte semnale, care sunt procesate doar pentru un proces care rulează, trimiterea acestor semnale provoacă o schimbare imediată a stării. În acest caz, dacă procesul rulează sau este pus în coadă pentru a rula, starea acestuia se schimbă în „oprit”. Dacă procesul a fost în stare de repaus, starea sa se va schimba în „oprit în stare de repaus”. Ieșirea din aceste stări se realizează printr-un semnal de continuare SIGCONT, în acest caz, procesul trece de la starea „oprit” la starea „gata de rulare”, iar pentru un proces oprit în starea de repaus, următoarea destinație este continuarea „sleep-ului”.
Capacitățile descrise sunt implementate complet în SVR4.

Există o excepție în ceea ce privește procesele care sunt în stare de somn pt
eveniment cu prioritate scăzută, adică un eveniment a cărui probabilitate de apariție este relativ scăzută (de exemplu, intrare de la tastatură care poate să nu aibă loc).

În cele din urmă, procesul execută un apel de sistem Ieșire()și își încheie execuția. Procesul poate fi încheiat și din cauza primirii unui semnal. În ambele cazuri, nucleul se lansează resursele deținute de proces, excluzând codul returnat și statisticile de execuție șipune procesul într-o stare „zombie”. Procesul rămâne în această stare până când procesul părinte execută unul dintre apelurile de sistem, după care toate informațiile despre proces vor fi distruse, iar părintele va primi codul de returnare al procesului încheiat.

Principii de management al memoriei

Marshall Kirk McKusick FreeBSD - Arhitectură și implementare<<-----------PDF ст.166

Managementul memoriei partea-1

12:51 - Rezolvarea adresei 34:21 - Suprapunere, structură dinamică

59:26 - Mapare liniară continuă - Liniară pe bucăți (Articolul 25)

Managementul memoriei partea-2

Ce sa întâmplat la început? OOP sau memorie virtuală.

51:44--> „Memorie virtuală”;<-(стр. 18)->56:03--> „Segmente”;

Buffer de difuzare asociativ, Buffer de traducere(TLB) este un cache specializat al procesorului folosit pentru a accelera traducerea unei adrese de memorie virtuală într-o adresă de memorie fizică. https://ru.wikipedia.org https://www.ibm.com/support/knowledgecenter/.performance/cache_tlbs.htm

Una dintre funcțiile principale ale unui sistem de operare este gestionarea eficientă a memoriei.
RAM, sau memorie principală, sau memorie cu acces aleatoriu (Random Access Memory, RAM). Timpul de acces la RAM este de doar câteva cicluri de procesor, așa că lucrul cu datele din memorie asigură performanță maximă.
Această resursă este de obicei limitată. Într-o măsură mai mare, acest lucru este valabil pentru un sistem de operare multitasking de uz general, care este UNIX.
Prin urmare, datele care nu pot fi plasate în RAM se află pe dispozitive de stocare secundare, sau în memoria secundară, al cărei rol este de obicei îndeplinit de
unități de disc. Timpul de acces la memoria secundară este cu câteva ordine de mărime mai mare decât timpul de acces la RAM și necesită asistența activă a sistemului de operare.
Subsistemul de gestionare a memoriei UNIX este responsabil pentru alocarea corectă și eficientă
resursă RAM partajată între procese și pentru schimbul de date între RAM și memoria secundară. Unele operații sunt efectuate în hardware, de către dispozitiv
unitatea de gestionare a memoriei (MMU) a procesorului sub controlul sistemului de operare, obținând astfel performanța necesară.
Managementul primitiv al memoriei reduce semnificativ funcționalitatea sistemului de operare. Astfel de sisteme, de regulă, permit încărcarea unei singure sarcini într-o locație predeterminată din RAM și transferarea controlului către aceasta. În acest caz, sarcina primește
eliminarea tuturor resurselor computerului (partajarea acestora, desigur, cu sistemul de operare),
iar adresele utilizate de sarcină sunt adrese RAM fizice.
Deoarece această metodă de lansare și executare a unui program este cu siguranță cea mai rapidă, este adesea folosită în sistemele specializate cu microprocesoare, dar este practic inaplicabilă în sistemele de operare de uz general, cum ar fi UNIX.
Putem formula o serie de capabilități pe care subsistemul de gestionare a memoriei al unui sistem de operare multitasking modern ar trebui să le ofere:

• Efectuarea de sarcini a căror dimensiune depășește dimensiunea operațională memorie.
• Executați sarcini parțial încărcate în memorie pentru a minimizamomentul lansării lor.
• Plasați mai multe sarcini în memorie simultan pentru a îmbunătăți eficiența procesorului.
• Plasarea unei sarcini într-o locație arbitrară din RAM.
• Plasarea unei sarcini în mai multe părți diferite ale RAM.
• Partajarea acelorași zone de memorie de către mai multe sarcini.De exemplu, mai multe procese care rulează același program pot partaja un segment de cod.
• capacitatea de a crea coduri independente de mașină, adică a priori nu ar trebui să existe nicio legătură între program și memoria fizică.

Toate aceste caracteristici sunt implementate în versiunile moderne ale UNIX folosind memorie virtuala, performanța sistemului de operare multitasking în ansamblu depinde în mare măsură de eficacitatea implementării și funcționării acestui subsistem. Permite unei aplicații să dea iluzia că are o cantitate mare de memorie disponibilă, când în realitate computerul poate avea doar o cantitate mică de RAM. Acest lucru necesită definirea unei abstracții „spațiu de adresă” care este distinctă de locația fizică a memoriei. Programul creează legături către coduri și date în spațiul său de adrese, astfel de adrese trebuie convertite în adrese ale celulelor RAM. Transferul de informații în memoria principală pentru utilizare de către un program și efectuarea traducerii adresei la fiecare acces la memorie obligă atât software-ul, cât și hardware-ul computerului să acționeze împreună.

PS: LINUX Mai mult, procesul funcționează cu adrese virtuale, nu fizice. Conversia are loc prin calcule folosind tabele de descriptori și cataloage de tabele. Linux acceptă 3 niveluri de tabele: directorul de tabel de primul nivel ( PGD- Directorul tabelului de pagini), directorul tabelelor de al doilea nivel ( PMD- Medium Page Table Diractory) și, în final, un tabel de descriptori (PTE- Intrare în tabelul paginii). În realitate, nu toate nivelurile pot fi suportate de un anumit procesor,dar spațiul pentru cap vă permite să susțineți mai multe arhitecturi posibile (Intel are 2 niveluri de tabele,și Alpha - cât 3). Conversia unei adrese virtuale într-una fizică are loc în 3 etape. Se ia un indicator PGD, disponibil în structura care descrie fiecare proces, este convertit într-un pointer de înregistrare PMD, iar acesta din urmă este convertit într-un pointer în tabelul descriptor PTE. Și în sfârșit la adresa adevărată,care indică la începutul paginii se adaugă un decalaj față de începutul acesteia. Un bun exemplu de astfel de procedură poate fi găsit în funcția kernel< parţial_clear>.

Memorie virtuală și fizică

RAM este una dintre componentele importante ale unui sistem informatic. Primele sisteme UNIX aveau la dispoziție 64 KB de RAM, iar această cantitate era în mod clar insuficientă computerele moderne au gigaocteți de RAM, iar acest lucru nu este încă suficient.
RAM poate fi reprezentată ca o secvență de octeți, fiecare având propria sa adresă unică, numită adresă fizică. Aceste adrese sunt pe care procesorul le folosește în cele din urmă atunci când face schimb de date cu RAM. Cu toate acestea, spațiul de adresă al unui proces diferă semnificativ de spațiul de adresă al memoriei RAM fizice. Să ne imaginăm că spațiul de adrese al procesului a fost mapat direct în RAM, cu alte cuvinte, că adresele folosite de proces erau adrese fizice. Cu această abordare, ne-ar aștepta o serie de obstacole de netrecut pe calea creării unui sistem multitasking:

• În primul rând, este dificil de imaginat un mecanism care protejează spațiul de adrese al unui singur proces,din spațiul de adrese al altuia sau, mai important, din spațiul de adrese al sistemului de operare însuși.Deoarece fiecare proces funcționează pe adrese fizice, nu există nicio garanție că un proces nu va accesacelule de memorie aparținând altor procese sau nucleului de sistem.Consecințele unui astfel de tratament vor fi cel mai probabil foarte grave.
• În al doilea rând, deja în etapa de compilare ar fi necesar să se prevadă distribuțiaspațiul de adrese fizice existent. Când a început, fiecare proces trebuieocupă o zonă adiacentă și fără suprapunere a adreselor fizice.
• În al treilea rând, o astfel de distribuție a memoriei între procese este puțin probabilăpoate fi numit optim. Volumul fizic operaționalmemoria va limita semnificativ numărul de proceserulează simultan pe sistem. Deci opt procese,fiecare dintre ele ocupă 1 MB de memorie va epuiza 8 MBRAM și sistemul de operare la încărcare medieare peste 80 de procese!

Toate aceste probleme pot fi depășite cu ajutorul memoriei virtuale.
Cu toate acestea, adresele utilizate de aplicații și nucleul în sine nu trebuie să corespundă adreselor fizice. Adresele virtuale sunt traduse sau mapate la cele fizice la nivel hardware cu participarea activă a nucleului sistemului de operare.Ideea memoriei virtuale este că fiecare proces rulează în propriul spațiu de adrese virtuale.

Spațiul de adrese virtuale este paradisul unui proces.

• În primul rând, procesul are un sentiment de exclusivitate - la urma urmei, întregul spațiu de adreseîi aparține numai lui.
• În al doilea rând, nu mai este limitat de cantitatea de memorie fizică - memoria virtuală poate în mod semnificativdepășește fizic Ca urmare, procesele devin izolate unele de altele și nu auposibilități (chiar dacă se dorește)„găzduiește” spațiul de adresă al vecinului. Memoria fizică este alocată cât mai mult posibileficient - nu depinde de alocarea memoriei virtuale a unui proces individual.

Evident, este necesar un mecanism de mapare gestionat pentru implementarea memoriei virtuale
adresa virtuală la fizică. În sistemele informatice moderne, procesul de afișare se realizează la nivel hardware (folosind MMU)(MMU bit ("bit de utilizare")) furnizând de mare viteză emisiuni.
Sistemul de operare gestionează acest proces.

Procesoarele moderne, de regulă, acceptă unificarea spațiului de adrese (organizarea segmentului - memorie de pagină):

V zone de dimensiuni variabile – segmenteȘi

V zone cu dimensiuni fixe - pagini,

conceptul de „pagină” poate fi interpretat ca o modalitate de organizare a memoriei atunci când memoria fizică este împărțită în blocuri de dimensiune fixă ​​(512-2Kb, un multiplu de 2), precum și conceptul de „segment”, „pagină” este una dintre abstracțiile fundamentale în înțelegerea arhitecturii și funcționării sistemelor de operare. În acest caz, fiecare segment sau pagină poate avea propria sa mapare a adreselor virtuale la cele fizice.
Spațiul de adrese virtuale al unui proces este de obicei structurat secvenţial în segmente - cod, date, stivă și biblioteci. Locația zonelor corespunzătoare ale memoriei fizice poate varia fragmentat caracter. Dimensiunea memoriei virtuale poate depăși semnificativ dimensiunea memoriei fizice prin utilizarea memoriei secundare sau a unei zone de schimb - de obicei spațiu pe disc, unde pot fi stocate porțiuni temporar neutilizate din spațiul de adresă al procesului. De exemplu, dacă un proces execută și accesează o adresă virtuală care are o pagină corespunzătoare de memorie fizică prezentă, operația de citire sau scriere va reuși. Dacă o pagină lipsește din RAM, procesorul generează o întrerupere hardware numită eroare de pagină ( eroare de pagină), ca răspuns la care nucleul determină poziția conținutului paginii stocate în zona de swap, citește pagina în memorie, setează parametrii pentru maparea adreselor virtuale cu cele fizice și informează procesorul despre necesitatea repetării operației. Toate aceste acțiuni sunt invizibile pentru aplicația care funcționează cu memorie virtuală.
Mecanismul de mapare a adreselor virtuale cu cele fizice (traducere adrese) este esențial

depinde de implementarea hardware specifică. Această secțiune discută mecanismul de mapare a adreselor virtuale la adrese fizice în sistemul de operare SCO UNIX folosind familia de procesoare Intel ca exemplu. Cu toate acestea, ca și în cazul altor subsisteme UNIX, principiile de bază diferă puțin, iar această prezentare va ajuta la introducerea mecanismelor de gestionare a memoriei și, dacă este necesar, la înțelegerea unei implementări specifice.

Segmente

Familia de procesoare Intel permite ca memoria să fie împărțită în mai multe părți logice numite segmente. În acest caz, spațiul de adrese de proces poate fi reprezentat sub forma mai multor segmente logice, fiecare dintre ele constând dintr-o secvență continuă de adrese situate într-un interval dat. Traducerea adreselor bazată pe segmentare
asigură o mapare neechivocă a adreselor segmentelor într-o secvență continuă
adrese fizice. Adresa virtuală este formată din două părți: selectorul de segment și
offset față de începutul segmentului. Selector(mai precis, câmpul selector INDEX) indică
un așa-numit descriptor de segment care conține parametri cum ar fi locația sa în memorie,
dimensiune și drepturi de acces. Procesorul acceptă adresarea indirectă a segmentelor prin descriptori de segment, care sunt localizați în tabele speciale - zone de memorie indicate de
registrele de procesator destinate acestui scop. Nucleul sistemului de operare este responsabil pentru popularea acestor tabele și setarea valorilor registrului. Cu alte cuvinte, nucleul stabilește maparea, iar procesorul realizează maparea în hardware. Datorită acestei adrese indirecte, segmentele logice sunt protejate unele de altele, ceea ce asigură integritatea procesului și a spațiului de adrese kernel.
Descriptorii de segment sunt localizați în două tabele de sistem - tabelul de descriptor local
(Tabel de descriptor local - LDT) și Tabelul Global Descriptor - GDT).
După cum sugerează și numele, LDT oferă traducerea adresei virtuale a segmentelor de proces,
în timp ce GDT servește spațiul de adrese kernel (de exemplu, când procesează sistemul
apel sau întrerupe). Fiecare proces are propriul LDT, în timp ce GDT
împărtășită de toate procesele. Informațiile despre tabelul către care indică selectorul se află în selectorul însuși.

1 5 3 2 1 0

INDEX

T.I.

RPL

Selector de segmente

• Camp INDEX este numărul (indexul) descriptorului din tabelul de descriptori care ar trebuiutilizat la calcularea adresei liniare.
• Pic T.I. specifică ce tabel de descriptori trebuie utilizatØ - corespunde GDT1 - corespunde LDT
• Camp RPL utilizat pentru a controla drepturile de acces la program la segment. este solicitatnivel de privilegiu și este unul dintre mecanismele de asigurare a protecției segmentelor.De exemplu, dacă un proces, în timp ce se află în modul task, încearcă să acceseze un segment,aparținând nucleului, procesorul va genera o excepție, ca răspuns la care nucleul va trimite procesului semnalul SIGSEGV.

Fiecare intrare LDT sau GDT este un descriptor de segment. Sunt definite mai multe tipuri de descriptori, utilizați pentru cod, date și segmente de stivă, precum și un număr de descriptori,
cu ajutorul căruia sunt furnizate multitasking și transferul controlului de la o sarcină neprivilegiată, de exemplu, un proces în modul task, la o sarcină privilegiată, de exemplu, nucleul.
Descriptorii utilizați în acest din urmă caz ​​se numesc porți.

Descriptorii de segment (cod, date, stivă) au mai multe câmpuri:

• Adresă de bază Acest câmp stochează adresa de 32 de biți a începutului segmentului. Procesorul se adaugă la eloffset și obține o adresă liniară de 32 de biți.
• Limită Acest câmp specifică dimensiunea segmentului. Dacă rezultatulAdresa liniară este în afara limitelor segmentului, procesorul generează o excepție.Limitele de segmente permit procesorului să detecteze erori comune, cum ar fi depășirea stivei,indicatoare incorecte, adrese de apel incorecte șitranziții. În cazul în care sistemul de operare crede căapelarea în afara segmentului nu este o eroare(de exemplu, la depășirea stivei), poate extinde segmentul prin alocarememorie suplimentară și solicitați ca comanda să fie executată din nou.
• Privilegii Acest câmp, numit Descriptor Privilege Level (DPL), definește nivelulprivilegii de segment și este utilizat împreună cu câmpul RPL al selectorului pentru a permite sau a refuza accesulla segment. Pentru a avea acces la un segment, o sarcină trebuie să aibă cel puțin același nivelprivilegii, cum ar fisegment, adică RPL DPL.
• Semn de prezenta. Acest bit oferă unul dintre mecanismele de implementare a memoriei virtuale.Dacă bitul nu este setat, atunci când încercați să accesațila segmentul procesorului generează o excepție lipsăsegment, permițând nucleului să încarce segmentul din memoria secundară și să repete instrucțiunea din nou,fără a afecta execuția procesului. Cu toate acestea, în majoritatea versiunilor moderneMemoria virtuală UNIX se bazează pe un mecanism de pagină,în care segmentul este mereu prezent în memorie, iar schimbul între operațional șiMemoria secundară apare la nivel de pagină.
• Tip Acest câmp specifică tipul de segment. Procesorul verifică tipulsegment pentru respectarea comenzii care se execută. În special, acest lucru nu ne permite să interpretăminformații despre segmentul de date ca instrucțiuni ale procesorului.
• Drepturi de acces Acest câmp definește drepturile de acces care limitează setul deoperatii care pot fi efectuate cu un segment. De exemplu,un segment de cod este de obicei marcat ca executabil și lizibil.Segmentele de date pot avea drepturi de acces numai pentru citire,sau pentru citit și scris.

Combinația dintre selector și offset formează o adresă logică. Unitate de control al memoriei procesorului
folosește un selector pentru a-și determina descriptorul corespunzător. Adăugând adresa de bază a segmentului stocat în descriptor cu offset, procesorul creează o adresă liniară. Dacă paginarea nu este utilizată, adresa liniară rezultată este cea fizică folosită pentru a accesa direct RAM. Cu toate acestea, o implementare numai pe segment a memoriei virtuale nu este suficient de flexibilă și nu este utilizată în versiunile moderne. Gestionarea memoriei în majoritatea sistemelor se bazează pe un mecanism de pagină. Segmentele sunt folosite de nucleu pentru a găzdui codul, datele și stiva de proces, fiecare cu o adresă de bază de zero și o limită de 3 GB, adică toată memoria virtuală adresabilă minus 1 GB ocupat de nucleul de sistem.
Distribuția spațiului de adrese virtuale între nucleu și procese este discutată în „”.

Mecanismul paginii

La implementarea memoriei virtuale bazate doar pe segmentare, întregul segment poate fi fie prezent în RAM, fie absent (mai precis, situat în memoria secundară sau în fișierul executabil al procesului).
Deoarece dimensiunea segmentului poate fi destul de mare, execuția simultană a mai multor procese mari va provoca o competiție severă pentru resursele de memorie, care la rândul lor
va duce la un schimb intens de date între RAM și memoria secundară. În plus, schimbul de zone de dimensiuni variabile, care sunt segmente, este destul de complex și, deși fragmentarea memoriei va fi mică, va duce la o eficiență scăzută a utilizării acesteia,
lăsând o cantitate mare de spațiu nefolosit.

Mecanismul paginii oferă o flexibilitate mult mai mare. În acest caz, întregul spațiu de adrese virtuale (4 GB pentru procesoarele Intel) este împărțit în blocuri de dimensiuni egale numite pagini. Majoritatea procesoarelor Intel operează cu pagini de 4 KB. Ca și în cazul segmentării, pagina poate fi fie prezentă în RAM,
sau să fie în zona de schimb sau în fișierul executabil al procesului. Principalul avantaj al acestei scheme este că sistemul de gestionare a memoriei funcționează pe zone destul de mici
dimensiune pentru a asigura o alocare eficientă a resurselor de memorie între procese.
Mecanismul de paginare permite ca o parte din segmente să fie în RAM și altele să lipsească. Acest lucru oferă nucleului capacitatea de a plasa în memorie doar acele pagini care sunt utilizate în prezent de proces, eliberând astfel în mod semnificativ RAM. Un alt avantaj este că paginile segmentate pot fi localizate în memoria fizică în orice locație și ordine, ceea ce permite utilizarea eficientă a spațiului liber.
Această abordare amintește de o schemă de stocare a fișierelor pe disc - fiecare fișier este format din
diverse numere de blocuri de stocare a datelor, care pot fi localizate în orice zonă liberă unitate disc. Acest lucru duce la o fragmentare semnificativă, dar îmbunătățește semnificativ eficiența spațiului pe disc.
Când se utilizează mecanismul de paginare, adresa liniară obținută prin adăugarea adresei de bază a segmentului și a decalajului este, de asemenea, o adresă logică, care este procesată suplimentar de blocul de paginare al procesorului. În acest caz, adresa liniară este considerată de procesor ca fiind formată din trei părți.

Intrare în directorul paginilor, PDE- Primul câmp de adresă, biții de la 22 la 31, indică intrarea din directorul tabelului de pagini PDE. Directorul tabelului de pagini are o lungime de o pagină și conține până la 1024 de indicatori de tabel de pagini. Deci primul câmp se adresează unui anumit tabel de pagini.
Intrare în tabelul paginilor, PTE- Al doilea câmp, ocupând biții de la 12 la 21, indică elementul tabelului de pagini RTE. Tabelele de pagini au, de asemenea, 4 KB, iar elementele tabelului se adresează unui total de 1024 de pagini. Cu alte cuvinte, al doilea câmp se adresează unei anumite pagini.
În cele din urmă, offset-ul paginii este determinat de al treilea câmp, care ocupă cei 12 biți inferiori ai adresei liniare. Astfel, cu un singur director de tabel, un proces se poate adresa

1024 x 1024 x 4096 = 4 GB memorie fizică.

Figura de mai sus arată cum unitatea de adresare a paginii a procesorului traduce o adresă liniară într-o adresă fizică. Procesorul folosește câmpul de adresă PDE (înaltă 10 biți) ca index în directorul tabelului. Găsiteelementul conține adresa tabelului de pagini. Al doilea câmp de adresă liniară PTE permite procesorului să selectezeelementul de tabel dorit care se adresează paginii fizice. Adăugarea adresei de la începutul paginii cu offset,stocat în al treilea câmp, procesorul primește o adresă fizică de 32 de biți.

Cele mai multe procesoare moderne, și în special familia de procesoare Intel, plasează datele despre ultimele pagini pe care le-au folosit într-un cache ultra-rapid. Numai când procesorul nu găsește pagina necesară în acest cache, accesează directorul și tabelele de pagini. De regulă, 99-98% dintre legăturile de adrese ajung în cache, fără a necesita traducerea adresei pentru a accesa memoria RAM, unde se află directorul și tabelele.
Fiecare element de tabel de pagină conține mai multe câmpuri care descriu diferite

caracteristicile paginii. Câmpuri PTE:

P	Un semn de prezență în RAM. Accesarea unei pagini care nu se află în memorie (P=0) provoacă o eroare a paginii, excepție despre care procesorul informează nucleul, care o gestionează în consecință.
R/V	Drepturi de a citi numai pagina (R/W=0) sau de a citi și scrie (R/W=1)
NE	Privilegii de acces. Dacă U/S=0, numai sarcini privilegiate(kernel) au acces la adresele paginilor. În caz contrar, acces lapagina are toate sarcinile.
Abordare	Adresa fizică de la începutul paginii (adresa de bază)

Spațiu de adresă de proces

Spațiul de adrese al nucleului este de obicei același cu spațiul de adrese al procesului care rulează în prezent. În acest caz, se spune că nucleul este situat în același context cu procesul. De fiecare dată când resursele de calcul sunt transferate într-un proces, sistemul se restaurează
contextul sarcinilor acestui proces, care include valorile registrelor de uz general, registrelor de segment și pointerii către tabele de pagini care mapează memoria virtuală a procesului în modul de activitate. În acest caz, contextul sistemului rămâne neschimbat pentru toate procesele. Spațiul de adrese ale procesului este prezentat în figura de mai jos.