Orice proces nou care apare în sistem intră în starea gata. Sistemul de operare, folosind un algoritm de programare, selectează unul dintre procesele gata și îl transferă în starea de execuție. În starea de execuție, codul de program al procesului este executat direct. Un proces poate părăsi această stare din trei motive:

sistemul de operare își încetează activitatea;

nu își poate continua activitatea până când nu are loc un eveniment, iar sistemul de operare îl pune în starea de așteptare;

ca urmare a unei întreruperi în sistem de calcul(de exemplu, întreruperi de la un cronometru după expirarea timpului de execuție prevăzut) este revenit la starea gata.

Din starea de așteptare, procesul intră în starea de pregătire după ce a avut loc evenimentul așteptat și poate fi selectat din nou pentru execuție.

Al nostru model nou descrie bine comportamentul proceselor în timpul existenței lor, dar nu se concentrează pe apariția unui proces în sistem și pe dispariția acestuia. Pentru a completa imaginea, trebuie să introducem încă două stări ale proceselor: nașterea și execuția terminată (vezi Fig. 2.3).

Orez. 2.3. Diagrama stării procesului adoptată în curs

Acum, pentru a apărea în sistemul de calcul, procesul trebuie să treacă prin starea de naștere. La naștere, procesul primește la dispoziție spațiul de adrese în care este încărcat cod de programare proces; i se alocă un teanc şi resursele sistemului; valoarea inițială a contorului programului acestui proces este setată, etc. Procesul născut este transferat în starea gata. La sfârşitul activităţii sale, procesul din starea de execuţie intră în starea de execuţie terminată.

În anumite sisteme de operare, stările proceselor pot fi și mai detaliate și pot apărea câteva opțiuni noi pentru tranzițiile de la o stare la alta. De exemplu, modelul stării procesului pentru sistem de operare Windows NT conține 7 diferite state, iar pentru sistemul de operare Unix - 9. Cu toate acestea, într-un fel sau altul, toate sistemele de operare se supun modelului de mai sus.

Operații pe procese și concepte aferente

Set de operații

Un proces nu poate trece de la o stare la alta de unul singur. Sistemul de operare se ocupă cu schimbarea stării proceselor prin efectuarea de operațiuni asupra acestora. Numărul de astfel de operații din modelul nostru de până acum coincide cu numărul de săgeți de pe diagrama de stare. Este convenabil să le combinați în trei perechi:

crearea procesului - finalizarea procesului;

suspendarea procesului (transferarea din starea de execuție în starea gata) – pornirea procesului (transferul din starea gata în starea de execuție);

blocare proces (transfer din starea de execuție în starea de așteptare) – deblocarea procesului (transfer din starea de așteptare în starea de pregătire).

LA Mai târziu, când vorbim despre algoritmi de programare, modelul nostru va mai avea o operație care nu are o pereche: schimbarea priorității unui proces.

Operațiunile de creare și terminare a unui proces sunt o singură dată, deoarece sunt aplicate unui proces nu mai mult de o dată (unele procese de sistem nu se termină niciodată în timpul funcționării unui sistem de calcul). Toate celelalte operațiuni legate de schimbarea stării proceselor, fie că este vorba despre pornire sau blocare, sunt de obicei reutilizabile. Să aruncăm o privire mai atentă asupra modului în care sistemul de operare efectuează operațiuni asupra proceselor.

Bloc de control al procesului și contextul procesului

Pentru ca sistemul de operare să efectueze operații asupra proceselor, fiecare proces este reprezentat în el de o structură de date. Această structură conține informații specifice procesului:

starea în care se află procesul;

contorul de program al procesului sau, cu alte cuvinte, adresa instrucțiunii care urmează să fie executată pentru acesta;

conținutul registrelor procesorului;

datele necesare pentru planificarea CPU și gestionarea memoriei (prioritatea procesului, dimensiunea spațiului de adrese și locația etc.);

acreditări ( un număr de identificare proces, care utilizator l-a inițiat, timpul total în care procesorul a fost folosit de acest proces etc.);

informatie despre dispozitiv I/O asociate cu procesul (de exemplu, ce dispozitive sunt alocate procesului, un tabel cu fișiere deschise).

Compoziția și structura sa depind, desigur, de sistemul de operare specific. În multe sisteme de operare, informațiile care caracterizează un proces sunt stocate nu într-una, ci în mai multe structuri de date aferente. Aceste structuri pot avea denumiri diferite, conțin Informații suplimentare sau, dimpotrivă, doar o parte din informațiile descrise. Pentru noi nu contează. Pentru noi, este important doar ca pentru orice proces din sistemul de calcul, toate informațiile necesare pentru a efectua operațiuni pe acesta să fie disponibile sistemului de operare. Pentru simplitate, vom presupune că este stocat într-o singură structură de date. Îl vom numi PCB (Process Control Block) sau bloc de control al procesului. Blocul de control al procesului este modelul de proces pentru sistemul de operare. Orice operație efectuată de sistemul de operare asupra unui proces cauzează anumite modificariîn PCB. În cadrul modelului de stare a procesului adoptat, conținutul PCB rămâne constant între operații.

Informațiile pe care unitatea de control al procesului este proiectată să le stocheze pot fi împărțite convenabil în două părți pentru o prezentare ulterioară. Conținutul tuturor registrelor procesorului (inclusiv valoarea contorului programului) va fi numit contextul registrului de proces și orice altceva - contextul procesului de sistem. Cunoașterea registrului și a contextelor de sistem ale unui proces este suficientă pentru a controla funcționarea acestuia în sistemul de operare prin efectuarea de operațiuni asupra acestuia. Cu toate acestea, acest lucru nu este suficient pentru a caracteriza pe deplin procesul. Sistemul de operare nu este interesat de ce fel de calcule face procesul, adică ce cod și ce date sunt în spațiul său de adrese. Din punctul de vedere al utilizatorului, dimpotrivă, conținutul spațiului de adrese al procesului prezintă cel mai mare interes, eventual, alături de contextul registrului, determinând succesiunea conversiei datelor și rezultatele obținute. Codul și datele aflate în spațiul de adrese al procesului vor fi numite context de utilizator. Setul de contexte de registru, sistem și utilizator ale unui proces se numește pur și simplu context de proces pentru concizie. În orice moment, un proces este pe deplin caracterizat de contextul său.

Operațiuni unice

Dificil drumul vietii procesul în computer începe cu nașterea sa. Orice sistem de operare care susține conceptul de procese trebuie să aibă mijloacele necesare pentru a le crea. În foarte sisteme simple(de exemplu, în sistemele concepute să funcționeze doar cu unul aplicație specifică) toate procesele pot fi generate în etapa de pornire a sistemului. Sistemele de operare mai complexe creează procese în mod dinamic după cum este necesar. Inițiatorul nașterii unui nou proces după pornirea sistemului de operare poate fi fie procesul utilizatorului care a efectuat un apel special de sistem, fie sistemul de operare însuși, adică, în cele din urmă, și un proces. Procesul care a inițiat crearea unui nou proces se numește proces părinte și, din nou, creație acest proces- proces copil. Procesele copil pot, la rândul lor, să dea naștere la noi copii etc., formând, în cazul general, în cadrul sistemului un ansamblu de arbori genealogici ai proceselor – o pădure genealogică. Un exemplu de pădure familială este prezentat în Figura 2.4. Rețineți că toate procesele utilizatorului, împreună cu unele procese ale sistemului de operare, aparțin aceluiași arbore de pădure. Într-un număr de sisteme de calcul, pădurea degenerează în general într-un astfel de copac.

