Cursul 5: Fire de

executie (Threads)
Cursul 4: Recapitulare
• Planificator – Selecteaza dintre programele din
memorie gata de executie (cozile PCB) si aloca CPU
pentru unul dintre ele
• Modulul dispatcher ofera controlul asupra CPU
proceselor selectate de planificator; acest lucru implica:
• Schimbare de context
• Comutare in user mode
• Saltul la locatia de memorie adecvata din programul
utilizatorului pentru a reporni programul
• Criterii planificare:
• Utilizarea CPU
• Rata de transfer
• Timpul de ciclare
• Timp de asteptare
• Timp de raspuns
Cursul 4: Recapitulare

• Algoritmi de planificare:
• FCFS – batch
• SJF – TS
• Round Robin
• Multinivel (eventual multinivel cu feedback)
• Bazata pe prioritati
Definirea firelor de executie (threads)
Definitie
• Proces: Abstractizare a SO pentru a
reprezenta ceea ce este necesar pentru a rula
un singur program singlethread sau multithread
• Doua parti ale unui proces:
• [Multiple] fire de executie
• Fiecare fir de executie este un flux secvential de executie
• Resurse protejate:
• Starea memoriei principale (continutul Spatiului de Adrese)
• Starea dispozitivelor de I/E (descriptorii de fisiere)
• De ce sa separam conceptul de thread de cel
de proces?
• Gestionarea partii “thread” a proceselor
(concurenta)
• Separarea de “spatiul de adrese” (Protectie)
• “Proces Heavyweight” º Proces cu un singur thread
• Proces – abstractizeaza executia, resursele,
spatiul de adrese
• Thread – abstractizeaza executia
Procese Single/Multithread

! Thread-urile incapsuleaza executia concurenta

! Componenta “activa” a unui proces
! Spatiile de adresa încapsuleaza protectia
! Previne posibilele daune determinate de un program cu erori
! Componenta “pasiva” a unui proces
Beneficii

• Reactivitate – ex: browser-web, word

processor, etc

• Partajarea resurselor – ex: optimizare IPC

• Economie – ex: in Solaris – crearea unui

thread – de 30 de ori mai rapida, schimbarea
contextului pentru un thread de 5 ori mai rapida

• Scalabilitate – ex: utilizarea arhitecturilor cu

procesoare multiple
Clasificarea sistemelor cu
threaduri
Modele multithreading
Thread-uri Kernel
• E.g. lightweight process; thread cunoscut de
SO
• Comutarea intre thread-uri ale aceluiasi proces
presupune o comutare de context (mai rapida
decat in cazul proceselor)
• Se schimba valorile registrilor, PC, SP
• Nu se schimba info asoc spatiului de adrese comun
• Kernel gestioneaza comutarea intre thread-uri
utilizand aceeasi algoritmi ca in cazul
proceselor
Thread-uri Kernel

• Exemple de SO care le folosesc:

• Windows
• Solaris
• Linux
• Tru64 UNIX
• Mac OS X
Thread-uri utilizator
• OS nu le gestioneaza
• OS planifica procesele, nu si thread-urile din
proces
• Administrarea Thread-urilor se realizeaza cu
ajutorul librariilor thread ce ruleaza la nivel de
utilizator, fara ajutorul kernel-ului
Thread-uri utilizator
Thread-uri utilizator - Avantaje
• Nu presupune comutare de context
• Mai flexibil
• programatorul poate defini politica de planificare
• Fiecare proces poate folosi algoritmi specifici de
planificare
• Un thread poate renunta voluntar la procesor
oferind procesorul altor thread-uri din proces
• Nu presupun apeluri de sistem ci mai degraba
apeluri de librarie
• De obicei sunt mai rapide
Thread-uri utilizator -
Dezavantaje
• Nefiind cunoscute de OS; acesta poate lua
decizii mai putin eficiente
• Poate rula un proces cu thread-uri Idle
• Daca un thread user asteapta I/O atunci tot
procesul va astepta
• Presupune o comunicare intre kernel si user-level
thread manager pt a rezolva aceste probleme
• Planificarea procesului nu va tine cont de
numarul de thread-uri din proces
• Pentru thread-urile kernel – cu cat avem mai
multe thread-uri intr-un proces cu atat vom
avea mai multe cuante de timp asociate
Modelele multithreading
• Multe la Unul (Many-to-One)

• Unul la Unul (One-to-One)

