Tema 1

Laborator PATR 2011-2012

Data predarii temei: 2.04.2012

Studenti:
1. Iorga Dan
2. Cherciu Claudiu

Grupa:
333AB
333AB

Adresa e-mail:
iorgadan90@yahoo.com
cherciu_claudiu@yahoo.com

Observatii:

Grila punctaj
1. Prezentarea problemei propuse spre rezolvare si explicarea abordarii pentru rezolvarea
temei
2. Analiza problemei si evidentierea activitatilor care trebuie abordate in cadrul solutiei
3. Definirea taskurilor care compun aplicatia
4. Prezentarea solutiei de implementare organigramele taskurilor
5. Descrierea modului de sincronizare si evidentierea mecanismelor de sincronizare a
taskurilor
6. Explicarea alegerii solutiei (de ce nu ati utilizat alte mecanisme de sincronizare /
comunicare). Explicarea modului de implementare ce ati ales (procese sau fire de
executie) si de ce?
7. Explicarea modului in care utilizam mecanismele QNX pentru implementarea solutiei
propuse
8. Prezentarea programului complet (sub QNX) care implementeaza solutia pentru problema
propusa (listing) explicatie si comentarii
9. Prezentarea si analiza rezultatelor obtinute prin executia programului
TOTAL:

2p
1p
1p
1p
1p
1p
1p
1p
1p
10 p

Cuprins

TEMA NR_TEMA.............................................................................................................................1
1. PREZENTAREA PROBLEMEI PROPUSE.............................................................................................3
2. ANALIZA PROBLEMEI....................................................................................................................3
3. DEFINIREA TASKURILOR................................................................................................................3
4. PREZENTAREA SOLUTIEI DE IMPLEMENTARE.................................................................................3
5. DESCRIEREA MODULUI DE SINCRONIZARE....................................................................................3
6. EXPLICAREA ALEGERII SOLUTIEI..................................................................................................3
7. MECANISMELE QNX PENTRU IMPLEMENTAREA SOLUTIEI............................................................3
8. PREZENTAREA PROGRAMULUI.......................................................................................................3
9. REZULTATELOR OBTINUTE PRIN EXECUTIA PROGRAMULUI...........................................................3
ANEXA LISTING PROGRAM.............................................................................................................4

1. Prezentarea problemei propuse

Se considera simularea activitatii intr-o benzinarie:
A) Cu o singura pompa, la care sosesc clienti, si formeaza o coada de asteptare, in ordinea
sosirii. Cand pompa este libera, primul client din coada incepe sa alimenteze, apoi merge
la casier, sa achite benzina. Abia apoi casierul poate elibera pompa, urmatorul client
fiind liber sa alimenteze, reluandu-se ciclul.
B) Asemanator, pentru mai multe pompe, se formeaza la fiecare cate o coada, dar de
aceasta data se poate forma inca o coada la casier, daca acesta nu este liber.

2. Analiza problemei
Pt a reprezenta fiecare pompa am folosit un semafor care se initializeaza cu numarul total de
pompe. Pentru a reprezenta faptul ca avem un singur casier, folosim un mutex. Astfel, nu vor plati
doi clienti in acelasi timp, ci asteapta eliberarea casierului.
Pentru a simula timpul de alimentare, am folosit comanda sleep, iar timpii de alimentare
pentru fiecare client l-am memorat intr-un vector.

3. Definirea taskurilor
Avem doua tipuri de threaduri: unul care simuleaza activitatea unui client si altul care
reprezinta activitatea unui casier. Threadurile pentru clienti sunt lansate toate in acelasi timp.

4. Prezentarea solutiei de implementare

Un client verifica daca are o pompa libera (verifica semaforul), ocupa pompa
(decrementeaza semaforul) si apoi alimenteaza pentru o perioada de timp (asteapta, cu functia
sleep). Apoi verifica daca este casierul liber (verifica mutexul corespunzator), si executa threadul
care simuleaza casierul.

Proce
s:

P(S)
slee
p
slee
p
slee
p
slee
p
slee
p
P(M)

P(S)
slee
p
P(M)

P(S)
slee
p
slee
p
slee
p
slee
p
slee
p
slee
p
P(M)

casi
er
V(M
)
V(S)

P(S)

