OS104

Capitolul 4: Procesele Conceptul de Proces
 Un sistem de operare execută o varietate de programe:

 Conceptul de Proces
 Sistem Batch – joburi
 Planificarea proceselor  Sisteme cu divizare a timpului (Time-shared) – programe
 Operaţii asupra proceselor utilizator sau taskuri
 Procese cooperante  Folosim termenii job şi proces aproape interschimbabil
 Comunicarea interprocese  Proces – un program aflat în execuţie; execuţia unui

proces trebuie să progreseze într-o manieră secvenţială
 Comunicarea în sisteme Client-Server
 Un proces include:
 Contor program
 Stivă
 Secţiune de date
Operating System Concepts with Java 4.1 Silberschatz, Galvin and Gagne ©2003 Operating System Concepts with Java 4.2 Silberschatz, Galvin and Gagne ©2003
Stările unui Proces Diagrama Stărilor unui Proces
 Pe măsură ce un proces se execută, el îşi schimbă starea

 new: Procesul este în proces de creare
 running: Instrucţiuni sunt executate
 waiting: Procesul aşteaptă apariţia unui anumit eveniment
 ready: Procesul aşteaptă să fie asignat unui procesor
 terminated: Procesul a terminat execuţia
Blocul de Control a unui Proces (PCB) Blocul de Control a unui Proces (PCB)
Informaţii asociate fiecărui proces

 Starea procesului
 Contor program
 Regiştri CPU
 Informaţii de planificare CPU
 Informaţii de gestionare a memoriei
 Informaţii de contare
 Informaţii de stare I/E
1
Schimbarea de Context de la un Proces la alt
Proces Cozi de Planificare a Proceselor
 Job queue – setul tuturor proceselor din sistem
 Ready queue – setul tuturor proceselor care se află în memoria
principală, pregătite de execuţie
 Device queues – setul de procese care aşteaptă după un
dispozitiv de I/E
 Procesele migrează între diferitele cozi
Coada Ready şi alte cozi ale dispozitivelor de

I/E Reprezentarea Planificării Proceselor
Planificatori Adăugarea Planificării pe Termen Mediu
 Planificator pe termen lung (sau planificatorul de job-uri) –

selectează care dintre procese ar trebui aduse în coada ready
 Planificatorul pe termen scurt (sau planificatorul de CPU) –
selectează care proces ar trebui executat şi îl alocă un CPU
2
Planificatori (Cont.) Schimbarea de Context
 Planificatorul pe termen scurt este apelat foarte frecvent  Când CPU-ul schimbă la un alt proces, sistemul trebuie să
(milisecunde)  (deci trebuie să fie foarte rapid) salveze starea vechiului proces şi să încarce starea salvată
 Planificatorul pe termen lung este apelat foarte rar (secunde, pentru noul proces
minute)  (poate fi încet)  Timpul de schimbare de context este un timp suplimentar;
 Planificatorul pe termen lung controlează gradul de sistemul nu efectuează nici o operaţie folositoare în timpul
multiprogramare comutării
 Procesele pot fi descrise ca fiind fie:  Timpul depinde de suportul hardware
 I/O-bound process (legat de I/E) – petrece mai mult timp efectuând

I/E decât calcule, multe execuţii CPU scurte
 CPU-bound process (legat de CPU) – petrece mai mult timp
efectuând calcule; câteva execuţii CPU foarte lungi
Crearea unui Proces Crearea unui Proces (Cont.)

 Procesul părinte creează procese fii, care la rândul lor creează  Spaţiul de adrese
alte procese, formând un arbore de procese  Fiul este un duplicat al părintelui
 Partajarea resurselor  Fiul are un program încărcat în el
 Părintele şi fii partajează toate resursele  Exemple UNIX
 Fii partajează un subset din resursele părintelui  apelul sistem fork creează un proces nou
 Părintele şi fii nu partajează resurse  apelul sistem exec este folosit după un fork pentru a înlocui spaţiul
 Execuţia de memorie a procesului cu un nou program
 Părintele şi fii se execută concurent
 Părintele aşteaptă până ce fiul se termină
Program C Program lansând un proces Arborele de Procese pe un sistem

