Managementul proceselor (calcul) - Process management (computing)

Un proces este un program în execuție. O parte integrantă a oricărui sistem de operare modern (SO). Sistemul de operare trebuie să aloce resurse proceselor , să permită proceselor să partajeze și să schimbe informații, să protejeze resursele fiecărui proces de alte procese și să permită sincronizarea între procese. Pentru a îndeplini aceste cerințe, sistemul de operare trebuie să mențină o structură de date pentru fiecare proces, care descrie starea și proprietatea resurselor acestui proces și care permite sistemului de operare să exercite controlul asupra fiecărui proces.

Multiprogramare

În orice sistem de operare modern, pot exista mai multe instanțe ale unui program încărcat în memorie în același timp. De exemplu, mai mulți utilizatori ar putea executa același program, fiecare utilizator având copii separate ale programului încărcate în memorie. Cu unele programe, este posibil să aveți o copie încărcată în memorie, în timp ce mai mulți utilizatori au acces partajat la acesta, astfel încât fiecare să poată executa același cod de program. Se spune că un astfel de program este reintroducător . Procesorul în orice moment poate fi doar executa o instrucțiune de la un program , dar mai multe procese pot fi susținute pe o perioadă de timp , prin atribuirea fiecărui proces la procesor , la intervale de timp ce restul devin inactive temporar. Un număr de procese care se execută pe o perioadă de timp în loc de în același timp se numește execuție concurentă .

Un sistem de operare multiprogramare sau multitasking este un sistem care execută simultan mai multe procese. Multiprogramarea necesită ca procesorul să fie alocat fiecărui proces pentru o perioadă de timp și să fie alocat la un moment adecvat. Dacă procesorul este delocalizat în timpul execuției unui proces, acesta trebuie făcut în așa fel încât să poată fi repornit ulterior cât mai ușor posibil.

Există două modalități posibile pentru ca un SO să recâștige controlul procesorului în timpul execuției unui program pentru ca SO să efectueze alocarea sau alocarea:

  1. Procesul emite un apel de sistem (uneori numit întrerupere de software ); de exemplu, apare o cerere de I / O care solicită accesarea unui fișier de pe hard disk.
  2. Se produce o întrerupere hardware ; de exemplu, o tastă a fost apăsată pe tastatură sau un cronometru se termină (utilizat în multitasking preventiv ).

Oprirea a unui proces și de pornire (sau repornirea) a unui alt proces este numit un comutator de context sau de schimbare de context. În multe sisteme de operare moderne, procesele pot consta din multe subprocese. Aceasta introduce conceptul de fir . Un fir poate fi privit ca un sub-proces ; adică o secvență separată, independentă de execuție în cadrul codului unui proces. Subiectele devin din ce în ce mai importante în proiectarea sistemelor distribuite și client-server și în software rulat pe sisteme cu mai multe procesoare .

Cum multiprogramarea crește eficiența

O trăsătură comună observată între procesele asociate cu cele mai multe programe de calculator, este faptul că acestea alternează între CPU cicluri și I / O cicluri. Pentru partea din timpul necesar ciclurilor CPU, procesul este în curs de executare; adică ocupă CPU. În timpul necesar ciclurilor I / O, procesul nu folosește procesorul. În schimb, fie așteaptă să efectueze intrare / ieșire, fie efectuează de fapt intrare / ieșire. Un exemplu în acest sens este citirea sau scrierea pe un fișier de pe disc. Înainte de apariția multiprogramării , computerele funcționau ca sisteme cu un singur utilizator. Utilizatorii unor astfel de sisteme au devenit rapid conștienți de faptul că, în mare parte din timpul în care un computer a fost alocat unui singur utilizator, procesorul a fost inactiv; când utilizatorul introduce informații sau depanează programe de exemplu. Informaticienii au observat că performanța generală a mașinii ar putea fi îmbunătățită lăsând un proces diferit să utilizeze procesorul ori de câte ori un proces aștepta intrarea / ieșirea. Într-un sistem uni-programare , dacă N utilizatori ar trebui să execute programe cu timpi de execuție individuali de t 1 , t 2 , ..., t N , atunci timpul total, t uni , pentru a deservi N procesele (consecutiv) tuturor N utilizatori ar fi:

t uni = t 1 + t 2 + ... + t N .

Cu toate acestea, deoarece fiecare proces consumă atât cicluri CPU cât și cicluri I / O, timpul pe care fiecare proces îl folosește de fapt CPU este o fracțiune foarte mică din timpul total de execuție al procesului. Deci, pentru procesul i :

