Meno:

Pri vypracovaní príkladov 1-4  použite nasledovnú syntax funkcií:

sem_init(sem, value) – inicializácia semafóra sem na hodnotu value

sem_wait(sem) – operácia wait na semafóre
sem_post(sem) – operácia post na semafóre

mutex_init(mut,value) – inicializácia zámky mut na honotu 0-lock, 1-unlock

mutex_lock(mut) – uzamknutie zámky
mutex_unlock(mut) – odomknutie zámky

cond_init(con) – inicializácia podm. premennej con

cond_wait(con,mut) – operácia blokovania na podmienke
cond_signal(con) – operácia signál pre podm. premennú

1. Doplňte programový kód procesov tak, aby sa príkaz p1 vykonal vždy pred
príkazom p2 a prikaz p2 pred príkazom p3. Na synchronizáciu použite
semafóry. 2 b.

Inicializácia semafórov:
_____________________________________
sem_int(sem1, 0) sem_int(sem2, 0)

proces1: proces2: proces3:

_sem_wait(sem1) sem_wait(sem2)
p1 p2 p3
sem_post(seml) sem_post(sem2)

2. Doplňte programový kód procesov tak, aby sa príkaz pA1 vykonal vždy pred
príkazom pB2 a príkaz pB1 vždy pred príkazom pA2. Na synchronizáciu
použite semafóry. 4 b.

Inicializácia semafórov:
__________________________
sem_int(sem2,0);
sem_init(sem1,0);

proces1: proces2:
___________________ _______________________

1
 ___________________
___________________
pA1
___________________
sem_post(sem1);
___________________
sem_wait(sem2);
pA2
___________________
___________________
_______________________
_______________________
pB1
_______________________
sem_post(sem2);
_______________________
sem_wait(sem1);
pB2
_______________________
_______________________

3. Doplňte nasledovný kód, ktorý zbieha n-procesov tak, aby žiaden proces
nevykonal príkaz p1 pokiaľ všetky procesy nevykonali príkaz r. Na
synchronizáciu použite semafór, zámku a počídadlo (procesov). 6 b.

Inicializácia:

sem_init(sem1,0);
mutex_init(mut1,1);
int count = 0;

Kód procesov:

mutex_lock(mut1);
r
____________________________________
count++;
mutex_unlock(mut1);

if (count == n) sem_post(sem1);
sem_wait(sem1);
p1
sem_post(sem1);

2
4. Pre úlohu výrobca/konzument s konečnou kapacitou zásobníka N doplňte kód
vlákien výrobca , konzument tak, aby bola zabezpečená ochrana pretečenia a
podtečenia zásobníka. Na riešenie použite podmienkové premenné. 8 b.

Inicializácia:
cond_init(con);
mutex_init(mut,1);
N = 20;
C = 0;

funkcia vlákna výrobca funkcia vlákna konzument

_________________________
mutex_lock(mut);
if (C == N)
cond_wait(cond,mut);
_________________________
__________________________
mutex_lock(mut);
if (C == 0 )
cont_wait(cond,mut);
__________________________

buffer_add(item); item = buffer_get();

C++;
mutex_unlock(mut);
cond_signal(cond);
_________________________
_________________________
_________________________
_________________________
C--;
mutex_unlock(mut);
cont_signal(cond);
__________________________
__________________________
__________________________
__________________________

5. V nasledovnej funkcii vlákien, ktorú vykonáva viac vlákien doplňte kód tak,
aby vlákno, ktoré je asynchrónne zrušitelné bolo možné zrušiť len v bode
zrušenia a pritom bola zámka odomknutá. 8 b.

thread_function( ){
_______________________________________________
_______________________________________________
_______________________________________________
_______________________________________________

3
 pthread_mutex_lock(&mut);
.......... ................................. // nejaká činnosť
pthread_testcancel();
............................................ // nejaká činnosť
pthread_mutex_unlock(&mut);
_____________________________________________
_____________________________________________
_____________________________________________
_____________________________________________
}

6. Doplňte nasledovný kód tak, aby výstup shellovského príkazu „who“ išiel do
súboru „file“ (ekvivalent shellovského who > file v c- jazyku). 4 b.

void main(){
int d = open(„file“,“rw“);
close(1);
dup(d);
close(d);
execlp(who, who, 0);
}

7. Existencii  stavu „zombie“ detských procesov možno zabrániť obyčajne tak,

že rodič čaka na ich ukončenie. Napíšte asynchrónny spôsob riešenia uvedenej
situácie. Doplňte nasledovný kód a napíšte potrebnú funkciu.
(Poznámka k riešeniu: rodičovský proces nečaká (venuje sa inej činnosti)
synchrónne na ukončenie detských procesov pričom využíva tú skutočnosť, že
každý detský proces po skončení vyšle signál SIGCHLD). 8 b.

void main(){ // rodičovský proces

_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
..................................// tu sa vytvoria detske procesy
}

4
 Tu napíšte potrebnú funkciu:

8. V programe, ktorý obsahuje globálnu premennú char* buffer je

vytvorený detský proces. Predpokladajme, že v detskom aj v rodičovskom
procese sú vytvorené vlákna. 3 b.

a) Navrhnite spôsob komunikácie medzi vláknami v tom istom procese:

______________________________________________________
b) Navrhnite spôsob komunikácie medzi vláknami detského
a rodičovského procesu:

__________________________________________________________
c) Za predpokladu, že je program vykonávaný na viacprocesorovom
systéme napíšte ako môžu byť vlákna zbiehané na viacerých
procesoroch v rámci jedného a oboch procesov v závislosti od ich typu
ULT alebo KLT:

ULT (User level threads)

________________________________________________
KLT (Kernel level threads)
________________________________________________

9. Reentrantné funkcie sú thread- safe (bezpečné). Vysvetlite pojem thread-safe

funkcia. 2 b.
___________________________________________________
___________________________________________________

10. Pre nasledovnú nereentrantnú funkciu napíšte jej reentrantnú verziu. 5 b.

char *strtoupper(char *string){

static char buffer[MAX_STRING_SIZE];

int index;

for (index = 0; string[index]; index++)

buffer[index] = toupper(string[index]);

buffer[index] = 0;

5
 return buffer;

Príloha:
Niektoré prototytypy funkcií:
int close( int fd);

int dup(int oldfd);

int dup2(int oldfd, int newfd);

int open(char* filename, int flag, mode_t mode);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

int pthread_cancel(pthread_t thread);

void pthread_cleanup_push(void (*routine) (void *), void *arg);

void pthread_cleanup_pop(int execute);

int pthread_setcancelstate(int state, int *oldstate);

int pthread_setcanceltype(int type, int *oldtype);

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sighandler_t signal(int signum, sighandler_t handler);

int wait( int *status);