Problema produttori consumatori

di il
3 risposte

Problema produttori consumatori

Buongiorno a tutti.......potete per favore aiutarmi su questo problema:
utilizzare una struttura buffer e due condition variable non pieno e non vuoto.Poi utilizzare 3 mutex per proteggere l'accesso alle variabili condivise: il buffer, l'indice delle estrazioni e l'indice degli inserimenti. Per inserire si valuta il buffer per controllare se è pieno, se lo è per il caso bloccante si attende una notifica di un'eliminazione di un messaggio, altrimenti si ritorna errore per quello non bloccante. Se il buffer non è pieno, si inserisce il messaggio e si aggiorna il numero di messaggi contenuti.
Dualmente si procede per il consumo, si verifica se il buffer è vuoto, si attende per una notifica di avvenuto inserimento messaggio per il caso bloccante, mentre si ritorna un errore per il caso non bloccante. Nel caso di buffer non vuoto, si ritorna il messaggio e lo si elimina dal buffer.
Ho scritto questo ,ma sto impazzendo non riesco a farlo funzionare:

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<string.h>
#define BUFFERERROR (msg_t *) NULL;
typedef char* stringa;
typedef struct msg {
void* content;
// generico contenuto del messaggio
struct msg * (*msg_init_string)(void*);
// creazione msg
void (*msg_destroy_string)(struct msg *);
// deallocazione msg
struct msg * (*msg_copy_string)(struct msg *); // creazione/copia msg
} msg_t;

typedef struct buffer{

int K; //numero messaggi inseriti
int N; //capacita buffer circolare
int D;
int T;
msg_t **buffer_circolare;
pthread_mutex_t mutex;
pthread_cond_t non_pieno;
pthread_cond_t non_vuoto;



}buffer_t;




void msg_destroy_string(msg_t* msg) {
free(msg->content); // free copia privata
free(msg);
// free struct
}

msg_t* msg_copy_string(msg_t* msg) {
return msg->msg_init_string( msg->content );
}
msg_t* msg_init_string(void* content) {


//viene creata una copia "privata" della stringa
msg_t* new_msg = (msg_t*)malloc( sizeof(msg_t) );
char* string = (char*)content;
char* new_content = (char*)malloc(strlen(string)+1); // +1 per \0 finale
strcpy(new_content, string);
new_msg->content=new_content;
new_msg->msg_init_string=msg_init_string;
new_msg->msg_destroy_string=msg_destroy_string;
new_msg->msg_copy_string=msg_copy_string;
return new_msg;
}

void buffer_destroy(buffer_t* buffer){
free(buffer);
}

buffer_t* buffer_init(unsigned int maxsize){
buffer_t *buffer;
buffer = (buffer_t *)malloc(sizeof(buffer_t));
buffer->buffer_circolare = malloc(maxsize*sizeof(msg_t));
buffer->D=0;
buffer->K=0;
buffer->T=0;
buffer->N=maxsize;
pthread_mutex_init(&buffer->mutex,NULL);
pthread_cond_init(&buffer->non_pieno,NULL);
pthread_cond_init(&buffer->non_vuoto,NULL);
return buffer;



}

msg_t* put_non_bloccante(buffer_t *buffer){

pthread_mutex_lock(&buffer->mutex);

if(buffer->K==buffer->N){
printf("Il buffer è pieno e il mutex è rilasciato\n");
pthread_mutex_unlock(&buffer->mutex);
return NULL;

}else{

msg_t* msg=msg_init_string("Messaggio");
buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
printf("Il produttore inserisce il messaggio\n");
buffer->D=(buffer->D+1)%buffer->N;
buffer->K=buffer->K+1;
pthread_cond_signal(&buffer->non_vuoto);
pthread_mutex_unlock(&buffer->mutex);
return msg;

}
}



