Esercizi Sistemi operativi

Lettori/scrittori con priorità

Si realizzi in linguaggio C/C++ un'applicazione multiprocesso, basata su costrutto monitor, che implementi la variante dello schema dei lettori-scrittori descritta di seguito. Il monitor dovrà fornire le seguenti procedure:

typedef struct {
    int buffer; // risorsa condivisa
    // ... aggiungere altre variabili per la sincronizzazione ...
} MonitorLS;

void inizializza(MonitorLS * m);
int lettore(MonitorLS * m);
void scrittore_lento(MonitorLS * m, int valore);
void scrittore_veloce(MonitorLS * m, int valore);

La funzione lettore() dovrà ritornare in uscita il valore nel buffer, rispettando i normali vincoli dello schema lettori-scrittori (mutua esclusione con gli scrittori; più lettori possono accedere contemporaneamente). Le funzioni scrittore_lento() e...

<p>scrittore_veloce() dovranno scrivere sul buffer il valore passato come parametro di ingresso, rispettando i normali vincoli dello schema lettori-scrittori (mutua esclusione con i lettori e tra gli scrittori). Gli scrittori veloci impiegano 1 secondo per effettuare la scrittura (da simulare usando la funzione sleep()); gli scrittori lenti impiegano 2 secondi.</p>

<p>Si richiede di implementare il seguente schema, in cui la starvation può verificarsi sia sui lettori sia sugli scrittori, e in cui gli scrittori veloci hanno la priorità sugli scrittori lenti. Si usino condition variables distinte per i due tipi di scrittori. Quando vi sono in attesa sia scrittori veloci sia scrittori lenti, il processo uscente (sia nel caso di un lettore sia di uno scrittore in uscita) dovrà sbloccare uno scrittore veloce; altrimenti, in assenza di scrittori veloci, il processo uscente dovrà sbloccare uno scrittore lento; oppure, in assenza di scrittori in attesa, sbloccare un processo lettore.</p>

Il programma dovrà creare 3 processi lettori, 2 processi scrittori lenti, e 2 processi scrittori veloci. Ciascuno di essi dovrà chiamare la corrispondente funzione del monitor per 3 volte, attendendo 3 secondi tra le chiamate. Gli scrittori dovranno generare un valore casuale intero tra 0 e 10 per la scrittura. I processi dovranno stampare a video i valori letti e scritti. Il processo padre dovrà attendere la terminazione dei figli e terminare a sua volta. È richiesto che il codice sia contenuto all'interno di un unico eseguibile. Lo studente può utilizzare una delle implementazioni delle primitive di base del monitor che sono state utilizzate durante il corso, e disponibili sulle macchine di laboratorio.

#include "procedure.h"
#include "monitor_signal_continue.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <sys/shm.h>

#define ...

OK_SCRITTORI_V 0
#define OK_SCRITTORI_L 1
#define OK_LETTORI 2
#define N_SCRITTORI 4
#define N_LETTORI 3

typedef struct{
    int buffer;
    Monitor M;
    int n_scrittori_v;
    int n_scrittori_l;
    int n_lettori;
} MonitorLS;

void inizializza(MonitorLS *);
void lettore(MonitorLS *);
void scrittore_lento(MonitorLS *);
void scrittore_veloce(MonitorLS *);
int leggi(MonitorLS *);
void scrivi_lento(MonitorLS *,int);
void scrivi_veloce(MonitorLS *,int);
void dealloca(int,MonitorLS *);

#endif

procedure.c

#include "procedure.h"

void inizializza(MonitorLS *ls){
    init_monitor(&(ls->M),3);
    ls->n_scrittori_l = 0;
    ls->n_scrittori_v = 0;
    ls->n_lettori = 0;
    //printf("[DEBUG]: status variabili, n_lettori: %d n_scrittori_v: %d n_scrittori_l: %d \n",ls->n_lettori,ls->n_scrittori_v,ls->n_scrittori_l);
}

pag. 33

void lettore(MonitorLS *ls){
    // printf("Sono il lettore \n");
    int val;
    for(int i = 0; i<3;i++){
        val = leggi(ls);
        printf("Il valore letto è: %d \n",val);
    }
}

