Corso di Laurea in Ingegneria Informatica. Sistemi Operativi. Esercitazione semafori. Università degli Studi KORE - Enna. Docente: Mario Collotta

Transcript

1 Corso di Laurea in Ingegneria Informatica Sistemi Operativi Esercitazione semafori Università degli Studi KORE - Enna Docente: Mario Collotta mario.collotta@unikore.it 1

2 Esercizio 1 Implementare un programma C che rispetti le seguenti specifiche: il processo padre deve dar vita a 2 processi figli. ogni processo (padre e figlio) deve avere l accesso esclusivo ad un file di testo su cui scrivere il proprio PID.

3 Soluzione proposta dagli studenti senza l utilizzo dei semafori e senza segnali #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> #define N 2 FILE *fp; void scrittura(); int main() int i, c, stato; fp=fopen("pid.txt", "w"); fclose(fp); //CREO O RESETTO FILE /* do printf("\n\nnumero di figli con N>2:\t"); scanf("%d", &N); }while(n<2);*/

4 pid[i]=fork(); switch(pid[i]) case -1: printf("\n\nfork %d FALLITA!!!", c); exit(0); break; case 0: sleep(i+1); printf("\n\nfiglio %d - Padre %d\n\n", getpid(), getppid()); scrittura(); printf("%d ha scritto il proprio PID su file.\n\n", getpid()); exit(stato); break; default: wait(&stato); break; }//switch }//for printf("\n\npadre %d\n\n", getpid()); scrittura(); void scrittura() fp=fopen("pid.txt", "a"); fprintf(fp, "%d\n\n", getpid()); fclose(fp); }//scrittura

5 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <sys/wait.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> #define DBACCESS 17 #define N 2 FILE *fp; int dbaccess; void scrittura(); int main() int i, c, stato; int s[1]; Soluzione proposta dagli studenti con semafori dbaccess = semget(dbaccess, 1, 0777 IPC_CREAT); if(dbaccess==-1) printf("\n\nsemaforo FALLITO. RIPROVA.\n\n"); exit(0); } else printf("\nsemaforo creato correttamente. Semid = %d\n\n", dbaccess); } struct sembuf down[1], up[1]; down[0].sem_num=0; down[0].sem_op=-1; down[0].sem_flg=0; up[0].sem_num=0; up[0].sem_op=1; up[0].sem_flg=0; semctl(dbaccess, 0, SETVAL, 1);

6 int pid[n]; for(i=0; i<n; i++) pid[i]=0; } for(i=0; i<n; i++) c++; pid[i]=fork(); switch(pid[i]) case -1: printf("\n\nfork %d FALLITA!!!", c); exit(0); break; case 0: sleep(i+1); printf("\n\nfiglio %d - Padre %d\n\n", getpid(), getppid()); semop(dbaccess, down, 1); scrittura(); semop(dbaccess, up, 1); printf("%d ha scritto su file.\n\n", getpid()); exit(stato); break; default: wait(&stato); break; }//switch }//for printf("\n\npadre %d\n\n", getpid()); semop(dbaccess, down, 1); scrittura(); semop(dbaccess, up, 1); exit(0); }//main void scrittura() fp=fopen("pid.txt", "a"); fprintf(fp, "%d\n\n", getpid()); fclose(fp); }//scrittura

7 Esercizio 2 Implementare un programma C che rispetti le seguenti specifiche: il processo padre P0 deve dar vita a 3 processi figli. ogni processo (padre e figli) deve avere l accesso esclusivo ad un file di testo su cui scrivere il proprio pid. 7

8 8

9 9

10 10

11 Esercizio 3 Realizzare un programma C che rispetta le seguenti specifiche: il processo iniziale P0 deve dare origine ad N figli con N dato da input (N>5). il processo iniziale P0 dopo aver separato i processi figli con PID pari da quelli con PID dispari dovrà gestirli nel seguente modo: i processi con pid pari eseguono un comando Linux. i processi con pid dispari salvano sullo stesso file di testo il proprio pid. 11

12 12

13 13

14 14

15 Esercizio 4 Si implementi, utilizzando le system call di Linux, un processo iniziale (P0->processo padre) che crei un numero N di figli (con N inserito da tastiera ed N>2) ed alcuni nipoti (1 per figlio). Il processo padre P0 apparterrà alla I generazione, i figli alla II ed i nipoti alla III. I processi figli, così creati, devono attendere la terminazione del proprio figlio (processo appartenente alla III generazione) e stampare lo stato di terminazione. I processi di III generazione dovranno scrivere, ciascuno, un valore intero A nello stesso file: <<esame.txt>> (con A letto da tastiera ed A>10). Dovranno, inoltre, restituire uno stato di terminazione pari al valore di A. Il processo P0 dovrà terminare tutti i processi creati (di II generazione), inviando a ciascuno il segnale SIGKILL. Ogni processo creato dovrà stampare il proprio pid e quello del proprio padre. 15