msg_t* put_bloccante(buffer_t *buffer){

msg_t *msg = msg_init_string("Messaggio");
pthread_mutex_lock(&buffer->mutex);

while(buffer->K==buffer->N){
printf("Il Produttore è in attesa che il buffer sia vuoto\n");
pthread_cond_wait(&buffer->non_pieno,&buffer->mutex);


}

buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
printf("Il produttore inserisce il messaggio\n");
buffer->D=(buffer->D+1)%buffer->N;
buffer->K=buffer->K+1;

pthread_cond_signal(&buffer->non_vuoto);
pthread_mutex_unlock(&buffer->mutex);
return msg;

/**}else return BUFFERERROR;*/

}

msg_t* get_bloccante(buffer_t* buffer){
msg_t*result;
pthread_mutex_lock(&buffer->mutex);

while(buffer->K==0){
printf("Il consumatore è in attesa che il buffer venga riempito\n");
pthread_cond_wait(&buffer->non_vuoto,&buffer->mutex);


}
printf("Il consumatore preleva un messaggio\n");
result=(msg_t*)malloc( sizeof(msg_t) );
result=buffer->buffer_circolare[buffer->T];
buffer->buffer_circolare[buffer->T]=NULL;
buffer->T=(buffer->T+1)%buffer->N;
buffer->K=buffer->K-1;
pthread_cond_signal(&buffer->non_pieno);
pthread_mutex_unlock(&buffer->mutex);
return result;

}

msg_t* get_non_bloccante(buffer_t* buffer){
pthread_mutex_lock(&buffer->mutex);
if(buffer->K==0){
printf("Il consumatore non preleva poiche buffer vuoto\n");
pthread_mutex_unlock(&buffer->mutex);
return NULL;

}else{
printf("Il consumatore preleva un messaggio\n");
msg_t* result=(msg_t*)malloc( sizeof(msg_t) );
result=msg_copy_string(buffer->buffer_circolare[buffer->T]);
buffer->buffer_circolare[buffer->T]=NULL;
buffer->T=(buffer->T+1)%buffer->N;
buffer->K=buffer->K-1;
pthread_cond_signal(&buffer->non_pieno);
pthread_mutex_unlock(&buffer->mutex);
return result;
}
}

msg_t* dummy_produttore(buffer_t* buffer){
msg_t *msg = msg_init_string("Messaggio");
pthread_mutex_lock(&buffer->mutex);
buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
printf("Il produttore inserisce il messaggio\n");
buffer->D=(buffer->D+1)%buffer->N;
buffer->K=buffer->K+1;
pthread_cond_signal(&buffer->non_vuoto);
pthread_mutex_unlock(&buffer->mutex);
return msg;


}

msg_t* dummy_consumatore(buffer_t* buffer){
msg_t*result;
pthread_mutex_lock(&buffer->mutex);
printf("Il consumatore preleva un messaggio\n");
result=(msg_t*)malloc( sizeof(msg_t) );
result=buffer->buffer_circolare[buffer->T];
buffer->buffer_circolare[buffer->T]=NULL;
buffer->T=(buffer->T+1)%buffer->N;
buffer->K=buffer->K-1;
pthread_cond_signal(&buffer->non_pieno);
pthread_mutex_unlock(&buffer->mutex);
return result;

}