• Multe la Multe (Many-to-Many)

• Model pe doua niveluri

Thread-uri Kernel si User in
Solaris
Multe la unul
• Mai multe Thread-uri de
nivel utilizator sunt
mapate la un singur
thread Kernel
• Exemple:
• Solaris Green Threads
• Thread-urile Portabile
GNU
• Avantaje
• Administrarea thread-
urilor in spatiul utilizator
• Dezavantaje
• Blocheaza intregul proces
la aparitia unui apel de
sistem blocant
• Nu exista suport pentru
multi-procesare
Unu la unu
! Fiecare thread la nivel de • Avantaje:
utilizator se mapeaza pe un • Concurenta mai buna
thread kernel • Calcul paralel
! Exemple: • Dezavantaje:
• Overhead mai mare pentru
! Windows NT/XP/2000 crearea thread-urilor kernel
odata cu cele utilizator
! Linux
• este nevoie de un mecanism
! De la Solaris 9 pana in de restrictie de volum
prezent
Multe la multe
• Permite unui grup de thread-
uri utilizator sa fie mapate cu
un grup de thread-uri Kernel
• Permite SO sa creeze un
numar suficient de thread-uri
Kernel
• Exemple
• Solaris inainte de
versiunea 9
• Windows 7, Windows
NT/2000 cu pachetul
ThreadFiber
• Avantaje:
• Prezinta toate avantajele
prezente la modelele
anterioare
• Dezavantaje:
• complexitate
 Modelul pe doua niveluri
• Permite atat
asociere M:M
cat si asociere
1:1
• Exemple:
• IRIX
• HP-UX
• Tru64 UNIX
• Solaris 8 si
versiuni
anterioare
Implementarea Thread-urilor
Pthreads
• API standard POSIX (IEEE
1003.1c) pentru crearea si
sincronizarea thread-urilor
• API specifica comportamentul
librariei thread-ului, nu impune o
implementare
• Comun in SO UNIX (Solaris, Linux,
Mac OS X)
 Pthreads
#include <pthread.h> /* get the default attributes */
#include <stdio.h> pthread_attr_init (&attr) ;
int sum; /* this data is shared by the
thread(s) */ /* create the thread */
void *runner(void *param); /* the thread */ pthread_create(&tid,&attr,runner,argv[1]);

int main(int argc, char *argv[]) /* wait for the thread to exit */
{ pthread_join (tid, NULL) ;
pthread_t tid; /* the thread identifier */
pthread_attr_t attr; /* set of thread attributes printf("sum = %d\n",sum);
*/ }

if (argc != 2) { /* The thread will begin control in this

fprintf(stderr,"usage: a.out <integer function */
value>\n"); void *runner(void *param)
return -1; {
} int i, upper = atoi(param);
sum = 0;
if (atoi(argv[1]) < 0) { for (i = 1; i <= upper; i++)
fprintf(stderr,"%d must be >= sum += i;
0\n",atoi(argv[1])); pthread_exit (0) ;
return -1; }
}
 Win32
Threads
• Vezi: Operating System
Concepts – Silberschatz
Galvin Gagne
 Java Threads
• Thread-urile Java sunt
administrate de JVM
• Thread-urile Java pot fi
create prin:
• Extinderea clasei Thread
• Implementarea interfetei
Runnable

• Vezi: Operating System

Concepts – Silberschatz
Galvin Gagne
Thread-uri Linux
• Linux refera thread-urile ca task-uri
• Crearea thread-urilor se realizeaza prin
apelul de sistem clone()
• clone() permite unui task-copil sa
impartaseasca spatiul adresa al task-ului-
parinte (procesului parinte)
Thread-uri Windows XP
• Implementeaza modelul 1:1
• Fiecare thread contine:
• Id
• Set de registri
• Stive separat utilizator si kernel
• Zona de stocare pentru date private fiecarui Thread
• Setul de registrii, stivele, si zona de stocare
pentru datele private sunt cunoscute ca si
contextul thread-urilor
Thread Pools
• Crearea anticipata a unui numar de
thread-uri care vor putea fi folosite la
nevoie
• Avantaje:
• De obicei este mai rapida procesarea unei
cereri cu un thread deja existent, fata se
situatia in care se creaza un nou thread
• Permite numarului de thread-uri din
aplicatie sa se limiteze la marimea pool-ului
Sfarsitul cursului 5