separat
UNIX
#include <stdio.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
int pid;
/* lansează un alt proces */
pid = fork();
if (pid < 0) { /* a apărut o eroare */
fprintf(stderr, "Fork esuat");
exit(-1);
}
else if (pid == 0) { /* procesul fiu */
execlp("/bin/ls","ls",NULL);
}
else { /* procesul parinte */
/* parintele va astepta ca fiul sa se termine */
wait(NULL);
printf(“Fiul s-a terminat");
exit(0);
}
}
3
Terminarea unui Proces Cooperarea între Procese
 Procesul execută ultima instrucţiune şi cere sistemului de  Un proces Independent nu poate afecta sau să fie afectat de
operare să îl termine (exit) execuţia unui alt proces
 Trimite datele de la fiu la părinte (via wait)  Procese cooperante pot afecta sau să fie afectate de execuţia
 Resursele procesului sunt dealocate de către sistemul de operare unui alt proces
 Părintele poate termina execuţia proceselor fii (abort)  Avantaje ale cooperării proceselor
 Fiul a depăşit resursele alocate  Partajarea informaţiilor
 Task-ul asignat fiului nu mai este necesar  Creşterea vitezei de calcul
 Dacă părintele se termină  Modularitate
 Unele sisteme de operare nu permit ca fiii să continue dacă  Comoditate
părintele se termină
– Toţi fiii sunt terminaţi – terminare în cascadă
Problema Producător-Consumator Buffer Limitat – Soluţie cu memorie partajată
 Paradigmă pentru procese cooperante, producător produce

informaţie care este consumată de către un proces consumator public interface Buffer
 unbounded-buffer (buffer fără limită) nu pune nici o limită practică
asupra dimensiunii bufferului
{
 bounded-buffer (buffer limitat) presupune că există un buffer de // producătorii apelează această metodă
dimensiune fixă
public abstract void insert(Object item);
// consumatorii apelează această metodă
public abstract Object remove();
}
Buffer Limitat – Soluţie cu memorie partajată Buffer Limitat – Metoda Insert()