Orez. 2.4. Pădurea genealogică simplificată a proceselor. Săgeata indică relația părinte-copil

Când se naște un proces, sistemul pornește un nou PCB cu starea procesului de naștere și începe să-l umple. Noul proces primește propriul său număr unic de identificare. Deoarece sistemul de operare are un număr limitat de biți pentru a stoca numărul de identificare a procesului, numărul de procese prezente simultan în el trebuie limitat pentru a menține unicitatea numerelor. După terminarea oricărui proces, numărul de identificare eliberat poate fi reutilizat pentru un alt proces.

De obicei, un proces copil necesită anumite resurse pentru a-și îndeplini funcțiile: memorie, fișiere, dispozitive I/O etc. Există două abordări pentru a le aloca. Noul proces poate pune mâna pe unele dintre resursele părintelui, eventual împărțind dreptul de proprietate asupra acestora cu procesul părinte și cu alte procese secundare, sau poate obține resursele direct de la sistemul de operare. Informațiile despre resursele alocate sunt introduse în PCB.

După ce ați dotat procesul copil cu resurse, este necesar să introduceți codul programului, valorile datelor în spațiul său de adrese și să setați contorul programului. Există și două soluții posibile aici. În primul caz, procesul copil devine un duplicat al procesului părinte în contexte de registru și utilizator și trebuie să existe o modalitate de a determina care dintre procesele gemene este părintele. În al doilea caz, procesul copil este încărcat cu un nou program dintr-un fișier. Sistemul de operare Unix permite generarea procesului doar în primul mod; pentru început program nou mai întâi trebuie să creați o copie a procesului părinte, iar apoi procesul copil trebuie să înlocuiască contextul său de utilizator cu un apel de sistem special. Sistemul de operare VAX/VMS permite doar a doua soluție. Pe Windows NT, ambele opțiuni sunt posibile (în API-uri diferite).

Generarea unui nou proces ca duplicat al procesului părinte duce la posibilitatea existenței unor programe (adică fișiere executabile) pentru care este organizat mai mult de un proces. Abilitatea de a schimba contextul utilizatorului unui proces pe măsură ce rulează (adică, încărcat pentru execuție

program nou) duce la faptul că mai multe programe diferite pot fi executate secvenţial în cadrul aceluiaşi proces.

După ce procesul este dotat cu conținut, informațiile rămase sunt adăugate la PCB și starea noului proces este schimbată în gata. Rămâne să spunem câteva cuvinte despre modul în care procesele părinte se comportă după nașterea proceselor copil. Procesul părinte își poate continua execuția în același timp cu procesul copil sau poate aștepta ca unii sau toți „copiii” săi să se finalizeze.

Nu ne vom opri asupra motivelor care pot duce la reziliere ciclu de viață proces. După ce procesul și-a încheiat activitatea, sistemul de operare îl transferă în starea de execuție terminată și eliberează toate resursele asociate cu acesta, făcând intrările corespunzătoare în blocul de control al procesului. În acest caz, PCB-ul în sine nu este distrus, ci rămâne în sistem pentru ceva timp. Acest lucru se datorează faptului că procesul părinte, după terminarea procesului copil, poate solicita sistemului de operare cauza „morții” procesului pe care l-a generat și/sau informații statistice despre funcționarea acestuia. Astfel de informații sunt stocate în PCB-ul procesului încheiat până la solicitarea procesului părinte sau până la sfârșitul activității acestuia, după care toate urmele procesului încheiat dispar în cele din urmă din sistem. În sistemul de operare Unix, procesele care sunt în starea finalizată se numesc procese zombie.

Trebuie remarcat faptul că într-o serie de sisteme de operare (de exemplu, în VAX/VMS) moartea procesului părinte duce la încetarea activității tuturor „copiilor” săi. În alte sisteme de operare (de exemplu, în Unix), procesele copil continuă să existe după terminarea procesului părinte. În acest caz, devine necesară modificarea informațiilor din PCB-ul proceselor copil despre procesul care le-a generat pentru ca pădurea genealogică a proceselor să rămână intactă. Luați în considerare următorul exemplu. Procesul numărul 2515 să fie generat de procesul numărul 2001 și după finalizarea acestuia rămâne în sistemul informatic pe termen nelimitat. Atunci este posibil ca numărul 2001 să fie reutilizat de sistemul de operare pentru un proces complet diferit. Dacă nu modificați informațiile despre procesul părinte pentru procesul 2515, atunci pădurea familiei de procese va fi incorectă - procesul 2515 va considera noul proces 2001 ca părinte, iar procesul 2001 va renega copilul neașteptat. De regulă, procesele „orfane” sunt „adoptate” de unul dintre procesele sistemului, care este generat la pornirea sistemului de operare și funcționează tot timpul în timp ce acesta rulează.

Operații reutilizabile

Operațiunile unice au ca rezultat o modificare a numărului de procese aflate sub controlul sistemului de operare și sunt întotdeauna asociate cu alocarea sau eliberarea anumitor resurse. Operațiunile reutilizabile, în schimb, nu modifică numărul de procese din sistemul de operare și nu trebuie să fie asociate cu alocarea sau eliberarea resurselor.

În această secțiune, vom descrie pe scurt acțiunile pe care sistemul de operare le efectuează atunci când efectuează operațiuni reutilizabile asupra proceselor. Aceste acțiuni vor fi discutate mai detaliat mai târziu în prelegerile corespunzătoare.

Demararea unui proces. Dintre procesele aflate în starea de pregătire, sistemul de operare selectează un proces pentru execuția ulterioară. Criteriile și algoritmii pentru o astfel de alegere vor fi discutați în detaliu în cursul 3 - „Procesele de planificare”. Pentru procesul selectat, sistemul de operare se asigură că informațiile necesare executării lui ulterioare sunt disponibile în RAM. Cum face aceasta va fi descris în detaliu în prelegerile 8-10. În plus, starea procesului este schimbată în execuție, valorile registrelor pentru acest proces sunt restaurate, iar controlul este transferat către comanda indicată de contorul de comenzi al procesului. Toate datele necesare pentru a restabili contextul sunt preluate de pe PCB-ul procesului pe care se operează.

Suspendarea procesului. Un proces care se află în stare de execuție este suspendat ca urmare a unui fel de întrerupere. Procesorul salvează automat contorul programului și, eventual, unul sau mai multe registre pe stiva procesului de execuție, apoi transferă controlul către un

