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

Responsivitate 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
Programarea Multicore

Sunt necesari algoritmi de planificare pentru

executie paralela
Provocarile programarii paralele:
Divizarea activitatilor modelare
Balansarea volumului de munca pe fiecare thread
Impartirea datelor
Dependenta datelor ex: probleme de sincronizare
Depanare si testare
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
Starile Thread-urilor Java
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
Structurile de date primare ale unui thread
includ:
ETHREAD (executive thread block)
KTHREAD (kernel thread block)
TEB (thread environment block)
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