t i (procesor) t i (execuție)

Unde

t i (procesor) este timpul pe care îl petrec i procesorul, iar
t i (execuția) este timpul total de execuție pentru proces; adică timpul pentru ciclurile CPU plus ciclurile I / O care trebuie efectuate (executate) până la finalizarea procesului.

De fapt, de obicei suma tuturor timpului procesorului, utilizată de N procese, rareori depășește o mică parte din timp pentru a executa oricare dintre procese;

Prin urmare, în sistemele uni-programare, procesorul rămâne inactiv pentru o proporție considerabilă din timp. Pentru a depăși această ineficiență, multiprogramarea este acum implementată în sistemele de operare moderne, cum ar fi Linux , UNIX și Microsoft Windows . Acest lucru permite procesorului să treacă de la un proces, X, la altul, Y, ori de câte ori X este implicat în faza I / O a execuției sale. Deoarece timpul de procesare este mult mai mic decât timpul de execuție al unui singur job, timpul total pentru deservirea tuturor utilizatorilor N cu un sistem multiprogramare poate fi redus la aproximativ:

t multi = max ( t 1 , t 2 , ..., t N )

Crearea procesului

Sistemele de operare au nevoie de câteva modalități de a crea procese. Într-un sistem foarte simplu conceput pentru a rula doar o singură aplicație (de exemplu, controlerul într-un cuptor cu microunde), este posibil ca toate procesele care vor fi vreodată necesare să fie prezente la instalarea sistemului. Cu toate acestea, în sistemele cu scop general, este necesar un fel de a crea și a termina procesele după cum este necesar în timpul funcționării.
Există patru evenimente principale care determină crearea unui proces:

  • Inițializarea sistemului.
  • Executarea apelului de sistem de creare a procesului de către un proces în curs de executare.
  • O cerere de utilizator pentru a crea un nou proces.
  • Inițierea unui loc de muncă în serie.

Când este pornit un sistem de operare, de obicei sunt create mai multe procese. Unele dintre acestea sunt procese de prim plan, care interacționează cu un utilizator (uman) și efectuează lucrări pentru ei. Altele sunt procese de fundal , care nu sunt asociate cu anumiți utilizatori, dar au în schimb o anumită funcție specifică. De exemplu, un proces de fundal poate fi conceput pentru a accepta e-mail-urile primite, dormind cea mai mare parte a zilei, dar brusc prindând viață când ajunge un e-mail primit. Un alt proces de fundal poate fi conceput pentru a accepta o cerere primită pentru paginile web găzduite pe aparat, trezindu-se atunci când sosește o cerere de deservire a acestei cereri.

Crearea proceselor în UNIX și Linux se face prin apeluri de sistem fork () sau clone (). Există mai mulți pași implicați în crearea proceselor. Primul pas este validarea dacă procesul părinte are autorizație suficientă pentru a crea un proces. După validarea cu succes, procesul părinte este copiat aproape în întregime, cu modificări doar la ID-ul procesului unic, procesul părinte și spațiul utilizatorului. Fiecare proces nou primește propriul spațiu de utilizator.

Încetarea procesului

Există multe motive pentru încheierea procesului:

  • Problemele de muncă în lot opresc instruirea
  • Utilizatorul se deconectează
  • Procesul execută o cerere de serviciu pentru a termina
  • Eroare și condiții de eroare
  • Finalizare normală
  • Limita de timp a fost depășită
  • Memorie indisponibilă
  • Încălcarea limitelor; de exemplu: încercarea de acces a celui de-al 11-lea element (inexistent) al unui tablou de 10 elemente
  • Eroare de protecție; de exemplu: încercare de scriere în fișier numai în citire
  • Eroare aritmetică ; de exemplu: încercarea de divizare cu zero
  • Depășirea timpului; de exemplu: procesul așteptat mai mult decât un maxim specificat pentru un eveniment
  • Eșec I / O
  • Instrucțiuni nevalide; de exemplu: când un proces încearcă să execute date (text)
  • Instructiune privilegiata
  • Utilizarea greșită a datelor
  • Intervenția sistemului de operare ; de exemplu: pentru a rezolva un impas
  • Părintele se încheie astfel încât procesele copilului să se termine (încetare în cascadă)
  • Cerere părinte

Model de gestionare a proceselor în două state