la adresa procesării acestei întreruperi. Aceasta completează activitatea de gestionare a întreruperilor a hardware-ului. De adresa specificată de obicei se află una dintre părțile sistemului de operare. Salvează partea dinamică a sistemului și înregistrează contextele procesului în PCB-ul său, transferă procesul în starea gata și procedează la gestionarea întreruperii, adică la efectuarea anumitor acțiuni asociate întreruperii.

Blocarea procesului. Un proces este blocat atunci când nu poate continua fără a aștepta ca un eveniment să apară în sistemul de calcul. Pentru a face acest lucru, accesează sistemul de operare folosind un anumit apel de sistem. Sistemul de operare gestionează apelul de sistem (inițializează operația I/O, adaugă procesul la coada de procese care așteaptă eliberarea dispozitivului sau evenimentul, etc.) și, dacă este necesar, salvează partea necesară a contextul procesului în PCB-ul său, transferă procesul din starea de execuție în starea de așteptare. Această operație va fi discutată mai detaliat în capitolul 13.

Proces de deblocare. După ce apare un eveniment în sistem, sistemul de operare trebuie să determine exact ce eveniment a avut loc. Sistemul de operare verifică apoi dacă un proces a fost în starea de așteptare pentru acest eveniment și, dacă da, îl pune în starea gata executând acțiunile necesare asociat cu apariția unui eveniment (inițializarea unei operațiuni I/O pentru următorul proces de așteptare etc.). Această operație, ca și operația de blocare, va fi descrisă în detaliu în Capitolul 13.

Schimbarea contextului

Până acum, am luat în considerare operațiunile pe procese în mod izolat, independent unele de altele. În realitate, activitatea unui sistem de operare multiprogram constă în lanțuri de operații efectuate pe diverse procese și este însoțită de trecerea unui procesor de la un proces la altul.

De exemplu, să aruncăm o privire simplificată asupra modului în care operația de deblocare a unui proces care așteaptă I/O poate decurge în realitate (vezi Figura 2.5). Când procesorul execută un proces (în figură - procesul 1), apare o întrerupere de la dispozitivul I/O, semnalând sfârșitul operațiunilor pe dispozitiv. Suspendarea este efectuată pe un proces care rulează. În continuare, sistemul de operare deblochează procesul care a inițiat cererea I/O (procesul 2 din figură) și lansează procesul suspendat sau nou selectat în timpul programării (procesul deblocat a fost selectat în figură). După cum putem vedea, ca urmare a procesării informațiilor despre sfârșitul operațiunii I/O, este posibilă modificarea procesului care se află în starea de execuție.

Orez. 2.5. Efectuarea unei operații de deblocare a procesului. Utilizarea termenului „cod utilizator” nu limitează generalitatea desenului doar la procesele utilizatorului.

Pentru a comuta corect procesorul de la un proces la altul, este necesar să salvați contextul procesului care rulează și să restabiliți contextul procesului la care va fi comutat procesorul. Această procedură de salvare/restabilire a stării de sănătate a proceselor se numește comutare de context. Timpul petrecut la comutarea contextului nu este utilizat de sistemul de calcul pentru a efectua lucrări utile și reprezintă o suprasarcină care reduce performanța sistemului. Acesta variază de la o mașină la alta și, de obicei, variază de la 1 la 1000 de microsecunde. Reducerea semnificativă a supraîncărcării în sistemele de operare moderne permite un model de proces extins, care include conceptul de fire de execuție (threads de execuție sau doar fire). Despre firele de execuție vom vorbi mai mult în Lectura 4 - „Cooperarea proceselor și principalele aspecte ale organizării sale logice”.

Concluzie

Conceptul de proces caracterizează un anumit set al unui set de comenzi de execuție, resurse asociate acestuia și momentul actual al executării acestuia, care se află sub controlul sistemului de operare. În orice moment, un proces este complet descris de contextul său, care constă din registru, sistem și părți de utilizator. În sistemul de operare, procesele sunt reprezentate de o anumită structură de date - PCB, care reflectă conținutul registrului și contextul sistemului.

Procesele pot fi în cinci stări principale: naștere, pregătire, execuție, așteptare, execuție terminată. Procesul este transferat de la o stare la alta de către sistemul de operare ca urmare a operațiunilor efectuate asupra acestuia. Sistemul de operare poate efectua următoarele operații asupra proceselor: crearea unui proces, terminarea unui proces, suspendarea unui proces, pornirea unui proces, blocarea unui proces, deblocarea unui proces, modificarea priorității unui proces. Între operații, conținutul PCB nu se schimbă. Activitatea unui sistem de operare multiprogram constă în lanțuri de operațiuni enumerate efectuate pe diferite procese și este însoțită de proceduri de salvare/restabilire a stării de sănătate a proceselor, adică schimbarea contextului. Schimbarea contextului nu are nimic de-a face cu muncă utilă efectuate de procese, iar timpul petrecut cu aceasta se reduce timp util munca procesorului.

3. Prelegere: Planificarea procesului

Această prelegere tratează probleme legate de diferitele niveluri de planificare a proceselor în sistemele de operare. Sunt descrise principalele obiective și criterii de planificare, precum și parametrii pe care se bazează. Sunt dați diverși algoritmi de planificare.

Îmi plac planurile noastre uriașe...

VV Mayakovsky Cu cât ne planificăm mai atent activitățile, cu atât mai puțin timp rămâne pentru implementarea acesteia.

Din analele Comitetului de Stat de Planificare

Ori de câte ori avem de-a face cu o cantitate limitată de resurse și câțiva dintre consumatorii lor, fie că este vorba de un fond salariileîntr-un grup de lucru sau o petrecere studențească cu mai multe cutii de bere, suntem nevoiți să ne ocupăm de distribuirea resurselor disponibile în rândul consumatorilor sau, cu alte cuvinte, de planificarea resurselor. O astfel de planificare ar trebui să aibă obiective clar definite (ceea ce dorim să realizăm prin distribuirea resurselor) și algoritmi care să corespundă obiectivelor și să se bazeze pe parametrii consumatorilor. Doar cand alegerea potrivita criterii și algoritmi, puteți evita întrebări precum: „De ce primesc de zece ori mai puțin decât șeful meu?” sau "Unde este berea mea?" Această prelegere este dedicată programării execuției proceselor în sistemele de calcul multiprogram sau, cu alte cuvinte, programării proceselor.

Niveluri de planificare

În prima prelegere, având în vedere evoluția sistemelor informatice, am vorbit despre două tipuri de programare în sistemele de calcul: programarea locurilor de muncă și programarea utilizării procesorului. Programarea locurilor de muncă a apărut în sisteme de loturi după ce discurile magnetice au început să fie folosite pentru a stoca pachetele de sarcini generate. Discuri magnetice, fiind dispozitive directe