void scrittore_lento(MonitorLS *ls){
    // implementazione
}

void scrittore_veloce(MonitorLS *ls){
    // implementazione
}

int leggi(MonitorLS *ls){
    // implementazione
}

void scrivi_lento(MonitorLS *ls, int val){
    // implementazione
}

void scrivi_veloce(MonitorLS *ls, int val){
    // implementazione
}

void dealloca(int val, MonitorLS *ls){
    // implementazione
}

scrittore_lento(MonitorLS *ls){
    //printf("sono lo scrittore lento \n");
    int val;
    srand(time(NULL)*getpid());
    for(int i = 0; i<3;i++){
        val = rand()%11;
        scrivi_lento(ls,val);
        sleep(2);
    }
}

void scrittore_veloce(MonitorLS *ls){
    //printf("Sono lo scrittore veloce \n");
    int val;
    srand(time(NULL)*getpid());
    for(int i = 0; i<3;i++){
        val = rand()%11;
        scrivi_veloce(ls,val);
        sleep(1);
    }
}

int leggi(MonitorLS *ls){
    //printf("[DEBUG]: status variabili, n_lettori: %d n_scrittori_v: %d n_scrittori_l: %d \n",ls->n_lettori,ls->n_scrittori_v,ls->n_scrittori_l);
    enter_monitor(&(ls->M));
    while (ls->n_scrittori_l > 0 || ls->n_scrittori_v > 0){
        wait_condition(&(ls->M),OK_LETTORI);
    }
    ls->n_lettori++;
    leave_monitor(&(ls->M));
    int valore = ls->buffer;
    //printf("valore letto: %d",ls->buffer);
    enter_monitor(&(ls->M));
    ls->n_lettori--;
    if(ls->n_lettori ==

0){
    if(queue_condition(&(ls->M),OK_LETTORI) > 0){
        signal_all(&(ls->M),OK_LETTORI);
    }else if(queue_condition(&(ls->M),OK_SCRITTORI_V) > 0){
        signal_condition(&(ls->M),OK_SCRITTORI_V);
    }else if(queue_condition(&(ls->M),OK_SCRITTORI_L) > 0){
        signal_condition(&(ls->M),OK_SCRITTORI_L);
    }
}
pag. 34
leave_monitor(&(ls->M));
return valore;
}