Sistemul de operare e responsabilitatea principală este în controlul executării proceselor . Aceasta include determinarea tiparului de intercalare pentru execuția și alocarea resurselor proceselor. O parte a proiectării unui sistem de operare este de a descrie comportamentul pe care am dori să îl prezinte fiecare proces. Cel mai simplu model se bazează pe faptul că un proces fie este executat de un procesor, fie nu este. Astfel, un proces poate fi considerat a fi în una din cele două stări, RUNNING sau NU RUNNING . Atunci când sistemul de operare creează un nou proces, acel proces este inițial etichetat ca NOT RUNNING și este plasat într-o coadă în sistem în starea NOT RUNNING . Procesul (sau o parte a acestuia) există apoi în memoria principală și așteaptă în coadă să fie executată o oportunitate. După o anumită perioadă de timp, procesul RUNNING curent va fi întrerupt și mutat din starea RUNNING în starea NOT RUNNING , făcând procesorul disponibil pentru un proces diferit. Porțiunea de expediere a sistemului de operare va selecta apoi, din coada proceselor NOT RUNNING , unul dintre procesele de așteptare pentru a fi transferat la procesor. Procesul ales este apoi reetichetat de la o stare NOT RUNNING la o stare RUNNING și executarea acestuia fie începe dacă este un proces nou, fie este reluată dacă este un proces care a fost întrerupt într-o perioadă anterioară.

Din acest model putem identifica câteva elemente de design ale sistemului de operare:

  • Nevoia de a reprezenta și de a urmări fiecare proces.
  • Starea unui proces.
  • Queueing de FUNCTIONARE NON procese

Model de gestionare a proceselor în trei state

Deși modelul de management de proces cu două state este un design perfect valabil pentru un sistem de operare, lipsa unui BLOCATE mijloc de stat că procesorul se află inactiv atunci când activ își schimbă procesul de la ciclurile procesorului la I / O cicluri. Acest design nu utilizează eficient procesorul. Modelul de gestionare a proceselor în trei stări este conceput pentru a depăși această problemă, prin introducerea unui nou stat numit stat BLOCAT . Această stare descrie orice proces care așteaptă să aibă loc un eveniment I / O. În acest caz, un eveniment I / O poate însemna utilizarea unui dispozitiv sau a unui semnal din alt proces. Cele trei stări din acest model sunt:

  • RUNNING: Procesul care se execută în prezent.
  • GATA: Un proces care este în așteptare și pregătit să se execute atunci când li se oferă oportunitatea.
  • BLOCAT: Un proces care nu se poate executa până când nu are loc un eveniment, cum ar fi finalizarea unei operații de I / O.

În orice moment, un proces se află într-una și numai una dintre cele trei stări. Pentru un computer cu un singur procesor, un singur proces poate fi în starea RUNNING în orice moment. Pot exista multe procese în stările GATA și BLOCATE și fiecare dintre aceste stări va avea o coadă asociată pentru procese.

Procesele care intră în sistem trebuie să intre inițial în starea READY , procesele pot intra doar în starea RUNNING prin starea READY . În mod normal, procesele părăsesc sistemul din starea RUNNING . Pentru fiecare dintre cele trei stări, procesul ocupă spațiu în memoria principală. În timp ce motivul majorității tranzițiilor dintr-un stat în altul ar putea fi evident, este posibil ca unele să nu fie atât de clare.

  • RUNNING → GATA Cel mai frecvent motiv pentru această tranziție este că procesul de rulare a atins timpul maxim admis pentru executarea neîntreruptă; adică are loc un time-out. Alte motive pot fi impunerea nivelurilor de prioritate determinate de politica de planificare utilizată pentru programatorul de nivel scăzut și sosirea unui proces cu prioritate mai mare în starea READY.
  • RUNNING → BLOCKED Un proces este pus în starea BLOCKED dacă solicită ceva pentru care trebuie să aștepte. O cerere către sistemul de operare este, de obicei, sub forma unui apel de sistem (adică un apel de la procesul de rulare la o funcție care face parte din codul sistemului de operare). De exemplu, solicitarea unui fișier de pe disc sau salvarea unei secțiuni de cod sau date din memorie într-un fișier de pe disc.

Descrierea și controlul procesului

Fiecare proces din sistem este reprezentat de o structură de date numită Process Control Block (PCB) sau proces descriptor în Linux , care îndeplinește aceeași funcție ca și pașaportul unui călător. PCB conține informații de bază despre job, inclusiv:

  • Ce este
  • Unde merge
  • Cât din procesarea sa a fost finalizată
  • Unde este stocat
  • Cât a „cheltuit” în utilizarea resurselor