acces, permit descărcarea lucrărilor pe computer în orice ordine, nu doar în ordinea în care au fost scrise pe disc. Prin schimbarea ordinii în care joburile sunt încărcate într-un sistem informatic, este posibilă creșterea eficienței utilizării acestuia. Procedura de alegere a următoarei lucrări de încărcat în mașină, adică pentru a genera procesul corespunzător, am numit-o programarea lucrărilor. Programarea procesorului apare mai întâi în sistemele de calcul cu mai multe programe, unde mai multe procese pot fi în starea pregătită în același timp. Este pentru procedura de selectare a unui proces dintre ele, care va primi procesorul la dispoziția sa, adică va fi transferat în starea de execuție, am folosit această expresie. Acum, după ce ne-am familiarizat cu conceptul de procese în sistemele de calcul, vom lua în considerare ambele tipuri de planificare ca diverse niveluri planificarea procesului.

Programarea locurilor de muncă este utilizată ca programare pe termen lung a proceselor. Este responsabil pentru generarea de noi procese în sistem, determinând gradul său de multiprogramare, adică numărul de procese care se află simultan în el. Dacă gradul de multiprogramare al sistemului este menținut constant, adică numărul mediu de procese din computer nu se modifică, atunci procesele noi pot apărea numai după finalizarea celor încărcate anterior. Prin urmare, planificarea pe termen lung se realizează destul de rar, între apariția unor noi procese pot trece minute și chiar zeci de minute. Decizia de a alege unul sau altul proces pentru a rula are un impact asupra funcționării sistemului de calcul pentru o perioadă destul de lungă. De aici și numele acestui nivel de planificare - pe termen lung. Unele sisteme de operare au puțină sau nu au planificare pe termen lung. Deci, de exemplu, în multe sisteme interactive de partajare a timpului, un proces este generat imediat după ce apare cererea corespunzătoare. Menținerea unui grad rezonabil de multiprogramare se face prin limitarea numărului de utilizatori care pot lucra la sistem și particularitățile psihologiei umane. Dacă există un interval de 20-30 de secunde între apăsarea unei taste și apariția unui caracter pe ecran, atunci mulți utilizatori vor prefera să nu mai lucreze și să o continue atunci când sistemul este mai puțin ocupat.

Programarea procesorului este folosită ca programare pe termen scurt a proceselor. Se realizează, de exemplu, atunci când un proces în execuție accesează dispozitivele I/O sau pur și simplu după ce a trecut o anumită perioadă de timp. Prin urmare, planificarea pe termen scurt este efectuată, de regulă, cel puțin o dată la 100 de milisecunde. Alegerea unui nou proces pentru execuție afectează funcționarea sistemului până când apare următorul eveniment similar, adică pentru o perioadă scurtă de timp, care este motivul pentru denumirea acestui nivel de planificare - pe termen scurt.

În unele sisteme de calcul, poate fi avantajos să se îmbunătățească performanța prin eliminarea temporară a unui proces parțial executat de pe RAM pe disc și, ulterior, returnându-l înapoi pentru execuție ulterioară. O astfel de procedură în literatura de limbă engleză se numește swapping, care poate fi tradus în rusă ca „pumping”, deși în literatura de specialitate este folosită fără traducere - swapping. Când și care dintre procese trebuie transferat pe disc și returnat înapoi este decis de un nivel intermediar suplimentar de planificare a procesului - pe termen mediu.

Criterii de planificare și cerințe pentru algoritmi

Pentru fiecare nivel de planificare a procesului, există multe diverși algoritmi. Alegerea unui anumit algoritm este determinată de clasa de probleme rezolvate de sistemul de calcul și de obiectivele pe care dorim să le atingem prin planificare. Aceste obiective includ următoarele:

Corectitudinea este de a garanta fiecărei lucrări sau procese o anumită cantitate de timp CPU într-un sistem informatic, încercând să evite situația în care procesul unui utilizator ocupă constant procesorul în timp ce procesul altui utilizator nu a început efectiv să se execute.

Eficiență - încercați să utilizați procesorul 100% din timpul de lucru, fără a-i permite să stea inactiv în așteptarea proceselor care sunt gata de executare. În sistemele de calcul reale, sarcina procesorului variază de la 40 la 90%.

Reducerea timpului de realizare - pentru a asigura timpul minim între începerea unui proces sau punerea în coadă a unui job pentru descărcare și finalizarea acestuia.

Reduceți timpul de așteptare - Reduceți timpul pe care procesele îl petrec în starea pregătită și joburile aflate în coadă pentru descărcare.

Reducerea timpului de răspuns - Minimizați timpul necesar unui proces din sistemele interactive pentru a răspunde la o solicitare a utilizatorului.

Indiferent de obiectivele planificării, este, de asemenea, de dorit ca algoritmii să aibă următoarele proprietăți.

Erau previzibile. Aceeași sarcină ar trebui finalizată aproximativ în același timp. Aplicarea algoritmului de programare nu trebuie să conducă, de exemplu, la extragere rădăcină pătrată din 4 în sutimi de secundă la o lansare și în câteva zile la a doua lansare.

Au fost asociate cu cheltuieli generale minime. Dacă pentru fiecare 100 de milisecunde alocate unui proces pentru a utiliza procesorul, vor exista 200 de milisecunde pentru a determina ce proces va pune procesorul la dispoziție și pentru a schimba contextul, atunci un astfel de algoritm evident nu merită să fie folosit.

Încărcate uniform resursele sistemului de calcul, dând prioritate acelor procese care vor ocupa resurse subutilizate.

Erau scalabili, adică nu și-au pierdut imediat performanța atunci când sarcina a crescut. De exemplu, dublarea numărului de procese din sistem nu ar trebui să conducă la o creștere a timpului total de execuție al proceselor cu un ordin de mărime.

Multe dintre obiectivele și proprietățile de mai sus sunt contradictorii. Îmbunătățirea performanței algoritmului în ceea ce privește un criteriu, îl înrăutățim în ceea ce privește altul. Adaptând algoritmul la o clasă de probleme, discriminăm astfel problemele unei alte clase. „Nu poți să înhami un cal și o căprioară tremurândă într-o singură căruță.” Nimic de făcut. Asta-i viata.

Opțiuni de planificare

Pentru a atinge obiectivele stabilite, algoritmii de programare rezonabili ar trebui să se bazeze pe unele caracteristici ale proceselor din sistem, sarcinile din coada de descărcare, starea sistemului informatic în sine, cu alte cuvinte, pe parametrii de programare. În această secțiune, descriem o serie de astfel de parametri fără a pretinde că sunt completi.

Toți parametrii de planificare pot fi împărțiți în doi grupuri mari: parametri staticiși parametrii dinamici. Parametrii statici nu se modifică în timpul funcționării sistemului de calcul, în timp ce cei dinamici, dimpotrivă, sunt supuși unor modificări constante.

La Parametrii statici ai unui sistem de calcul pot fi atribuiți valorilor limită ale resurselor sale (dimensiunea memoriei, suma maxima spațiu pe disc pentru schimb, numărul de dispozitive conectate intrare-ieșire etc.). Parametrii dinamici ai sistemului descriu cantitatea de resurse libere per acest moment.

La Parametrii statici ai procesului includ caracteristici care sunt de obicei inerente sarcinilor aflate deja în faza de încărcare.

