Pasted

/* Esame del 28/02/14
 * Una ditta che effettua vendite online dei propri prodotti gestisce le richieste di acquisto con un programma multithreading.
 * Questo programma è costituito da un thread che riceve le richieste e attiva, per ognuna di queste,
 * un thread per la gestione della richiesta stessa.
 * Il programma di gestione delle richieste è progettato in modo che abbia le seguenti caratteristiche:
 * 
 *  - Non si possono gestire piu` di N richieste contemporaneamente: 
 *    se una richiesta arriva mentre nel sistema se ne stanno servendo N la nuova richiesta viene rifiutata
 *    (non rimane in attesa nel sistema);
 *
 *  - Ogni thread di gestione di una richiesta necessita della risorsa R per poter eseguire e tale risorsa
 *        puo' essere acquisita da un thread alla volta;
 *
 *  - Esistono due categorie di richieste, richieste di utenti gold e richieste di utenti silver:
 *    alle richieste di utenti gold viene concesso l’uso della risorsa R con priorita' su quelle degli utenti
 *    silver che attendono fino a quando non ci sono nel sistema thread che servono richieste gold.
 *
 *
 * Scrivere il programma in questione, usando il linguaggio C e la libreria pthread, concentrandosi solo
 * sugli aspetti di sincronizzazione tra i thread e di accesso alle risorse;
 * A tal scopo lasciare indicate in modo generico eventuali altre funzioni svolte dai thread.
 * Generare in modo casuale l’arrivo di richieste segnalandole tramite un semaforo su cui il thread di ricezione
 * si sincronizza.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
 
#define N 10
 
 
sem_t clienti; // # clienti
sem_t impiegati; // # impiegati liberi
 
typedef struct{
    int priority; // 1 gold, 0 silver
    char* richiesta;
} t_param;
 
pthread_mutex_t m_waiting;
int waiting;
 
sem_t s_priority; // Semaphore used to let silver user wait
int n; // numero di richieste in corso
pthread_mutex_t m_n; // mutex per n
 
int main(int argc, char const *argv[]){
    
    waiting = 0;
 
    return 0;
}
 
void* assegna_lavoro(){
    pthread_t tid;
    while(1){
        deaccoda();
        pthread_create(&tid, NULL, nuovoticket, (void *) &param);   
    }
}
 
void* nuovoticket(){
 
    pthread_mutex_lock(&m_n); // Inizio sez. critica
    if(n >= N){ // Se ci sono già N processi, sblocco mutex ed esco
        pthread_mutex_unlock(&m_n);
        return NULL;
    }
    ++n;
    pthread_mutex_unlock(&m_n); // Fine sez. critica
    if(param->priority == 0) // Aspetto che non ci siano utenti con priorità gold.
        sem_wait(&s_priority);
 
    // LAVORO IL TICKET
    
    pthread_mutex_lock(&m_n); // Inizio sez. critica
    if(param->priority == 1 && n==0) // Se sono l'ultimo gold, rilascio priority così entrano eventuali silver
        sem_post(&s_priority);
    --n;
    pthread_mutex_unlock(&m_n);
 
}
 
// Probelmi:
// Il silver viene mai eseguito?