Identificarea procesului : fiecare proces este identificat în mod unic prin identificarea utilizatorului și un indicator care îl conectează la descriptorul său.

Stare proces : Aceasta indică starea curentă a procesului; GATA , RUNGING , BLOCKED , GATA SUSPEND , BLOCKED SUSPEND .

Stare proces : Acesta conține toate informațiile necesare pentru a indica starea curentă a lucrării.

Contabilitate : Aceasta conține informații utilizate în principal în scopuri de facturare și pentru măsurarea performanței. Acesta indică ce tip de resurse a utilizat procesul și pentru cât timp.

Moduri procesor

Procesoarele contemporane încorporează un bit de mod pentru a defini capacitatea de execuție a unui program în procesor. Acest bit poate fi setat la modul kernel sau la modul utilizator . Modul kernel este, de asemenea, denumit în mod obișnuit modul supervizor , modul monitor sau soneria 0 .

În modul kernel, procesorul poate executa fiecare instrucțiune din repertoriul său hardware, în timp ce în modul utilizator, poate executa doar un subset de instrucțiuni. Instrucțiunile care pot fi executate numai în modul kernel se numesc kernel, instrucțiuni privilegiate sau protejate pentru a le distinge de instrucțiunile mod utilizator. De exemplu, instrucțiunile I / O sunt privilegiate. Deci, dacă o aplicație Execută programul în modul utilizator, acesta nu poate efectua propria I / O . În schimb, trebuie să solicite sistemului de operare să efectueze I / O în numele său.

Arhitectura de calculator se poate extinde în mod logic , bitul mod pentru a defini zone de memorie pentru a fi utilizate atunci când procesorul este în modul kernel față de modul de utilizare. Dacă bitul de mod este setat la modul kernel, procesul care se execută în procesor poate accesa fie nucleul, fie partiția utilizator a memoriei. Cu toate acestea, dacă modul utilizator este setat, procesul poate face referire doar la spațiul de memorie al utilizatorului. Ne referim frecvent la două clase de spațiu de memorie pentru utilizator și spațiu de sistem (sau nucleu, supraveghetor sau spațiu protejat). În general, bitul de mod extinde drepturile de protecție ale sistemului de operare. Bitul de mod este setat de instrucțiunea de captare a modului de utilizator, numită și instrucțiune de supraveghere . Această instrucțiune setează bitul de mod și se ramifică într-o locație fixă ​​în spațiul sistemului. Deoarece numai codul de sistem este încărcat în spațiul sistemului, numai codul de sistem poate fi invocat printr-o capcană. Când sistemul de operare a finalizat apelul de supraveghere, acesta resetează bitul de mod la modul utilizator înainte de returnare.

Conceptul sistemului Kernel

Părțile sistemului de operare esențiale pentru funcționarea sa corectă se execută în modul kernel , în timp ce alte programe (cum ar fi software-ul generic de sistem) și toate programele de aplicații se execută în modul utilizator . Această distincție fundamentală este, de obicei, distincția irefutabilă dintre sistemul de operare și alte software-uri ale sistemului . Partea sistemului care se execută în starea de supraveghere a nucleului se numește nucleul sau nucleul sistemului de operare . Nucleul funcționează ca un software de încredere, ceea ce înseamnă că atunci când a fost proiectat și implementat, acesta a fost destinat să implementeze mecanisme de protecție care nu puteau fi schimbate în mod ascuns prin acțiunile unui software care nu este de încredere care se execută în spațiul utilizatorului. Extensiile la sistemul de operare se execută în modul utilizator , astfel încât sistemul de operare nu se bazează pe corectitudinea acelor părți ale software-ului sistemului pentru o funcționare corectă a sistemului de operare. Prin urmare, o decizie de proiectare fundamentală pentru orice funcție care trebuie încorporată în sistemul de operare este dacă aceasta trebuie să fie implementată în nucleu. Dacă este implementat în kernel, acesta se va executa în spațiul kernel (supervizor) și va avea acces la alte părți ale kernel-ului. De asemenea, va fi un software de încredere de către celelalte părți ale nucleului. Dacă funcția este implementată pentru a se executa în modul utilizator , nu va avea acces la structurile de date ale nucleului. Cu toate acestea, avantajul este că va necesita în mod normal un efort foarte limitat pentru a invoca funcția. În timp ce funcțiile implementate în nucleu pot fi ușor de implementat, mecanismul de captare și autentificarea la momentul apelului sunt de obicei relativ costisitoare. Codul kernelului rulează rapid, dar există o cheltuială mare de performanță în apelul propriu-zis. Acesta este un punct subtil, dar important.