Care utilizator a început procesul sau a generat sarcina.

Cât de importantă este sarcina, adică care este prioritatea implementării acesteia.

Cât timp CPU este solicitat de utilizator pentru a rezolva problema.

Care este raportul dintre timpul CPU și timpul necesar pentru a efectua operațiuni intrare ieșire.

Care sunt resursele sistemului de calcul (RAM, dispozitive I/O, biblioteci speciale și programe de sistem etc.) și câte sunt necesare pentru muncă.

Algoritmii de programare pe termen lung folosesc parametrii statici și dinamici ai sistemului informatic și parametrii statici ai proceselor în activitatea lor (parametrii dinamici ai proceselor în etapa de încărcare a sarcinilor nu sunt încă cunoscuți). Algoritmi pentru planificarea pe termen scurt si mediu

În plus, calculele iau în considerare caracteristicile dinamice ale proceselor. Pentru planificarea pe termen mediu, următoarele informații pot fi utilizate ca astfel de caracteristici:

cât timp a trecut de când procesul a fost descărcat pe disc sau încărcat în Berbec;

câtă memorie RAM ia procesul;

cât timp CPU a fost deja alocat procesului.

Orez. 3.1. Fragment al activității procesului, evidențiind perioadele de utilizare continuă a procesorului și așteptarea I/O

Pentru planificarea pe termen scurt, trebuie să introducem doi parametri mai dinamici. Activitatea oricărui proces poate fi gândită ca o succesiune de cicluri de utilizare a procesorului și de așteptare pentru finalizarea operațiunilor I/O. Perioada de timp de utilizare continuă a procesorului se numește explozie CPU, iar perioada de timp de așteptare continuă pentru I/O se numește rafală I/O. Figura 3.1. un fragment al activității unui anumit proces într-un pseudo-limbaj de programare este afișat cu selecția intervalelor indicate. Pentru concizie, vom folosi termenii CPU burst și I/O burst fără traducere. Valorile duratei pentru ultimele și următoarele rafale CPU și exploziile I/O sunt importante parametrii dinamici proces.

Planificare preventivă și non-preemptivă

Procesul de programare este realizat de o parte a sistemului de operare numită planificator. Planificatorul poate decide să selecteze un nou proces dintre cele aflate în starea pregătită pentru execuție în următoarele patru cazuri.

1. Când un proces trece de la starea de rulare la starea de rulare finalizată.

2. Când un proces trece din starea de rulare în starea de așteptare.

3. Când un proces este trecut de la starea de rulare la starea de pregătire (de exemplu, după o întrerupere a temporizatorului).

4. Când procesul este transferat din starea de așteptare în starea pregătită (operația I/O sau un alt eveniment a avut loc). Procedura pentru un astfel de transfer a fost discutată în detaliu în Lectura 2 (secțiunea „Schimbarea contextului”), unde am arătat de ce acest lucru ridică posibilitatea de a schimba un proces care se află în starea de execuție.

LA În cazurile 1 și 2, procesul care se afla în starea de execuție nu mai poate fi executat, iar sistemul de operare este forțat să efectueze planificarea prin alegerea unui nou proces pentru execuție. În cazurile 3 și 4, planificarea poate fi sau nu efectuată, planificatorul nu este neapărat obligat să decidă asupra alegerii procesului de execuție, procesul care se afla în starea de execuție pur și simplu își poate continua munca. Dacă sistemul de operare efectuează doar programarea în situații forțate, se spune că este programare nonpreemptivă. Dacă planificatorul ia atât decizii forțate, cât și neforțate, se vorbește de planificare preventivă. Termenul „programare preventivă” a apărut deoarece un proces care rulează poate fi forțat să iasă din starea de execuție de către un alt proces împotriva voinței sale.

Programarea non-preemptivă este utilizată, de exemplu, în MS Windows 3.1 și OS Apple Macintosh. În acest mod de programare, procesul necesită atât timp CPU cât are nevoie. În acest caz, comutarea procesului are loc numai atunci când procesul de execuție însuși dorește să transfere controlul (pentru a aștepta finalizarea unei operațiuni I/O sau la sfârșitul lucrului). Această metodă de programare este relativ ușor de implementat și destul de eficientă, deoarece vă permite să alocați cea mai mare parte a timpului procesorului pentru lucrul proceselor în sine și să minimizați costul comutării contextului. Cu toate acestea, cu programarea non-preemptivă, apare problema posibilității de a capta complet procesorul de către un proces, care, dintr-un anumit motiv (de exemplu, din cauza unei erori în program), face bucle și nu poate transfera controlul unui alt proces. . Într-o astfel de situație, doar repornirea întregului sistem informatic salvează.

Programarea preventivă este folosită în mod obișnuit în sistemele de partajare a timpului. În acest mod de programare, procesul poate fi suspendat în orice moment în timpul execuției. Sistemul de operare setează un cronometru special pentru a genera un semnal de întrerupere după un anumit interval de timp - un cuantum. După întrerupere, procesorul este transferat la următorul proces. Întreruperile temporare ajută la asigurarea unor timpi acceptabili de răspuns al procesului pentru utilizatorii interactivi și previn „blocarea” sistem informatic datorită unui program în buclă.

Algoritmi de planificare

Există un set destul de mare de diverși algoritmi de programare care sunt proiectați pentru a atinge diferite obiective și sunt eficienți pentru diferite clase de probleme. Multe dintre ele pot fi utilizate la mai multe niveluri de planificare. În această secțiune, vom analiza unii dintre cei mai comuni algoritmi aplicați procesului de programare pe termen scurt.

Primul venit, primul servit (FCFS)

Cel mai simplu algoritm de programare este algoritmul, care este de obicei notat cu abrevierea FCFS după primele litere ale acestuia. nume englezesc- Primul venit, primul servit (primul venit, primul servit). Imaginați-vă că procesele care sunt în starea pregătită sunt aliniate. Când un proces intră în starea gata, el, sau mai degrabă, o referință la PCB-ul său, este plasată la sfârșitul acestei cozi. Alegerea unui nou proces pentru execuție se efectuează de la începutul cozii cu eliminarea unei referințe la PCB-ul său de acolo. O coadă de acest tip are un nume special în programare

- FIFO1), prescurtare pentru First In, First Out (primul intrat, primul ieşit).

Acest algoritm de selecție a procesului implementează programarea non-preemptivă. Un proces care are la dispoziție un procesor îl păstrează până la expirarea exploziei curente a procesorului. După aceea, un nou proces din capul cozii este selectat pentru execuție.

Tabelul 3.1.

Avantajul algoritmului FCFS este ușurința sa de implementare, dar în același timp are multe dezavantaje. Luați în considerare următorul exemplu. Fie trei procese p0 , p1 și p2 să fie în starea pregătită, pentru care se cunosc timpii următoarelor explozii CPU. Acești timpi sunt prezentati în Tabelul 3.1. în unele unităţi arbitrare. Pentru simplitate, vom presupune că toată activitatea procesului este limitată la utilizarea unei singure rafale CPU, că procesele nu efectuează operațiuni I/O și că timpul de schimbare a contextului este atât de mic încât poate fi neglijat.

