1. Programare și securitate la nivelul arhitecturii x86
Prof. dr. ing. Gheorghe Sebestyen
Cursul 7 Procese si Fire de executie (threads)

2. Definitii - Proces Proces:
Concept abstract definit de SO, ce modeleaza o aplicatie aflata in executie pe un calculator
“executie” poate fi si asteptare in vederea executiei
la aplicatiile distribuite – cate un proces pe fiecare calculator pe care ruleaza aplicatia
Proces = un program in executie + un context de executie asociat
Context:
spatiu de memorie alocat in exclusivitate,
dispozitive de I/E, intreruperi, porturi alocate temporar

3. Definitii Proces (cont.) Sisteme uniprocesor Sisteme multiprocesor
Un singur proces in executie – sistem unitasking
Mai multe procese executate in regim concurent – sistem multitasking uniprocesor
Sisteme multiprocesor
Mai multe procese executate in regim paralel si concurent; exemple
Procesoare multi-core – 2,4,8,128 UCP
Arhitecturi paralele – 2, 100, 1.000,

4. Procese – avantaje, dezavantaje
Asigura o izolare si o protectie a conextului in care se executa un program: cod, date, spatiu de memorie, dispozitive, etc.
Se pot executa mai multe taskuri/aplicatii in acelasi timp fara sa se deranjeze reciproc
SO poate tine o evidenta a aplicatiilor care sunt rulate pe un calculator – “care in ce stare este”:
In executie - run
In asteptarea unui eveniment – wait (ex. terminarea unei operatii de I/E sau a unui apel de functie sistem)
Suspendat – suspended (optional)

5. Procese – avantaje, dezavantaje
Comunicatia intre procese concurente/paralele este dificila si costisitoare ca timp
Necesita mecanisme suplimentare de obicei furnizate de SO: Pipes, socket, dendezvous
Trecerea executiei de pe un proces pe altul (comutarea de context) implica un overhead de timp semnificativ
Ex. la procesoarele x86 comutarea de context forteaza stergerea TLB (cache-ul pentru tabele de paginare)
Procese multiple duc la fragmentarea resurselor unui calculator (ex. fragmentarea memoriei)

6. Definitii - Thread Fire de executie (Threads):
Secvente de program ce se pot executa in regim concurent sau paralel
Nu au un context propriu de executie, contextul este partajat cu celelalte fire ale unui proces
Thread – “light weight process”
Avantajate de existenta mai multor core-uri sau procesoare

7. Threads – avantaje,dezavantaje
Asigura executia concurenta sau paralela a mai multor sarcini (taskuri)
Contribuie la scaderea timpului de executie in cazul sistemelor multiprocesor prin favorizarea executiei paralele
Permite descompunerea unei probleme complexe in fire de executie mai simple
Comutarea de pe un fir pe altul este mai simpla decat la procese si dureaza mai putin
Utilizarea partajata (mai eficienta) a resurselor unui calculator
Ex. un server poate deservi f. multi clienti pe fire separate

8. Threads - avantaje, dezavantaje
Nu asigura protejarea contextului de actiunea altor fire (ex. spatiului de memorie neprotejat)
Creeaza probleme de sincronizare de genul “data race” mai ales la executia paralela
Thread-safe programming – un alt stil, mai sofisticat de programare decat programarea secventiala
O eroare intr-un fir de executie face sa esueze intregul proces

9. Procese v.s. fire de executie
Proces – heavyweight unit
Resurse detinute de proces:
Spatiu de memorie
Handlere de dispozitive si de fisiere
Socket
PCB – process control block
Thread – lightweight unit
Nu dispune de resurse proprii,
le partajeaza cu celelalte fire din proces
Planificate pentru executie de SO sau explicit de programator

10. Fire de executie in spatiul user si kernel
Ambele pot fi executate (planificate pentru executie) in spatiul “kernel” sau spatiul “user”
Thread-urile din spatiul user nu sunt vazute de kernel si invers
Unui “user thread” i se asociaza pentru executie un “kernel thread”
User thread
executat in “userspace”
Cele executate pe o masina virtuala – “green threads”
Usor de creat si de distrus sau de comutat
Nu beneficiaza de capabilitatile de multithreading sau multiprocesor ale platformei !!!??? (“if a user thread or a fiber performs a system call that blocks, the other user threads and fibers in the process are unable to run until the system call returns. “)
Se suspenda daca kernel thread-ul asociat este blocat