import java.util.*;
public class BoundedBuffer implements Buffer
{ public void insert(Object item) {
private static final int BUFFER SIZE = 5;
private int count; // număr de elemente din buffer while (count == BUFFER SIZE)
private int in; // arată la următoarea poziţie liberă
private int out; // arată la următoarea poziţie plină
private Object[] buffer;
; // fă nimic – nu există buffer liber
public BoundedBuffer() {
// buffer-ul este iniţial gol
// adaugă un element la buffer
count = 0;
in = 0; ++count;
out = 0;
buffer = new Object[BUFFER SIZE]; buffer[in] = item;
}
// producătorii apelează această metodă in = (in + 1) % BUFFER SIZE;
public void insert(Object item) {
// Slide-ul 4.24 }
}
// consumatorii apelează această metodă
public Object remove() {
// Slide-ul 4.25
}
}
4
Buffer Limitat – Metoda Remove() Comunicarea Interproces (IPC)
 Mecanism pentru ca procesele să comunice şi să îşi
public Object remove() { sincronizeze acţiunile
 Sistem de mesagerie – procesele comunică unele cu altele fără
Object item; să folosească variabile partajate
while (count == 0)  Facilităţile IPC oferă două operaţii:
 send(message) – dimensiunea mesajului este fixă sau variabliă
; // fă nimic – nimic de consumat
 receive(message)
// elimină un element din buffer  Dacă P şi Q doresc să comunice, ele trebuie să:
--count;  Stabilească o cale de comunicare între ele
 Interschimbe mesaje via send/receive
item = buffer[out];
 Implementarea căii de comunicare
out = (out + 1) % BUFFER SIZE;  fizică (ex., memorie partajată, magistrală hardware)
return item;  logică (ex., proprietăţi logice)
Probleme de Implementare Comunicare Directă

 Cum anume sunt stabilite căile?  Procesele trebuie să se numească explicit:
 Poate fi o cale asociată cu mai mult de două procese?  send (P, message) – trimite un mesaj procesului P
 Câte căi pot exista între fiecare pereche de procese care  receive(Q, message) – primeşte un mesaj de la procesul Q
comunică?  Proprietăţile căii de comunicare
 Care este capacitatea unei căi?  Căile sunt stabilite automat
 Este dimensiunea unui mesaj pe care calea poate să o accepte  O cale este asociată cu o singură pereche de procese care
fixă sau variabilă? comunică
 Între fiecare pereche există o singură cale
 Este o cale unidirecţională sau bidirecţională?
 Calea poate fi unidirecţională, dar de obicei este bidirecţională
Comunicare Indirectă Comunicare Indirectă

 Mesajele sunt direcţionate şi recepţionate din căsuţe
poştale (mailbox) (referite deasemenea ca şi porturi)  Operaţii
 Fiecare mailbox are un id unic  Creează un mailbox nou
 Procesele pot comunica doar dacă partajează un mailbox  Trimite şi recepţionează mesaje prin mailbox
 Proprietăţile căii de comunicare  Distruge un mailbox
 Legătura este stabilită doar dacă procesele partajează un  Primitivele sunt definite ca şi:
mailbox comun
send(A, message) – trimite un mesaj la mailbox-ul A
 O cale poate fi asociată mai multor procese
receive(A, message) – recepţionează un mesaj de la
 Fiecare pereche de procese poate partaja mai multe căi de mailbox-ul A
comunicaţie
 Calea poate fi unidirecţională sau bidirecţională
5
Comunicare Indirectă Sincronizare
 Partajarea Mailbox-ului  Trimiterea de mesaje poate fi sau cu blocare sau fără blocare
 P1, P2, şi P3 partajează mailbox-ul A  Blocarea este considerată sincronă
 P1, trimite; P2 şi P3 recepţionează  send cu blocare blochează expeditorul până ce mesajul a fost
 Cine primeşte mesajul? recepţionat
 Soluţii  receive cu blocare blochează receptorul până ce un mesaj este

disponibil
 Permite ca o cale să fie asociată cu cel mult două procese
 Fără blocare este considerat asincronă
 Permite ca doar un singur proces să poată executa o operaţie de
recepţie la un moment dat  send fără blocare permite ca expeditorul să trimită mesajul şi să
continue execuţia
 Permite ca sistemul să selecteze în mod arbitrar receptorul.
Expeditorul este notificat despre cine a recepţionat mesajul  receive fără blocare permite ca receptorul să primească un mesaj
valid sau null
Buffering Comunicare Client-Server

 O coadă de mesaje ataşat unei căi; implementat într-una din trei  Sockets
moduri  Remote Procedure Calls (Apeluri de procedură la distanţă)
1. Capacitate zero – 0 mesaje
 Remote Method Invocation (Java)
Expeditorul trebuie să aştepte pentru un receptor (rendezvous)
2. Capacitate limitată – o lungime finită de n mesaje
Expeditorul trebuie să aştepte în momentul în care calea este plină
3. Capacitate nelimitată – lungime infinită
Expeditorul nu aşteaptă niciodată
Sockets Comunicare prin Socket

 Un socket este definit ca şi un capăt de comunicare
 Este o concatenare a adresei IP şi a portului
 Socket-ul 161.25.19.8:1625 se referă la portul 1625 de pe
sistemul cu adresa IP 161.25.19.8
 Calea de comunicare constă dintr-o pereche de socket-uri şi un
protocol (TCP, UDP, ...)
6
Remote Procedure Calls
(Apeluri de Procedură la Distanţă) Execuţia RPC
 Apelul de procedură la distanţă (RPC) abstractizează apelurile
de procedură dintre procese pe sisteme legate în reţea.
 Stub – este un proxy pe parte de client (client-side proxy) pentru
procedura efectivă de pe server.
 Stub-ul de pe client localizează server-ul şi aranjează,
împachetează şi trimite parametri (marshalling).
 Stub-ul de pe server recepţionează acest mesaj, despachetează
parametri şi efectuează procedura pe server.
Remote Method Invocation Aranjarea Parametrilor (Marshalling)

 Remote Method Invocation (RMI) este un mecanism Java similar
cu RPC.
 RMI permite ca un program Java de pe o maşină să apeleze o
metodă dintr-un obiect distant.
Thread-uri Thread-uri (Cont.)

 Într-un task cu mai multe thread-uri, în timp ce un thread server
 Un thread (fir de execuţie sau proces uşor - lightweight process)
este blocat şi aşteaptă, un al doilea thread din acelaşi task
este o unitate de bază de folosire a CPU; el constă din:
poate rula.
 Contor program
 Cooperarea dintre mai multe thread-uri din acelaşi job oferă un
 Set de regiştri debit mai ridicat şi performanţe îmbunătăţite.
 Spaţiu de stivă  Aplicaţiile care necesită partajarea unui buffer comun (ex.,
 Un thread partajează cu thread-urile pereche: producător-consumator) beneficiază de pe urma folosirii thread-
urilor.
 Secţiunea de cod
 Secţiunea de date
 Thread-urile oferă un mecanism care permite ca procesele
secvenţiale să efectueze apeluri de sistem cu blocare şi în
 Resursele sistemului de operare
acelaşi timp să obţină paralelism.
În colectiv cunsocute ca şi un task.
 Thread-uri suportate de nucleu (Mach şi OS/2).
 Un proces tradiţional sau greu (heavyweight) este egal cu un
 Thread-uri de nivel utilizator; suportate deasupra nucleului,
task având un singur thread
printr-o serie de apeluri de librărie la nivel utilizator (Project
Andrew de la CMU).
 Abordarea hibridă implementează atât thread-uri de nivel
Silberschatz, Galvin and Gagne ©2003
utilizator cât şi cele suportate de nucleu (SolarisSilberschatz,
2). Galvin and Gagne ©2003
Operating System Concepts with Java 4.41 Operating System Concepts with Java 4.42
7
Thread-uri multiple dintr-un Task Suportul Thread-urilor în Solaris 2
 Solaris 2 este o versiune de UNIX care suportă thread-uri atât
la nivel de nucleu cât şi utilizator, multiprocesare simetrică şi
planificare în timp-real.
 LWP – nivel intermediar între thread-uri de nivel utilizator şi
thread-uri de nivel nucleu.
 Resurse necesare pe tipuri de thread-uri:
 Thread de nivel nucleu: o structură compactă de date şi o stivă;
comutarea între thread-uri nu necesită schimb de informaţie de
acces la memorie – relativ rapid.
 LWP: PCB cu date din regiştri, informaţii de contabilizare şi
memorie; comutarea între LWP-uri este relativ înceată.
 Thread de nivel utilizator: necesită doar contor program şi stivă;
neimplicarea nucleului înseamnă o comutare rapidă. Nucleul
vede doar LWP-urile care suportă thread-urile de nivel utilizator.
Solaris 2 Threads
Operating System Concepts with Java 4.45 Silberschatz, Galvin and Gagne ©2003

OS104

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

OS104

Încărcat de

Drepturi de autor:

Formate disponibile

Capitolul 4: Procesele Conceptul de Proces

 Un sistem de operare execută o varietate de programe:

 Procese cooperante  Folosim termenii job şi proces aproape interschimbabil

 Comunicarea interprocese  Proces – un program aflat în execuţie; execuţia unui

Stările unui Proces Diagrama Stărilor unui Proces

 Pe măsură ce un proces se execută, el îşi schimbă starea

Informaţii asociate fiecărui proces

Coada Ready şi alte cozi ale dispozitivelor de

Planificatori Adăugarea Planificării pe Termen Mediu

 Planificator pe termen lung (sau planificatorul de job-uri) –

 Procesele pot fi descrise ca fiind fie:  Timpul depinde de suportul hardware

 I/O-bound process (legat de I/E) – petrece mai mult timp efectuând

Crearea unui Proces Crearea unui Proces (Cont.)

Program C Program lansând un proces Arborele de Procese pe un sistem

Problema Producător-Consumator Buffer Limitat – Soluţie cu memorie partajată

 Paradigmă pentru procese cooperante, producător produce

Buffer Limitat – Soluţie cu memorie partajată Buffer Limitat – Metoda Insert()

return item;  logică (ex., proprietăţi logice)

Probleme de Implementare Comunicare Directă

Comunicare Indirectă Comunicare Indirectă

 Soluţii  receive cu blocare blochează receptorul până ce un mesaj este

Buffering Comunicare Client-Server

Sockets Comunicare prin Socket

Remote Method Invocation Aranjarea Parametrilor (Marshalling)

Thread-uri Thread-uri (Cont.)

S-ar putea să vă placă și