Dacă procesele sunt situate în coada de procese gata de execuție, în ordinea p0 , p1 , p2 , atunci imaginea execuției lor arată ca cea prezentată în Figura 3.2. Primul proces care urmează să fie executat este p0, care primește procesorul pe întreaga durată a exploziei CPU, adică timp de 13 unități de timp. După finalizarea acestuia, procesul p1 este transferat în starea de execuție, ia procesorul timp de 4 unități de timp. Și, în sfârșit, procesul p2 are oportunitatea de a funcționa. Timeout pentru procesul p0 este 0

Administrarea procesului

În sala de operație sistem UNIX procesele sunt create prin apelarea unei funcții de sistem kernel numită fork(). Când această funcție este apelată de un proces, sistemul de operare se execută următoarele acțiuni[BACH86].

1. Aloca spațiu în tabelul de procese pentru noul proces.

2. Atribuie un ID unic acestui proces.

3. Creează o copie a imaginii procesului părinte, excluzând zonele de memorie partajată.

4. Crește contoarele pentru toate fișierele deținute de procesul părinte pentru a reflecta faptul că noul proces deține și acele fișiere.

5. Atribuie procesului o stare gata de rulare.

Returnează ID-ul procesului copil procesului părinte și returnează 0 procesului copil.

Poate că această metodă de creare a proceselor este dificil de vizualizat deoarece atât procesele părinte, cât și cele secundare efectuează aceeași trecere de cod în momentul creării. Ele diferă prin valoarea returnată de funcția fork (): dacă este zero, atunci acesta este un proces copil. Astfel, este posibilă lansarea unei comenzi de ramificare care va determina executarea programului copil sau ramura principală să continue execuția.

REZUMAT, ÎNTREBĂRI CHEIE ȘI CONTROL

Elementul fundamental al sistemelor de operare moderne este procesul. Funcția principală a sistemului de operare este de a crea, gestiona și încheia procese. Sistemul de operare trebuie să se asigure că fiecărui proces activ i se alocă timp pentru a rula pe procesor, să coordoneze activitățile proceselor, să rezolve situațiile de conflict și să aloce resursele sistemului proceselor.

Pentru ca sistemul de operare să poată gestiona procesele, menține o descriere a fiecărui proces sau o imagine a procesului. Imaginea procesului include spațiul de adrese în care rulează procesul și blocul de control al procesului. Blocul de control conține toate informațiile de care sistemul de operare are nevoie pentru a controla procesul, inclusiv starea lui curentă, resursele alocate, prioritatea și alte date necesare.

În timpul existenței sale, un proces se poate muta de la o stare la alta. Cele mai importante dintre toate stările sunt starea pregătită, starea de rulare și starea blocată. Un proces gata de rulare este un proces care nu rulează în prezent, dar poate începe să se execute imediat ce sistemul de operare îi oferă controlul. Un proces care rulează este un proces care rulează în prezent pe procesor. Într-un sistem multiprocesor, mai multe procese pot fi în această stare simultan. Un proces blocat este unul care așteaptă să apară un eveniment, cum ar fi finalizarea unei operațiuni I/O.

Executarea proceselor este întreruptă din când în când. Întreruperea apare fie din cauza unui eveniment extern procesului, care este recunoscut de procesor, fie din cauza unui apel la programul de control al sistemului de operare. În oricare dintre aceste cazuri, procesorul trece la un alt mod de operare și controlul este transferat la o subrutină a sistemului de operare. După îndeplinirea funcțiilor sale, sistemul de operare poate continua execuția procesului întrerupt sau poate trece la execuția unui alt proces.

Termeni cheie

Preemption Interrupt Cuvânt de stare program

Procesul secundar Stare de blocare privilegiată

Încheierea stării de execuție a modului de proces

Starea de pregătire a procesului de muncă

Capcană modul Kernel Stare nouă de proces

Imagine de proces Starea procesului părinte

Schimbarea proceselor suspendate

Comutarea modului Modul sistem bloc de control

Pista de proces în modul utilizator

întrebări de test

3.1. Ce este o urmă de proces?

3.2. Ce evenimente creează procese?

3.3. Da scurta descriere fiecare stare care apare în modelul de procesare prezentat în fig. 3.3.

3.4. Ce este preempțiunea procesului?

3.5. Ce este swap și când este folosit?

3.6. De ce în fig. 3.6.6 sunt două stări blocate?

3.7. Enumerați patru caracteristici ale proceselor suspendate.

3.8. Pentru ce obiecte suportă sistemul de operare tabele cu informații de control?

3.9. Enumerați trei categorii generale de informații într-un bloc de control al procesului.

3.10. De ce avem nevoie de două moduri de procesor (modul utilizator și modul kernel)?

3.11. Ce acțiuni întreprinde sistemul de operare când este creat un nou proces?

3.12. Care este diferența dintre o întrerupere obișnuită și o capcană?

3.13. Dați trei exemple de întreruperi.

Care este diferența dintre comutarea modului procesorului și comutarea procesului?

Materialul acestui capitol este prezentat în manualele prezentate în Secțiunea 2.9. O descriere a managementului proceselor în sistemul de operare UNIX poate fi găsită în și . Se discută stările proceselor și ale primitivelor sistemului de operare utilizate în dispecerarea proceselor.

BINE94 Goodheart B., Soh J. Grădina magică explicată: elementele interne ale UNIX System V Versiunea 4.- Englewood Cliffs, NJ: Prentice Hall, 1994.

GREY97 gri J. Comunicarea între procese în UNIX: The Nooks and Crannies.- Upper Saddle River, NJ: Prentice Hall, 1997.

NEHM75 Nehmer J. Dispatcher Primitive for the Construction of sistem de operare Sâmburi. - Acta Informatica, vol. 5, 1975.

SARCINI

Care sunt cele cinci funcții principale ale sistemului de operare în managementul proceselor; justifica in in termeni generali nevoia lor.

3.1. Stările de proces sunt definite ca rulare, gata de rulare, blocate și suspendate. Un proces este într-o stare blocată dacă așteaptă permisiunea de a utiliza o resursă; Un proces este suspendat dacă așteaptă ca o resursă pe care a trimis deja o solicitare să o utilizeze să devină liberă. În multe sisteme de operare, aceste două stări sunt combinate într-una singură și sunt numite starea blocată. În acest caz, definiția stării suspendate este aceeași cu cea utilizată în acest capitol. Comparați beneficiile utilizării acestor două seturi de stări.

3.2. Desenați o diagramă folosind cozi pentru modelul cu șapte stări prezentat în Figura 1. 3.6.6. Ca bază, luați diagrama prezentată în fig. 3.5.6.

3.3. Luați în considerare diagrama de tranziție a stărilor prezentată în fig. 3.6.6. Să presupunem că este timpul ca sistemul de operare să schimbe procesele. Să presupunem că avem procese atât în ​​starea gata, cât și în stare suspendată, gata de execuție. În plus, de către macar unul dintre procesele suspendate gata de rulare are prioritate față de prioritatea oricărui proces în starea gata. Puteți proceda conform uneia dintre următoarele două strategii.

