esame-01-09-14

/* Esame del 01/09/14
 *
 * In una applicazione concorrente k threads condividono r risorse equivalenti dovendo eseguire ognuna una diversa
 * elaborazione che necessita di una istanza delle risorse.
 *
 * Scrivere un programma C che generi ad intervalli casuali i thread di calcolo che non dovranno mai essere piu` di k
 * Ogni thread richiede tramite la funzione Richiesta() l’accesso ad una istanza libera delle r risorse, se ce ne sono.
 * La funzione assegna la risorsa e torna un indice della stessa sotto forma di intero compreso tra 0 e r − 1;
 * La funzione ritorna sempre un valore, aspettando che una risorsa si liberi se non ci sono istanze disponibili.
 *
 * Il generico thread esegue la computazione invocando una funzione il cui prototipo `e void Elabora( int x ),
 * essendo x la risorsa assegnata al thread.
 * Dopo aver fatto uso della istanza della risorsa il thread la rilascia invocando una funzione il cui prototipo
 * e' void Rilascia( int x ), dove x indica l’indice della risorsa da rendere disponibile.
 * Specificare la stuttura del generico thread e le funzioni Richiesta() e Rilascia() in modo tale che
 * ogni istanza di risorsa venga usata da non piu’ di un thread alla volta anche se piu` thread eseguono in modo
 * concorrente.
 *
 * Svolgimento a cura di Emanuele Munafò.
 * Pertanto la soluzione data potrebbe essere inesatta e/o errata.
 */

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

#define K 10
#define R 4

sem_t s_nrisorselibere; // Contatore del numero delle risorse libere
pthread_mutex_t m_BMrisorsacondivisa; // Mutex per proteggere la bitmap della risorsa condivisa
short int BMrisorsacondivisa[R]; // Bitmap risorsa condivisa 0: risorsa libera, 1: risorsa occupata
sem_t s_maxthreads;

// Prototipi funzioni
unsigned int richiesta();
void rilascia(int x);
void* runner(void* runner);
void* elabora(int x);

int main(int argc, char const *argv[]){
    int r;
    pthread_t pid;
    // Inizializzo mutex e semafori
    sem_init(&s_nrisorselibere, 0, R); // Inizialmente tutte le risorse sono libere
    sem_init(&s_maxthreads, 0, K);
    pthread_mutex_init(&m_BMrisorsacondivisa, NULL);
    // Inizializzo la bitmap a 0
    for(int i=0;i<R;++i){
        BMrisorsacondivisa[i] = 0;
    }
    // Inizializzo seme random
    srand(time(NULL));

    // Genero sempre thread ma max K
    while(1){
        sem_wait(&s_maxthreads);
        r = rand()%300;
        usleep(r);
        pthread_create(&pid, NULL, runner, NULL);
    }

    return 0;
}


void* runner(void* params){
    unsigned int nr = richiesta(); // Richiedi numero di risorsa libera
    // Lavora sui dati
    elabora(nr); // Elabora i dati, la mutua escusione è implicitamente utilizzata con richiesta() e rilascia()
    // Rilascia le risorse
    rilascia(nr);


}

unsigned int richiesta(){
    sem_wait(&s_nrisorselibere); // Attendo che ci sia almeno una risorsa libera
    unsigned int retvalue = 0;
    pthread_mutex_lock(&m_BMrisorsacondivisa);
    for(int i=0;i<R && (retvalue == 0);++i){ // Break al primo valore 0 che trova
        if(BMrisorsacondivisa[i] == 0) // Ciò significa che l'iesima risorsa è libera
            retvalue = i;
    }
    pthread_mutex_unlock(&m_BMrisorsacondivisa);
    return retvalue;
}

void rilascia(int x){
    pthread_mutex_lock(&m_BMrisorsacondivisa);
    BMrisorsacondivisa[x] = 0;
    pthread_mutex_unlock(&m_BMrisorsacondivisa);
    sem_post(&s_nrisorselibere);
}