11. Fire de executie in spatiul user si kernel
Kernel thread
Executat in kernelspace
Exista cel putin un kernel thread in fiecare proces
In cazul mai multor kernel thread-uri intr-un proces, ele pot fi planificate spre executie in mod preemtiv (cu intreruperi) sau nu (functie de tipul SO)
nu are resurse proprii decat:
Stiva proprie
Set propriu de registre interne (copii ale registrelor fizice)
Numarator de program propriu (copie)
Comutarea intre thread-uri este simpla

12. Modele de implementare
1:1
Fiecare fir din spatiul user are alocat un fir din spatiul kernel
Usor de implementat
Exemple: Win32, librarii c din Linux
N:1
Mai multe fire din spatiul user alocate la un fir din spatiul kernel
Blocarea unui fir le blocheaza pe toate
Nu beneficiaza de facilitati multithreading ale procesorului
Exemplu: GNU portable threads
N:M
Solutie hibrida
M fire utilizator mapate pe M fire kernel (sau masini virtuale)
Exemplu: Microsoft Windows

13. Cand si cum se face comutarea intre procese, fire de executie
Strategii:
“Execute to completion” – se executa pana la finalizarea secventei de program sau pana cand se asteapta un eveniment (ex. finalizarea unei anumite operatii)
Executia concurenta este mai dificila
Un fir executat la infinit fara apeluri sistem blocheaza executia celorlalte fire (pe un singur procesor)
“Time slicing” – se limiteaza timpul de executie neintrerupta a unui fir la o valoare definita de SO; dupa aceasta perioada se comuta pe un alt proces/fir aflat in asteptare (ex. Linux)
Modeleaza mai bine executia concurenta pe un singur procesor
“Priority driven” – ordinea de lansare a taskurilor este data de prioritatea pe care o au (statica sau dinamica)
“Real-time scheduling” – lansarea in executie se face de un planificator (scheduler) care tine cont de restrictiile de timp (ex. deadline) ale taskurilor – ex. SO de timp-real

14. Fibre de executie (fibers)
Unitati si mai simple de executie definite in interiorul unor thread-uri
Sunt un fel de “fire cooperante”
Sunt planificate pentru executie doar la cererea expresa a unei alte fibre
Fibra in executie trebuie sa ceara explicit comutarea pe o alta fibra
Elimina multe probleme de sincronizare aparute la threaduri
Sunt mutual excusive
Exemplu de implementare: OpenMP – mediu pentru programare paralela

15. Co-routines
Asemanatoare cu fibrele doar ca sunt definite la nivel de limbaj de programare
Fibrele sunt unitati la nivel de sistem

16. Suport pentru multitaskingSO
apeluri sistem la primitive de administrare a proceselor si firelor de executie
API-uri ale SO
Limbaje de programare
Biblioteci pentru apelarea de functii
Exemple: Java, C#, Pyton
Concurenta si paralelism explicit:
OpenMP, MPI
Verilog - limbaj ce permite un numar f. mare de fire de executie
CUDA – un set de fire de executie ce ruleaza in paralel acelasi cod pe date diferite
Thread pool – un set limitat the threaduri sunt folosite pentru executarea functiilor unei aplicatii
Limiteaza numarul de comutari de context
Numarul de thread-uri din pool este in acord cu numarul de procesoare logice de care dispune un SO
Ex: procesor quad-core cu hyperthreading este vazut ca un sistem cu 8 unitati de procesare logice

17. Suport pentru multithreading
Limbajul C - Biblioteca standard “Pthreads”
Interfata uniforma indiferent de platforma (SO)
Unix, Linux implementeaza standardul Pthreads
Java – biblioteca java.util.concurrent
Microsoft Windows – implementare proprie, functii descrise in process.h

18. Procese in limbaj de asamblare
Procese in MS-DOS
Apeluri sistem (int 21H)
AH=4Bh –
AL=0 - incarca si executa un program
DS:DX – poantor la numele programului (exe)
ES:BX – poantor la structura LOADEXEC
AL=1 – incarcare program
…..
AH=4Ch – terminare executie program
AL – cod de revenire din proces (0 - este OK)
Sursa de documentare: AoA, cap 19