1. Selectați întotdeauna un proces în starea gata pentru a continua schimbarea la minimum.

2. Acordați întotdeauna preferință unui proces cu o prioritate mai mare, chiar dacă aceasta necesită schimbare, ceea ce nu este necesar.

Sugerați o strategie intermediară care încearcă să echilibreze conceptele de prioritate și performanță.

3.5. În tabel. 3.13 arată stările de proces utilizate în sistemul de operare VAX/VMS.

A. Puteți găsi o scuză pentru a avea așa ceva un numar mare diferite stări de așteptare?

b. De ce nu există versiuni rezidente și suspendate ale stărilor, cum ar fi așteptarea încărcării unei pagini în memoria principală, așteptarea ca un conflict de acces la pagină să fie rezolvat, așteptarea unui eveniment partajat, așteptarea unei pagini libere și așteptarea unei resurse .

în. Desenați o diagramă de tranziție de stare și indicați pe ea acțiunea sau evenimentul care duce la fiecare dintre tranzițiile descrise.

Tabelul 3.13. Starile procesului în sistemul de operare VAX/VMS

proces care rulează

Executabil (rezident) Un proces gata de rulare care se află în memoria principală

Executabil (paginat) Proces gata de rulare, paginat din memoria principală

Starea de așteptare

încărcare pagină Un proces a accesat o pagină care nu se află în memoria principală și trebuie să aștepte ca aceasta să fie citită

Starea de așteptare

rezolvarea conflictului

acces la pagină Un proces a accesat o pagină partajată pe care un alt proces așteaptă deja să o încarce sau o pagină personală care este în prezent citită sau scrisă

Starea de așteptare

eveniment partajat Așteptați ca un steag de eveniment partajat să treacă (steaguri de eveniment sunt mecanisme de semnalizare pe un singur bit de la un proces la altul)

Starea de așteptare

pagină liberă Procesul așteaptă adăugarea unei pagini de memorie principală liberă la setul de pagini alocate acesteia și aflate în memoria principală (setul de lucru al procesului).

Starea de somn Un proces se pune în stare de somn

(rezident)

starea de somn

(descărcat) Un proces de repaus este descărcat din memoria principală

În așteptarea localnicilor

evenimente (rezident) Procesul se află în memoria principală așteaptă să apară un eveniment local (de obicei, evenimentul este o finalizare I/O)

În așteptarea localnicilor

eveniment (schimbat) Un proces care așteaptă un eveniment local a fost schimbat din memoria principală

Suspendat

(rezident) Un proces care a fost pus în stare de așteptare de către un alt proces

Suspendat

(paginat) Un proces suspendat este schimbat din memoria principală

Așteptând o resursă Un proces care așteaptă ca o resursă de sistem să îi fie acordată.

Dezvoltarea unui algoritm și a unui program pentru calcularea unei funcții date interval pe diferite intervale. Algoritm și program pentru formarea unui tablou unidimensional conform unei condiții specificate interval la intervale diferite. Rezolvarea unei ecuații neliniare.

Introducere în funcționalitate și structura logica subsisteme de control al proceselor cu multitasking non-preemptive și durată cuantică constantă. Luarea în considerare a regulilor de lucru și GUI Programe de procesare administrator.

Memorie partajată. Semafoare. cozile de mesaje. Structuri de date utilizate pentru a organiza cozile de mesaje. Canale de programe. Socket-uri software (socket-uri). Una dintre posibilele configurații de socket software. Fluxuri.

Funcții interfata software Sistem de operare Windows conceput pentru a funcționa cu semafoare. Instrumente de sincronizare Win32 API bazate pe utilizarea obiectelor sistemului executiv cu mânere. Probleme la utilizarea semaforelor.

Lucrul cu procese. Trucuri de bază. Acest articol vorbește despre lucrul cu procese, module, heap-uri și fire de execuție folosind biblioteca TOOLHELP Processes, threads, modules, heaps, toolhelp, tlhelp.

Interacțiunea modulelor, utilizare apeluri de sistemși funcțiile bibliotecii managementul proceselor și fișierelor sistemelor de operare moderne. Exemple de creare a sistemului și programe personalizate, proceduri și funcții pe exemplul sistemului de operare al familiei UNIX/Linux.

Una dintre metodele de organizare a calculului paralel este o metodă bazată pe principiul controlului fluxului de date.

Luarea în considerare a modalităților de vizualizare a stării proceselor prin intermediul managerului de activități din sala de operație sistem Windows: determinarea relației dintre procese și fire de execuție, timpul de funcționare al sistemului în modul personalizat. Aflați mai multe despre fișierele driverului.

Universitatea de Stat din Daghestan. Facultatea de Matematică. Departamentul de Informatică și Inginerie Calculatoare. Munca de absolvent pe tema „Dezvoltare

Analiza sarcinilor și dezvoltarea algoritmului. Principiile de bază ale creării unui program. Diagrama interacțiunii dintre Procesul 1 și Procesul 4, în modul task și în modul kernel. Listarea și testarea programelor. Rezultatul muncii și execuției programului în consolă.

Pe scurt, noul model de memorie vă permite să rulați un număr aproape nelimitat de procese și sunt alocați 2 GB pentru fiecare proces. memorie virtuala.

Conceptul OS. Funcțiile de bază ale sistemului de operare. Un sistem de operare este de obicei înțeles ca un set de programe de control care acționează ca o interfață între hardware-ul computerului și sunt concepute pentru cel mai mult utilizare eficientă resursele sistemului de calcul, organizarea unui calcul fiabil. Oricare dintre componentele programului...

Schema și parametrii de bază ai elementelor circuitului. Ieșirea sistemului ecuatii diferentiale. Implementarea algoritmului într-un limbaj de programare nivel inalt Pascal. Rezolvarea ecuațiilor diferențiale în pachetul MathCAD. Soluție de interpolare în pachet Excel.

Procesați ca o instanță a unui program executabil, structura acestuia și elementele de bază în Windows. Numirea de fire și fibre. Ordinea creării și încheierii proceselor, dezvoltarea și distrugerea firelor și fibrelor. Modalități de a efectua munca unui fir, funcții de așteptare.

Este necesar să se facă distincția între procesele de gestionare a sistemului care reprezintă munca supervizorului sistemului de operare și se ocupă de alocarea și gestionarea resurselor din toate celelalte procese: procesele de procesare a sistemului care nu sunt incluse în nucleul sistemului de operare și procesele utilizatorului. Pentru procesele de control al sistemului din majoritatea sistemelor de operare, resursele sunt alocate inițial și fără ambiguitate. Aceste procese gestionează resursele sistemului pentru care există concurență între toate celelalte procese. Prin urmare, execuția programelor de control al sistemului nu este de obicei numită procese. Termenul sarcină poate fi folosit numai în legătură cu procesele utilizatorului și procesele de procesare a sistemului. Cu toate acestea, acest lucru nu este valabil pentru toate sistemele de operare. De exemplu, în așa-numitele sisteme de operare „microkernel” (sistemul de operare în timp real QNX din sistemele Quantum Software poate fi citat ca exemplu), majoritatea controlului module software sistemul de operare în sine și chiar driverele au statutul de procese cu prioritate ridicată, pentru care este necesar să se aloce resurse adecvate. În mod similar, în sistemele UNIX, execuția modulelor programului de sistem are și statutul de procese de sistem care primesc resurse pentru execuția lor.

