Programare și securitate la

nivelul arhitecturii x86

Prof. dr. ing. Gheorghe Sebestyen

Cursul 7 Procese si Fire de executie

(threads)
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
Definitii
 Proces (cont.)
 Sisteme uniprocesor
 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, 1.000.000
Procese – avantaje, dezavantaje
 Avantaje:
 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)
Procese – avantaje, dezavantaje
 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)
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
Threads – avantaje,dezavantaje
 Avantaje:
 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
Threads - avantaje, dezavantaje
 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
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
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
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
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
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
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
Co-routines
 Asemanatoare cu fibrele doar ca sunt
definite la nivel de limbaj de
programare
 Fibrele sunt unitati la nivel de sistem
Suport pentru multitasking
 SO
 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
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
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
http://www.planetpdf.com/codecuts/pdfs/aoa.pdf
 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;
Linux - Crearea si terminarea
proceselor
 fork() – lansarea unui  exit() – terminarea unui
nou proces “copil” ca proces
si copie a procesului
parinte
 Ex:
exit(n);
 Ex:
sau
pid_t p;
return n;
p = fork();
if (p == (pid_t) -1) //din procedura main a procesului copil
/* ERROR */  waitpid() Asteptarea
else if (p == 0)
terminarii unui proces
/* CHILD */
else ex: waitpid(0, &status, ...);
/* PARENT */
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)
http://homes.di.unimi.it/~boccignone/GiuseppeBo
ccignone_webpage/MatDidatSOD2009_files/pthrea
d-Tutorial.pdf
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
Procese si thread-uri in
Windows -detalii
 Procese:
 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.
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.
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 https://msdn.microsoft.com/en-
us/library/windows/desktop/ms684841%28v=vs.85%29.aspx
Modele de implementare a
aplicatiilor prin thread-uri
 Modelul boss/workers
 Modelul pipeline
 Modelul taskului in background
 Modelul interfata/implementare
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