3 Risposte

  • Re: Problema produttori consumatori

    Primo: devi usare i tag code per postare il codice, mantenendo la corretta indentatura e facilitare così la lettura.
    Secondo: come provi la funzioni? Hai scritto un main() per evidenziare il problema?
    Terzo: qual è il problema?
  • Re: Problema produttori consumatori

    Problema: dei produttori consumatori definendo un oggetto buffer_t che mi rappresenta il buffer contenente D indice inserimento buffer circolare, T indice estrazione elementi buffer circolare e un buffer circolare che contiene dei messaggi del tipo msg_t *.
    Scusate ecco il codice:
    #include<stdio.h>
    #include<stdlib.h>
    #include<pthread.h>
    #include<string.h>
    #define BUFFERERROR (msg_t *) NULL;
    typedef char* stringa;
    typedef struct msg {
        void* content;
    // generico contenuto del messaggio
        struct msg * (*msg_init_string)(void*);
    // creazione msg
        void (*msg_destroy_string)(struct msg *);
    // deallocazione msg
        struct msg * (*msg_copy_string)(struct msg *); // creazione/copia msg
    } msg_t;
    
    typedef struct buffer{
    
        int K; //numero messaggi inseriti
        int N; //capacita bffer circolare
        int D;
        int T;
        msg_t **buffer_circolare;
        pthread_mutex_t mutex;
        pthread_cond_t non_pieno;
        pthread_cond_t non_vuoto;
    
    
    
    }buffer_t;
    
    
    
    
    void msg_destroy_string(msg_t* msg) {
        free(msg->content); // free copia privata
        free(msg);
    // free struct
    }
    
    msg_t* msg_copy_string(msg_t* msg) {
        return msg->msg_init_string( msg->content );
    }
    msg_t* msg_init_string(void* content) {
    
    
    //viene creata una copia "privata" della stringa
        msg_t* new_msg = (msg_t*)malloc( sizeof(msg_t) );
        char* string = (char*)content;
        char* new_content = (char*)malloc(strlen(string)+1); // +1 per \0 finale
        strcpy(new_content, string);
        new_msg->content=new_content;
        new_msg->msg_init_string=msg_init_string;
        new_msg->msg_destroy_string=msg_destroy_string;
        new_msg->msg_copy_string=msg_copy_string;
        return new_msg;
    }
    
    void buffer_destroy(buffer_t* buffer){
        free(buffer);
    }
    
    buffer_t* buffer_init(unsigned int maxsize){
        buffer_t *buffer;
        buffer = (buffer_t *)malloc(sizeof(buffer_t));
        buffer->buffer_circolare = malloc(maxsize*sizeof(msg_t));
        buffer->D=0;
        buffer->K=0;
        buffer->T=0;
        buffer->N=maxsize;
        pthread_mutex_init(&buffer->mutex,NULL);
        pthread_cond_init(&buffer->non_pieno,NULL);
        pthread_cond_init(&buffer->non_vuoto,NULL);
        return buffer;
    
    
    
    }
    
    msg_t* put_non_bloccante(buffer_t *buffer){
    
        pthread_mutex_lock(&buffer->mutex);
    
        if(buffer->K==buffer->N){
            printf("Il buffer è pieno e il mutex è rilasciato\n");
            pthread_mutex_unlock(&buffer->mutex);
            return NULL;
    
        }else{
    
            msg_t* msg=msg_init_string("Messaggio");
            buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
            printf("Il produttore inserisce il messaggio\n");
            buffer->D=(buffer->D+1)%buffer->N;
            buffer->K=buffer->K+1;
            pthread_cond_signal(&buffer->non_vuoto);
            pthread_mutex_unlock(&buffer->mutex);
            return msg;
    
        }
    }
    
    
    
    msg_t* put_bloccante(buffer_t *buffer){
    
            msg_t *msg = msg_init_string("Messaggio");
            pthread_mutex_lock(&buffer->mutex);
    
            while(buffer->K==buffer->N){
                printf("Il Produttore è in attesa che il buffer sia vuoto\n");
                pthread_cond_wait(&buffer->non_pieno,&buffer->mutex);
    
    
            }
    
            buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
            printf("Il produttore inserisce il messaggio\n");
            buffer->D=(buffer->D+1)%buffer->N;
            buffer->K=buffer->K+1;
    
            pthread_cond_signal(&buffer->non_vuoto);
            pthread_mutex_unlock(&buffer->mutex);
            return msg;
    
        /**}else return BUFFERERROR;*/
    
    }
    
    msg_t* get_bloccante(buffer_t* buffer){
        msg_t*result;
        pthread_mutex_lock(&buffer->mutex);
    
        while(buffer->K==0){
                    printf("Il consumatore è in attesa che il buffer venga riempito\n");
                    pthread_cond_wait(&buffer->non_vuoto,&buffer->mutex);
    
    
        }
        printf("Il consumatore preleva un messaggio\n");
        result=(msg_t*)malloc( sizeof(msg_t) );
        result=buffer->buffer_circolare[buffer->T];
        buffer->buffer_circolare[buffer->T]=NULL;
        buffer->T=(buffer->T+1)%buffer->N;
        buffer->K=buffer->K-1;
        pthread_cond_signal(&buffer->non_pieno);
        pthread_mutex_unlock(&buffer->mutex);
        return result;
    
    }
    
    msg_t* get_non_bloccante(buffer_t* buffer){
        pthread_mutex_lock(&buffer->mutex);
        if(buffer->K==0){
            printf("Il consumatore non preleva poiche buffer vuoto\n");
            pthread_mutex_unlock(&buffer->mutex);
            return NULL;
    
        }else{
            printf("Il consumatore preleva un messaggio\n");
            msg_t* result=(msg_t*)malloc( sizeof(msg_t) );
            result=msg_copy_string(buffer->buffer_circolare[buffer->T]);
            buffer->buffer_circolare[buffer->T]=NULL;
            buffer->T=(buffer->T+1)%buffer->N;
            buffer->K=buffer->K-1;
            pthread_cond_signal(&buffer->non_pieno);
            pthread_mutex_unlock(&buffer->mutex);
            return result;
        }
    }
    
    msg_t* dummy_produttore(buffer_t* buffer){
                msg_t *msg = msg_init_string("Messaggio");
                pthread_mutex_lock(&buffer->mutex);
                buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
                printf("Il produttore inserisce il messaggio\n");
                buffer->D=(buffer->D+1)%buffer->N;
                buffer->K=buffer->K+1;
                pthread_cond_signal(&buffer->non_vuoto);
                pthread_mutex_unlock(&buffer->mutex);
                return msg;
    
    
    }
    
    msg_t* dummy_consumatore(buffer_t* buffer){
            msg_t*result;
            pthread_mutex_lock(&buffer->mutex);
            printf("Il consumatore preleva un messaggio\n");
            result=(msg_t*)malloc( sizeof(msg_t) );
            result=buffer->buffer_circolare[buffer->T];
            buffer->buffer_circolare[buffer->T]=NULL;
            buffer->T=(buffer->T+1)%buffer->N;
            buffer->K=buffer->K-1;
            pthread_cond_signal(&buffer->non_pieno);
            pthread_mutex_unlock(&buffer->mutex);
            return result;
    
    }
  • Re: Problema produttori consumatori

    Cosi come l'ho scritto funziona ma non rispetta le specifiche dell'homework. Infatti i metodi put e get devono avere come parametri buffer_t* e msg_t*(per intenderci put_bloccante(buffer_t* buffer,msg_t* msg))
    Io ho provato a scrivere il metodo put_bloccante in questo modo:
    msg_t* put_bloccante(buffer_t *buffer,msg_t* msg){
    
            msg = msg_init_string("Messaggio");
            pthread_mutex_lock(&buffer->mutex);
    
            while(buffer->K==buffer->N){
                printf("Il Produttore è in attesa che il buffer sia vuoto\n");
                pthread_cond_wait(&buffer->non_pieno,&buffer->mutex);
    
    
            }
    
            buffer->buffer_circolare[buffer->D]=msg_copy_string(msg);
            printf("Il produttore inserisce il messaggio\n");
            buffer->D=(buffer->D+1)%buffer->N;
            buffer->K=buffer->K+1;
    
            pthread_cond_signal(&buffer->non_vuoto);
            pthread_mutex_unlock(&buffer->mutex);
            return msg;
    
        /**}else return BUFFERERROR;*/
    
    }
    Ma se eseguo tale metodo(invocandolo nel main mediante pthread_create(&th1,NULL,put_bloccante,(buffer_vuoto,msg))) non mi viene visualizzato in output alcun tipo di messaggio.
    Volevo sapere se qualcuno mi potesse aiutare nel trovare l'errore e farmi capire dove sbaglio
Devi accedere o registrarti per scrivere nel forum
3 risposte