CURS 5 – SISTEME DE OPERARE

FIRE DE EXECUTIE
PROGRAMARE CONCURENTA
 Notiunea de fir de executie
 Avantajele utilizarii firelor
 Tipuri de fire
 Modele de implementare a firelor
 Fork, Exec şi fire, terminare fire
 Laborator
 Bibliografie
CE ESTE UN PROCES ?

Entitate dinamica - unitate de lucru a

unui sistem de calcul, contine un
program, mentine o serie date care
formeaza starea procesului,
si care executa în mod secvential
instructiunile programului asociat.
CE ESTE UN FIR?

Unitate de executie din cadrul unui

proces care executa secvential
instructiunile unei functii.

Un proces contine cel putin un fir de

executie – firul principal, care
executa functia main().
PROCESE CU UN FIR
PROCESE CU MAI MULTE FIRE
 PROCESE CU MAI MULTE FIRE

Printing Thread

Editing Thread
AVANTAJELE UTILIZARII FIRELOR

 Viteza de reactie
 Partajarea resourselor
 Economie
 Utilizare eficienta a platformei
hardware
FIRE USER MODE
 Gestiunea firelor este realizata în cadrul unei
biblioteci cu functii ce ruleaza în user mode

Exemple de biblioteci de fire

• POSIX, ISO/IEEE standard
• Mach C threads, CMU
• Sun OS LWP threads, Sun Microsystems
• PARAS CORE threads, C-DAC
• Java-Threads, Sun Microsystems
• Chorus threads, Paris
• OS/2 threads, IBM
• Windows NT/95 threads, Microsoft
BILIOTECA PTHREADS

• POSIX standard (IEEE 1003.1c) API

pentru crearea firelor şi sincronizare
• Prezenta in sisteme UNIX (Solaris, Linux,
Mac OS X)
 PROGRAMARE CU FIRE
printing()
{
- - - - - - - - - - - -
}
editing()
{
- - - - - - - - - - - -
}
main()
{
- - - - - - - - - - - -
id1 = pthread_create(printing);
id2 = pthread_create(editing);
pthread_join(id1);
pthread_join(id2);
}
SERVERE CU FIRE

Client Process
Server
Threads

Client Process

User Mode

Kernel Mode
Message Passing
Facility
FIRE KERNEL MODE

 Toate operatiile cu fire sunt iplementate în

kernel

 Exemple
 Windows XP/2000
 Solaris
 Linux (task)
 Tru64 UNIX
 Mac OS X
MODELE DE MULTITHREADING

• Many-to-One

• One-to-One

• Many-to-Many

• Hibrid
MANY TO ONE

Mai multe fire din user-mode sunt

gestionate ca un singur fir din kernel
mode

Exemple:
Solaris Green Threads
GNU Portable Threads
MANY TO ONE
ONE TO ONE

Fiecare fir din aplicatie corespunde unui

fir din kernel

Exemple:
Windows NT/XP/2000
Linux(clone)
Solaris 9 şi urmatoarele
ONE TO ONE
MANY TO MANY

Mai multe fire din user mode sunt

gestionate de mai multe fire din kernel

SO creaza un numar suficient de fire

Windows NT/2000 cu suport de Fibre

MANY TO MANY
MODEL HIBRID

Similar cu M:M, dar permite legarea unui fir user

mode de un fir din kernel

Exemple
IRIX
HP-UX
Tru64 UNIX
Solaris 8 şi mai vechi
MODEL HIBRID
FORK, EXEC ŞI TERMINARE

Un proces cu mai multe fire apeleaza fork:

-Se copiaza toate firele
-Se copiaza doar firul care a apelat fork

Terminare:
1. Imediata – termina firul imediat
2. Intarziata – permite firului sa verifice
periodic conditia de oprire şi daca
aceasta se schimba atunci firul se poate
opri într-un mod coerent
LABORATOR
1. #include <pthread.h>

2. pthread_t tid;
3. pthread_attr_t attr; //optional

4. int pthread_create( pthread_t * tid,

const pthread_attr_t *attr,
void *(*start_func)(void*),
void * arg);

Returneaza un numar intreg: ENOMEM (memorie),

EINVAL (attr – invalid), EPERM (permisiuni)
LABORATOR
1. pthread_t pthread_self(void);

2. int pthread_join(pthread_t tid, void **value_ptr);

3. int pthread_cancel(pthread_t tid);
EXEMPLU CU DOUA FIRE
#include <pthread.h>
using namespace std;

void * writer (void * arg) {

while (1) { cout<<“writer ”<<(int)pthread_self()<<endl;
sleep(1);
}
return NULL;
}
void * reader (void * arg) {
while (1) { cout<< “reader ”<<(int)pthread_self()<<endl;
sleep(1);
}
return NULL;
}
EXEMPLU, CONTINUARE
int main(void)
{
pthread_t tid_1, tid_2;

pthread_create(&tid_1, NULL, reader, NULL);

pthread_create(&tid_2, NULL, writer, NULL);
//------------------------------------------
pthread_join(tid_1, 0);
pthread_join(tid_2, 0);

return 0;
}
BIBLIOGRAFIE

 An Introduction to Programming with

Threads, Andrew D. Birrell

 Silberschatz A., Galvin P.B. and Gagne G.

(2005). Operating Systems Concepts, 7th
edn. John Wiley & Sons
DACA EXISTA INTREBARI?

Multumim