void scrivi_lento(MonitorLS *ls,int valore){
    // printf("[DEBUG]: status variabili, n_lettori: %d n_scrittori_v: %d n_scrittori_l: %d \n",ls->n_lettori,ls->n_scrittori_v,ls->n_scrittori_l);
    enter_monitor(&(ls->M));
    while (ls->n_lettori > 0 || ls->n_scrittori_l > 0 || ls->n_scrittori_v > 0){
        wait_condition(&(ls->M),OK_SCRITTORI_L);
    }
    printf("Inizio a scrivere (lento) il valore %d... \n",valore);
    ls->n_scrittori_l++;
    leave_monitor(&(ls->M));
    ls->buffer =

valore;
enter_monitor(&(ls->M));
ls->n_scrittori_l--;
if(queue_condition(&(ls->M),OK_SCRITTORI_V) > 0){
    signal_condition(&(ls->M),OK_SCRITTORI_V);
}else if(queue_condition(&(ls->M),OK_SCRITTORI_L)>0){
    signal_condition(&(ls->M),OK_SCRITTORI_L);
}else if(queue_condition(&(ls->M),OK_LETTORI)){
    signal_all(&(ls->M),OK_LETTORI);
}
leave_monitor(&(ls->M));

void scrivi_veloce(MonitorLS *ls,int valore){
    //printf("[DEBUG]: status variabili, n_lettori: %d n_scrittori_v: %d n_scrittori_l: %d \n",ls->n_lettori,ls->n_scrittori_v,ls->n_scrittori_l);
    enter_monitor(&(ls->M));
    while(ls->n_lettori > 0 || ls->n_scrittori_l > 0 || ls->n_scrittori_v > 0){
        wait_condition(&(ls->M),OK_SCRITTORI_V);
    }
    printf("Inizio a scrivere (veloce)... il valore: %d \n",valore);
    ls->n_scrittori_v++;
    leave_monitor(&(ls->M));
    ls->buffer =

valore;
enter_monitor(&(ls->M));
ls->n_scrittori_v--;
if(queue_condition(&(ls->M),OK_SCRITTORI_V) > 0){
    signal_condition(&(ls->M),OK_SCRITTORI_V);
}else if(queue_condition(&(ls->M),OK_SCRITTORI_L)>0){
    signal_condition(&(ls->M),OK_SCRITTORI_L);
}else if(queue_condition(&(ls->M),OK_LETTORI)){
    signal_all(&(ls->M),OK_LETTORI);
}
leave_monitor(&(ls->M));
} pag. 35

void dealloca(int id_shm,MonitorLS *ls){
    remove_monitor(&(ls->M));
    shmctl(id_shm,IPC_RMID,0);
}

monitor_signal_continue.h
/***PROTOTIPI DELLE PROCEDURE PER LA REALIZZAZIONE DEL COSTRUTTO MONITOR***/
#ifndef __MONITOR_H
#define __MONITOR_H

typedef struct {
    //id del semaforo per realizzare il mutex del monitor
    int mutex;
    //numero di variabili condition
    int num_var_cond;
    //id del gruppo sem associati alle var.cond
    int id_conds;
    //id della memoria condivisa per i contatori delle variabili condition
    int id_shared;
    //array delle variabili condition_count
    int *cond_counts;
} Monitor;

numero di variabili condition
void init_monitor (Monitor*, int);
void enter_monitor(Monitor*);
void leave_monitor(Monitor*);
void remove_monitor(Monitor*);
void wait_condition(Monitor*,int);
void signal_condition(Monitor*,int);
void signal_all(Monitor*,int);
int queue_condition(Monitor*,int);
#endif

monitor_signal_continue.c
/*************************************Monitor*************************************************/
/// Implementazione di un Monitor Signal and Continue pag. 36
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <stdio.h>
#include <unistd.h>
#include "monitor_signal_continue.h"

//Funzioni di utilita' private alla libreria Monitor
static void Wait_Sem(int, int);
static void Signal_Sem (int,int);
static int Queue_Sem (int,int); //restituisce il num di processi in attesa su un semaforo

/********************IMPLEMENTAZIONE DELLE PROCEDURE***********************/
void init_monitor (Monitor *M,int

num_var){
    int i;
    //alloca e inizializza il mutex per l'accesso al monitor
    M->mutex=semget(IPC_PRIVATE,1,IPC_CREAT|0664);
    semctl(M->mutex,0,SETVAL,1);
    //alloca e inizializza i semafori con cui realizzare le var.condition
    M->id_conds=semget(IPC_PRIVATE,num_var,IPC_CREAT|0664);
    for (i=0;iid_conds,i,SETVAL,0);
    //alloca un contatore per ogni var.condition
    M->id_shared=shmget(IPC_PRIVATE,num_var*sizeof(int),IPC_CREAT|0664);
    //effettua l'attach all'array di contatori appena allocato
    M->cond_counts=(int*) (shmat(M->id_shared,0,0));
    M->num_var_cond = num_var;
    //inizializza i contatori per le var.condition
    for (i=0; icond_counts[i]=0;
    #ifdef DEBUG_printf("Monitor inizializzato con %d condition variables. Buona Fortuna ! \n",num_var); pag. 37
    #endif
}

void enter_monitor(Monitor * M){
    #ifdef DEBUG_printf("<%d> Tentativo di ingresso nel monitor... \t",getpid() );
    #endif
    Wait_Sem(M->mutex,0);
    #ifdef

DEBUG_printf("<%d> Entrato nel monitor \n",getpid() );
#endif}
void leave_monitor(Monitor* M){
#ifdef DEBUG_printf("<%d> Uscito dal monitor \n", getpid());
printf("<%d> -Monitor- signal sul mutex del monitor \n", getpid());
#endif
Signal_Sem(M->mutex,0);
}
void remove_monitor(Monitor* M){
semctl(M->mutex,0,IPC_RMID,0);
semctl(M->id_conds,M->num_var_cond