16 16

17 17

18 18

19 19

20 Esercizio 5 Realizzare un programma C che simuli le operazioni bancarie. il processo iniziale P0 deve dare origine a N figli. Ogni figlio svolgerà le seguenti operazioni: Se ha PID pari deve leggere un valore dal file X.txt e decrementarlo di una certa quantità, successivamente scrivere il proprio PID, la quantità e il valore aggiornato all interno del file Y.txt Se ha PID dispari deve leggere un valore dal file X.txt e incrementarlo di una certa quantità, successivamente scrivere il proprio PID, la quantità e il valore aggiornato all interno del file Y.txt

21 Soluzione proposta dagli studenti #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <sys/wait.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> #define DBACCESS 17 #define DEC 10 #define INC 15 FILE *fp1; FILE *fp2; int dbaccess; int main() int N, i, c, stato, conto, inc, dec; int s[1]; dbaccess = semget(dbaccess, 1, 0777 IPC_CREAT); if(dbaccess==-1) printf("\n\nsemaforo FALLITO. RIPROVA.\n\n"); exit(0); } else printf("\nsemaforo creato correttamente. Semid = %d\n\n", dbaccess); }

22 struct sembuf down[1], up[1]; down[0].sem_num=0; down[0].sem_op=-1; down[0].sem_flg=0; up[0].sem_num=0; up[0].sem_op=1; up[0].sem_flg=0; semctl(dbaccess, 0, SETVAL, 1); fp2=fopen("y.txt", "w"); fclose(fp2); //CREO FILE LISTA MOVIMENTI printf("\n\nnumero di figli:\t"); scanf("%d", &N); int pid[n]; for(i=0; i<n; i++) pid[i]=0; } fp1=fopen("x.txt", "r"); rewind(fp1); fscanf(fp1, "%d", &conto); fclose(fp1); fp2=fopen("y.txt", "w+"); fprintf(fp2, "CONTO INIZIALE: %d\n\n", conto); fclose(fp2); printf("e'stato scritto su file Y.txt il conto iniziale.\n\n");

23 for(i=0; i<n; i++) c++; pid[i]=fork(); switch(pid[i]) case -1: printf("\n\nfork %d FALLITA!!!", c); exit(0); break; case 0: sleep(i+1); printf("\n\nfiglio %d - Padre %d\n\n", getpid(), getppid()); if((getpid()%2)==0) semop(dbaccess, down, 1); fp1=fopen("x.txt", "r"); rewind(fp1); fscanf(fp1, "%d", &conto); fclose(fp1); /* printf("\ndi quanto vuoi decrementare?\t"); scanf("%d", &dec);*/ conto=conto - DEC; fp2=fopen("y.txt", "a"); fprintf(fp2, "%d ha decrementato di %d.\nconto aggiornato = %d\n\n\n", getpid(), DEC, conto); fclose(fp2); fp1=fopen("x.txt", "w+"); fprintf(fp1, "%d", conto); fclose(fp1);

24 semop(dbaccess, up, 1); }//IF FIGLI PARI else semop(dbaccess, down, 1); fp1=fopen("x.txt", "r"); rewind(fp1); fscanf(fp1, "%d", &conto); fclose(fp1); /*printf("\ndi quanto vuoi incrementare?\t"); scanf("%d", &inc);*/ conto=conto + INC; fp2=fopen("y.txt", "a"); fprintf(fp2, "%d ha incrementato di %d.\nconto aggiornato = %d\n\n\n", getpid(), INC, conto); fclose(fp2); fp1=fopen("x.txt", "w+"); fprintf(fp1, "%d", conto); fclose(fp1); semop(dbaccess, up, 1); }//IF FIGLI DISPARI exit(stato); break; default: break; }//switch }//for printf("guardare lista movimenti su file X.txt"); exit(0); }//main

25 Esercizio 6 Realizzare un programma C che rispetti le seguenti specifiche: il processo iniziale P0 deve dare origine ad N figli con N dato da input (almeno 4). il processo iniziale P0 dovrà suddividere i processi figli in due sottogruppi (ordine ininfluente) e attivarli seguendo un ordine preciso (p.e. secondo un algoritmo di scheduling FIFO, LIFO, secondo una priorità). Ogni sottogruppo svolgerà le seguenti operazioni: I processi del primo sottogruppo (processi genitori) devono salvare il proprio PID in un file X.txt e creare a loro volta un processo figlio (nipote di P0) che deve leggere e stampare a video il contenuto di tale file I processi del secondo gruppo (processi genitori) devono creare un processo figlio ciascuno (nipote di P0) che, continuamente, attende alcuni istanti e stampa il proprio PID e quello del genitore che l ha creato in file Y.txt. I processi genitori devono quindi inviare un segnale di terminazione per terminare i processi nipoti.