slee
p
slee
p
casi slee
er p
V(M P(M)

casi
er
V(M
)
V(S)
3

...

P(S)

)
V(S)

casi slee
er p
V(M P(M)
)
V(S)
casi
er
V(M
)
V(S)

5. Descrierea modului de sincronizare

Pentru a reprezenta numarul de pompe am folosit un semafor, initializat cu numarul de
pompe, iar pentru reprezentarea unui singur casier am folosit un mutex.

6. Explicarea alegerii solutiei

Am ales un semafor deoarece numarul de pompe este mare (am fi putut folosi si un vector
de mutexuri, dar aceasta solutie ni s-a parut mai eleganta). Am folosit un mutex pentru a reprezenta
starea casierului deoarece exista un singur casier. Daca am fi avut mai multi casieri, am fi putut
folosi alt semafor, asemanator ca pentru pompe.

7. Mecanismele QNX pentru implementarea solutiei

Am folosit mecanisme POSIX: semafoare, mutex-uri, threaduri.

8. Prezentarea programului
In urma executarii programului am obtinut rezultate plauzibile si o ordine corecta a
succesiunii timpilor de alimentare.

9. Rezultatele obtinute prin executia programului

Clientul alimenteaza 4 timpi
Clientul alimenteaza 1 timpi
Clientul alimenteaza 6 timpi
Casierul a eliberat o pompa
Clientul alimenteaza 4 timpi
Casierul a eliberat o pompa
4

Clientul alimenteaza 9 timpi

Casierul a eliberat o pompa
Clientul alimenteaza 4 timpi
Casierul a eliberat o pompa
Clientul alimenteaza 6 timpi
Casierul a eliberat o pompa
Clientul alimenteaza 8 timpi
Casierul a eliberat o pompa
Clientul alimenteaza 2 timpi
Casierul a eliberat o pompa
Clientul alimenteaza 9 timpi
Casierul a eliberat o pompa
Casierul a eliberat o pompa
Casierul a eliberat o pompa
Main: toate taskurile s-au terminat ... exit ...

Anexa listing program

#include
#include
#include
#include
#include

<stdio.h>
<unistd.h>
<pthread.h>
<semaphore.h>
<stdlib.h>

#define nrPompe 3
#define nrClienti 10
#define timp_casier 2
sem_t semPompe;
static pthread_mutex_t mtxCasier = PTHREAD_MUTEX_INITIALIZER;
static void *threadCasier()
{
sleep(timp_casier);
//casierul e lent
sem_post(&semPompe);
printf("Casierul a eliberat o pompa\n");
return NULL;
}
static void *threadClient(int* t)
{
pthread_t casier;
pthread_attr_t attrCasier;
int s;
int timpAlimentare = *t;
sem_wait(&semPompe);
printf("Clientul alimenteaza %d timp\n",timpAlimentare);
sleep(timpAlimentare);
s = pthread_mutex_lock(&mtxCasier);
if (s != 0) perror("pthread_mutex_lock");

=0 ){

pthread_attr_init(&attrCasier);
if( pthread_create(&casier, &attrCasier, (void*)(*(threadCasier)), NULL) !
perror("pthread_create casier");
}
s = pthread_join(casier, NULL);
if (s != 0) perror("pthread_join");
s = pthread_mutex_unlock(&mtxCasier);
if (s != 0) perror("pthread_mutex_unlock");

return NULL;

int main() {
pthread_t client[nrClienti];
pthread_attr_t attr;
int timp[]={4,1,6,4,9,4,6,8,2,9};
int i;

if(!sem_init(&semPompe, 0, nrPompe)){}
else printf("Eroare la initializarea semaforului \n");
pthread_attr_init(&attr);
for(i = 0; i<nrClienti; i++)
if(
pthread_create(client+i,
&attr,
(void*)&timp[i]) !=0 ){
perror("pthread_create client");
return EXIT_FAILURE;
}

(void*)(*(threadClient)),

for(i=0; i<nrClienti; i++)

if(pthread_join(*(client+i), NULL) != 0){
perror("pthread_join");
return EXIT_FAILURE;
}
printf("\nMain: toate taskurile s-au terminat ... exit ... \n");
sem_destroy(&semPompe);
exit(0);
}

return 0;