Dacă generalizăm și luăm în considerare nu numai sistemul de operare convențional scop general, dar și, de exemplu, un OS în timp real, atunci putem spune că procesul poate fi într-o stare activă și pasivă (neactivă). LA stare activă un proces poate participa la competiție pentru utilizarea resurselor sistemului de calcul și, într-un mod pasiv, este cunoscut doar de sistem, dar nu participă la competiție (deși existența sa în sistem este asociată cu asigurarea acestuia cu operațiuni și// sau memorie externa). La randul lui, proces activ poate fi într-una din următoarele stări:

• împlinire- toate resursele solicitate de proces sunt alocate. Un singur proces poate fi în această stare la un moment dat dacă vorbim despre un sistem informatic cu un singur procesor;
• pregătirea pentru implementare- se pot asigura resurse, atunci procesul va intra in starea de executie;
• blocare sau așteptare- Resursele solicitate nu au putut fi furnizate sau operațiunea I/O nu a fost finalizată.

Pe majoritatea sistemelor de operare ultimul stat, la rândul său, este subdivizată într-un set de stări de așteptare corespunzătoare unui anumit tip de resursă, din cauza absenței cărora procesul intră într-o stare blocată.

În sistemele de operare convenționale, de regulă, un proces apare la lansarea unui program. Sistemul de operare organizează (apare sau alocă) un descriptor de proces adecvat (a se vedea mai multe despre acesta mai târziu) pentru un nou proces, iar procesul (sarcina) începe să se dezvolte (se rulează). Prin urmare, nu există o stare pasivă. Într-un sistem de operare în timp real (RTOS), situația este diferită. De obicei, la proiectarea unui sistem în timp real, compoziția programelor (sarcinilor) care vor trebui efectuate este deja cunoscută dinainte. Sunt cunoscuți și mulți dintre parametrii acestora, care trebuie luați în considerare la alocarea resurselor (de exemplu, dimensiunea memoriei, prioritatea, timpul mediu de execuție, fișierele deschise, dispozitivele utilizate etc.). Prin urmare, pentru ei sunt creați în prealabil descriptori de sarcini pentru a nu pierde timp prețios ulterior organizând descriptorul și găsirea resurselor necesare pentru acesta. Astfel, în RTOS, multe procese (sarcini) pot fi într-o stare de inactivitate, pe care am afișat-o în Fig. 1.3, separând această stare de restul statului printr-o linie punctată.

În timpul existenței sale, un proces poate face în mod repetat tranziții de la o stare la alta. Acest lucru se datorează apelurilor către sistemul de operare cu solicitări de resurse și execuție. funcțiile sistemului, pe care sistemul de operare le oferă, interacțiunea cu alte procese, apariția semnalelor de întrerupere de la temporizator, canale și dispozitive I/O, precum și alte dispozitive. Tranziții posibile procesele de la o stare la alta sunt afișate sub formă de gri])a stări în Fig. 1.3. Să luăm în considerare aceste tranziții de la o stare la alta mai detaliat.

Un proces poate trece din starea inactiv în starea pregătită în următoarele cazuri:

• la comanda operatorului (utilizatorului). Apare în acele sisteme de operare interactive în care programul poate avea statutul unei sarcini (și poate fi pasiv în același timp), și nu doar executabilși obțineți statutul sarcinii doar pe durata execuției (cum se întâmplă în majoritatea sistemelor de operare moderne pentru PC);
• atunci când este selectat din coadă de către planificator (tipic pentru sistemele de operare care rulează în modul lot);
• printr-un apel de la o altă sarcină (prin apelarea supervizorului, un proces poate crea, iniția, suspenda, opri, distruge un alt proces);
• prin întrerupere de la un dispozitiv de inițiativă externă 1 (un semnal despre finalizarea unui eveniment poate începe sarcina corespunzătoare);

1 Dispozitivul este apelat "proactivă" dacă, la un semnal de cerere de întrerupere, o anumită sarcină ar trebui pornită de la acesta.

• când sosește ora programată de începere a programului.

Orez. 1.3. Graficul stării procesului

Ultimele două moduri de pornire a unei sarcini, în care procesul trece de la starea inactivă la starea pregătită, sunt tipice pentru sistemele de operare în timp real.

Un proces care poate rula imediat ce i se oferă un procesor și, pentru sarcini rezidente pe disc pe unele sisteme, RAM, este într-o stare gata. Se consideră că unui astfel de proces i-au fost deja alocate toate resursele necesare cu excepția procesorului.

Un proces poate ieși din starea de rulare din unul dintre următoarele motive:

• procesul este încheiat, în timp ce acesta transferă controlul către sistemul de operare apelând supervizorul și raportează finalizarea acestuia. Ca urmare a acestor acțiuni, supervizorul fie îl transferă în lista de procese inactive (procesul intră într-o stare pasivă), fie îl distruge (în mod firesc, nu programul în sine este distrus, ci sarcina care i-a corespuns). executarea unui program). Procesul poate fi comutat forțat în starea inactiv: la comanda operatorului (efectul acestei comenzi și a altor comenzi ale operatorului este implementat proces de sistem, care „traduce” comanda într-o cerere către supervizor cu o solicitare de a pune procesul specificat într-o stare inactivă), sau prin apelarea supervizorului sistemului de operare dintr-o altă sarcină cu o solicitare de a opri acest proces;
• procesul este transferat de către supervizorul sistemului de operare în starea de pregătire pentru execuție din cauza apariției unei sarcini cu prioritate mai mare sau datorită sfârșitului intervalului de timp alocat acestuia;
• procesul este blocat (pus în stare de așteptare) fie pentru că a solicitat o operație I/O (care trebuie finalizată înainte de a putea continua execuția), fie pentru că nu poate fi furnizată cu resursa solicitată în acest moment(motivul transferului în starea de așteptare poate fi și absența unui segment sau a unei pagini în cazul organizării mecanismelor de memorie virtuală, vezi secțiunea „Organizarea memoriei segment, pagină și segment-pagină” din Capitolul 2), precum și ca la comanda operatorului de a suspenda sarcina sau la cerere prin supervizor de la o alta sarcina.
• când are loc evenimentul corespunzător (o operație I/O este finalizată, resursa solicitată este eliberată, pagina necesară a memoriei virtuale este încărcată în RAM etc.), procesul este eliberat și transferat în starea de pregătire pentru execuție.

Astfel, evenimentele sunt forța motrice care schimbă starea proceselor. Unul dintre principalele tipuri de evenimente este întreruperile.