Solicitarea serviciilor de sistem

Există două tehnici prin care un program care se execută în modul utilizator poate solicita serviciile nucleului :

Sistemele de operare sunt proiectate cu una sau alta dintre aceste două facilități, dar nu ambele. În primul rând, presupunem că un proces de utilizator dorește să invoce o anumită funcție de sistem țintă. Pentru abordarea apelului de sistem , procesul utilizatorului folosește instrucțiunea trap. Ideea este că apelul de sistem ar trebui să pară un apel de procedură obișnuită către programul de cerere; sistemul de operare oferă o bibliotecă de funcții ale utilizatorului cu nume corespunzătoare fiecărui apel efectiv de sistem. Fiecare dintre aceste funcții stub conține o capcană pentru funcția OS. Când programul de aplicație apelează stub, acesta execută instrucțiunea trap, care comută CPU în modul kernel și apoi se ramifică (indirect printr-o tabelă OS), la punctul de intrare al funcției care urmează să fie invocată. Când funcția se finalizează, comută procesorul în modul utilizator și apoi returnează controlul procesului utilizatorului; simulând astfel o revenire normală a procedurii.

În abordarea de transmitere a mesajelor , procesul utilizatorului construiește un mesaj, care descrie serviciul dorit. Apoi folosește o funcție de trimitere de încredere pentru a transmite mesajul către un proces de încredere al sistemului de operare . Funcția de trimitere are același scop ca și capcana; adică verifică cu atenție mesajul, comută procesorul în modul kernel și apoi livrează mesajul către un proces care implementează funcțiile țintă. Între timp, procesul utilizatorului așteaptă rezultatul cererii de serviciu cu o operațiune de primire a mesajului. Când procesul de operare finalizează operațiunea, acesta trimite un mesaj înapoi procesului utilizatorului.

Distincția dintre două abordări are consecințe importante în ceea ce privește independența relativă a comportamentului sistemului de operare, față de comportamentul procesului de aplicare și performanța rezultată. De regulă, sistemul de operare bazat pe o interfață de apel de sistem poate fi mai eficient decât cele care necesită schimbul de mesaje între procese distincte. Acesta este cazul, chiar dacă apelul de sistem trebuie să fie implementat cu o instrucțiune trap; adică, chiar dacă capcana este relativ costisitoare de realizat, este mai eficientă decât abordarea transmiterii mesajelor, unde există, în general, costuri mai mari asociate cu multiplexarea proceselor , formarea mesajelor și copierea mesajelor. Abordarea apelului de sistem are proprietatea interesantă că nu există neapărat vreun proces de sistem de operare. În schimb, un proces care se execută în modul utilizator se schimbă în modul kernel când execută codul kernel și revine în modul utilizator când revine din apelul OS. Dacă, pe de altă parte, sistemul de operare este conceput ca un set de procese separate, este de obicei mai ușor să îl proiectați astfel încât să obțină controlul mașinii în situații speciale, decât dacă nucleul este pur și simplu o colecție de funcții executate de utilizatori procesele în modul kernel. Chiar și sistemul de operare bazat pe proceduri consideră de obicei necesar să includă cel puțin câteva procese de sistem (numite demoni în UNIX ) pentru a gestiona situația în care mașina este altfel inactivă, cum ar fi programarea și gestionarea rețelei.

Vezi si

Referințe

Surse

  • Sistem de operare care încorporează Windows și UNIX, Colin Ritchie. ISBN   0-8264-6416-5
  • Sisteme de operare, William Stallings, Prentice Hall, (ediția a IV-a, 2000)
  • Multiprogramare, descriere și control al procesului
  • Sisteme de operare - O perspectivă modernă, Gary Nutt, Addison Wesley, (ediția a II-a, 2001).
  • Modele de gestionare a proceselor, programare, versiunea 4 UNIX System V:
  • Sisteme de operare moderne, Andrew Tanenbaum, Prentice Hall, (ediția a II-a, 2001).
  • Conceptele sistemului de operare, Silberschatz & Galvin & Gagne ( http://codex.cs.yale.edu/avi/os-book/OS9/slide-dir/ ), John Wiley & Sons, (ediția a 6-a, 2003)