19. Multitasking in Linux Starile posibile ale unui proces in Linux:
RUNNING – procesul este fie in executie, fie in asteptare pentru a fi executat
INTERRUPTIBLE – Procesul este in asteptare (sleep mode); asteapta sa fie intrerupt pentru a se trezi. Trezirea se poate face cu o intrerupere sau cu un semnal.
UN-INTERRUPTIBLE – este ca si in starea anterioara dar trezirea se face DOAR printr-un semnal.
STOPPED – procesul este oprit. Acest lucru se poate intampla daca procesul primeste semnale precum SIGSTOP, SIGTTIN etc.
TRACED – arata ca procesul este depanat. Procesul intra in aceasta stare cand este oprit de depanator.
ZOMBIE – procesul este terminat, dar ramane in tabela de procese; se asteapta ca procesul parinte sa ia cunostinta de terminare (ex. folosind o functie de tip wait())
DEAD – procesul este terminat si este eliminat din tabela de procese;

20. Linux - Crearea si terminarea proceselor
fork() – lansarea unui nou proces “copil” ca si copie a procesului parinte
Ex:
pid_t p;
p = fork();
if (p == (pid_t) -1)
/* ERROR */
else if (p == 0)
/* CHILD */
else
/* PARENT */
exit() – terminarea unui proces
Ex:
exit(n);
sau
return n;
//din procedura main a procesului copil
waitpid() Asteptarea terminarii unui proces
ex: waitpid(0, &status, ...);

21. Linux – implementarea thread-urilor
clone (flags) – creaza un thread nou:
Flagurile indica care resurse vor fi partajate de parinte si fiu si cum sa se execute noul thread
pthread_create() forma mai avansata de a creea threaduri (din biblioteca standard pthread)
Tutorial pthread (POSIX threads)

22. Procese si thread-uri in Windows
Modelul Windows de procese, fire, etc.
Aplicatie= unu sau mai multe procese
Proces = unu sau mai multe thread-uri
Thread = unitatea de baza pentru care SO aloca timp de executie pe un procesor
Job object = grup de procese care pot fi administrate ca o singura unitate
Thread pool = colectie de “worker threads” care executa eficient “asynchronous callbacks” pentru aplicatie; ajuta la administrarea firelor unei aplicatii si la reducerea numarului acestora
Fiber – unitate de executie care trebuie planificata manual de aplicatie; ruleaza in contextul thread-ului care l-a creeat si il planifica
User-mode-scheduling (UMS) – mecanism usor (lightweight) pentru planificarea in aplicatie a threadurilor proprii

23. Procese si thread-uri in Windows -detalii
Fiecare proces furnizeaza resursele necesare pentru executia programului.
Un proces are:
un spatiu virtual de memorie,
cod executabil,
handlere catre obiecte sistem,
un context de securitate,
un identificator unic de proces,
variabile de context,
o clasa de prioritate,
cel putin un fir de executie.
Fiecare proces incepe cu un singur fir de executie (numit primary thread), dar poate creea oricate fire de executie noi.

24. Procese si thread-uri in Windows - detalii
Threads:
Un thread este o entitate in cadrul unui proces care se poate planifica pentru executie.
Toate thread-urile unui proces partajeaza statiul virtual de memorie si resursele procesului de care apartin.
Fiecare thread are in plus:
Handlere de exceptii,
O prioritate la planificare,
Stocare locala asociata threadului,
Un identificator unic de thread
Structuri (de date) care permit salvarea contextului in caz de comutare de context
Contextul thread-ului contine: setul de registre generale, stiva kernel, thread environment block, stiva utilizator in spatiul de adrese al procesului
Thread-ul poate avea propriul context de securitate, ce se poate folosi pentru “depersonalizarea” clientilor.

25. Procese si thread-uri in Windows
Functii apelabile din biblioteca (API)
CreateProcess() - Creaza un proces nou si primul sau thread
CreatePipe() – creaza proces fiu cu redirectarea I/E
CreateThread() – creaza un nou thread pentru proces
CreateFiber() – creaza fibra
Exit()
Termina un proces si toate thread-urile sale
… si foarte multe alte functii
Sursa: Windows MSDN

26. Modele de implementare a aplicatiilor prin thread-uri
Modelul boss/workers
Modelul pipeline
Modelul taskului in background
Modelul interfata/implementare

27. Scrierea de cod thread-safe
Prin utilizarea mecanismelor de sincronizare:
Semafoare, mutex-uri
Solutionarea situatiilor de “data-race”
actualizarea unor variabile/obiecte partajate de mai multe threaduri