[C] Threads

[giacomovicinanza]

Salve a tutti. Sto riscontrando dei problemi con questo esercizio da 2 giorni. Non riesco a risolvere. Mi esce questa schermata e non so come fare


/*****************************************************************
Il candidato completi il programma fornito, implementando il main e la funzione worker.
Il programma crea 5 worker threads, ciascuno dei quali esegue la
funzione 'worker'. Ad ogni worker thread è assegnato un numero
identificativo progressivo da 1 a 5. I worker thread e il thread principale
lavorano su una variabile condivisa 'somma', di tipo intero,
inizializzata a 0 dal main.

I worker thread eseguono il seguente algoritmo:
1. Aspetta per 1 secondo.
2. Aggiungi il tuo numero identificativo a 'somma',
stampando il tuo numero identificativo e il nuovo
valore di 'somma'.
3. Ricomincia dal passo 1.

Il thread principale, dopo aver creato i worker thread, esegue il
seguente algoritmo:
1. Aspetta fino a che 'somma' diventi maggiore di 40.
2. Termina l'esecuzione del programma.

Il thread principale e i worker thread devono gestire in maniera corretta
la sincronizzazione nell'accesso alla variabile condivisa.

Viene fornita la struttura TParam, che il main usa per passare le informazioni
necessarie ai worker thread.

******************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <pthread.h>
#include <stdbool.h>

#define WORKERS 5
#define LIMITE 40

/* Struttura dati usata per passare le informazioni ai worker */
typedef struct {
    int numero; /* Numero progressivo assegnato al worker */
    int *psomma; /* Puntatore alla variabile condivisa */
    pthread_mutex_t *pmutex; /* Puntatore al mutex per la sincronizzazione */
    pthread_cond_t *pcond;   /* Puntatore alla variabile condition */
} TParam;

/* Prototipo della funzione dei worker thread */
void *worker(void *);


int main(int argc, char *argv[]) {
    int somma = 0; /* La variabile da condividere con i worker */
    pthread_mutex_t mutex; /* Mutex per la sincronizzazione */
    pthread_cond_t  cond;  /* Variabile condition per la sincronizzazione */
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid[WORKERS];
    TParam param[WORKERS];
    int arg[WORKERS];
    int i;
    

    for(i=0; i<WORKERS; i++) {
        arg[i] = i;
        if (pthread_create(&tid[i], NULL, worker, &param[i]) != 0) {
            printf("Errore nella creazione thread\n");
            return -1;
        }
    }
    
    while(true) {
        pthread_mutex_lock(&param->pmutex);
        while(somma < LIMITE)
        pthread_cond_wait(&param->pcond, &param->pmutex);
        for(i=0; i < LIMITE; i++)
          somma+= arg[i];
        pthread_cond_signal(&param->pcond);
        pthread_mutex_unlock(&param->pmutex);

    for(i=0; i<WORKERS; i++)
        pthread_join(tid[i], NULL);
    
    return 0;
}
}



void *worker(void *param) {
    TParam *p = (TParam *)param;
    int i;
    
    while(true) {
        pthread_mutex_lock(&p->pmutex);
        while(i < WORKERS)
        pthread_cond_wait(&p->pcond, &p->pmutex);
        p->psomma = p->numero;
        printf("Il numero progressivo è %d", p->numero);
        printf("Il nuovo valore di somma è %d", p->psomma);
        pthread_cond_signal(&p->pcond);
        pthread_mutex_unlock(&p->pmutex);
    }
    
    return NULL;
}

[vict85]

Basta togliere il [inline]&[/inline] prima di [inline]param->pmutex[/inline]. Infatti [inline]pmutex[/inline] è già un puntatore. Stessa cosa per gli altri errori.

Dovresti imparare a leggere gli errori del compilatore. Non ho guardato se ci sono altri errori.

[giacomovicinanza]

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <pthread.h>
#include <stdbool.h>

#define WORKERS 5
#define LIMITE 40

/* Struttura dati usata per passare le informazioni ai worker */
typedef struct {
    int numero; /* Numero progressivo assegnato al worker */
    int *psomma; /* Puntatore alla variabile condivisa */
    pthread_mutex_t *pmutex; /* Puntatore al mutex per la sincronizzazione */
    pthread_cond_t *pcond;   /* Puntatore alla variabile condition */
} TParam;

/* Prototipo della funzione dei worker thread */
void *worker(void *);


int main(int argc, char *argv[]) {
    int somma = 0; /* La variabile da condividere con i worker */
    pthread_mutex_t mutex; /* Mutex per la sincronizzazione */
    pthread_cond_t  cond;  /* Variabile condition per la sincronizzazione */
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_t tid[WORKERS];
    TParam param[WORKERS];
    int arg[WORKERS];
    int i;
   

    for(i=0; i<WORKERS; i++) {
        arg[i] = i;
        if (pthread_create(&tid[i], NULL, worker, &param[i]) != 0) {
            printf("Errore nella creazione thread\n");
            return -1;
        }
    }
   
    while(true) {
        pthread_mutex_lock(param->pmutex);
        while(somma < LIMITE)
        pthread_cond_wait(param->pcond, param->pmutex);
        for(i=0; i < LIMITE; i++)
          somma+= arg[i];
        pthread_cond_signal(param->pcond);
        pthread_mutex_unlock(param->pmutex);

    for(i=0; i<WORKERS; i++)
        pthread_join(tid[i], NULL);
   
    return 0;
}
}



void *worker(void *param) {
    TParam *p = (TParam *)param;
    int i;
   
    while(true) {
        pthread_mutex_lock(p->pmutex);
        while(i < WORKERS)
        pthread_cond_wait(p->pcond, p->pmutex);
        p->psomma = p->numero;
        printf("Il numero progressivo è %d", p->numero);
        printf("Il nuovo valore di somma è %d", p->psomma);
        pthread_cond_signal(p->pcond);
        pthread_mutex_unlock(p->pmutex);
    }
   
    return NULL;
}

[giacomovicinanza]

Il problema che non mi stampa i valori

[vict85]

Anche senza analizzare in dettaglio il codice mi rendo conto che quel codice non ha nulla a che fare con l'eservizio richiesto. Infatti non vedo alcuno sleep nei worker. Inoltre i thread dovrebbero incrementare somma, non assegnare il loro valore.

Non ho mai usato la libreria pthread, quindi non sono un esperto, ma immagino dovresti fare qualcosa del tipo.

void *worker(void *param) {
    TParam *p = (TParam *)param;
   
    while(true) {
        sleep(1);
        pthread_mutex_lock(p->pmutex);
        if( p->psomma > 40 )
       {
             pthread_mutex_unlock(p->pmutex);
             break;
       }
        p->psomma += p->numero;
        printf("Il numero progressivo è %d", p->numero);
        printf("Il nuovo valore di somma è %d", p->psomma);
        pthread_cond_signal(p->pcond);
        pthread_mutex_unlock(p->pmutex);
    }
   
    return NULL;
}

Non ho guardato se funziona, ho scritto il codice più che altro per mostrare i passaggi.

[edit] avevo scritto al contrario la condizione del break, ho corretto.