[C-Linux] Sincronizzazione thread tramite eventi passando parametri

[das]

Sul web ho trovato questo esempio:

//global variables
/* STATE_A = THREAD A runs next, STATE_B = THREAD B runs next */
enum { STATE_A, STATE_B } state = STATE_A;
pthread_cond_t      condA  = PTHREAD_COND_INITIALIZER;
pthread_cond_t      condB  = PTHREAD_COND_INITIALIZER;
pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;

void *threadA()
{
    int i = 0, rValue, loopNum;

    while(i<5)
    {
        /* Wait for state A */
        pthread_mutex_lock(&mutex);
        while (state != STATE_A)
            pthread_cond_wait(&condA, &mutex);
        pthread_mutex_unlock(&mutex);

        //do stuff
        for(loopNum = 1; loopNum <= 5; loopNum++)
            printf("Hello %d\n", loopNum);

        /* Set state to B and wake up thread B */
        pthread_mutex_lock(&mutex);
        state = STATE_B;
        pthread_cond_signal(&condB);
        pthread_mutex_unlock(&mutex);

        i++;
    }

    return 0;
}

void *threadB()
{
    int n = 0, rValue;

    while(n<5)
    {
        /* Wait for state B */
        pthread_mutex_lock(&mutex);
        while (state != STATE_B)
            pthread_cond_wait(&condB, &mutex);
        pthread_mutex_unlock(&mutex);

        //do stuff
        printf("Goodbye\n");

        /* Set state to A and wake up thread A */
        pthread_mutex_lock(&mutex);
        state = STATE_A;
        pthread_cond_signal(&condA);
        pthread_mutex_unlock(&mutex);

        n++;
    }

    return 0;
}

Solo che non riesco a capire come sia possibile senza usare variabili globali passare un parametro dal thread A al B contestualmente alla segnalazione dell'evento.

Nello specifico il mio scopo sarebbe:
1- Il main genera dei thread di comunicazione con dei sensori
2- Il main rimane in attesa di un evento
3- Quando uno dei thread ha i dati pronti del suo sensore, sblocca il main passandogli un puntatore a quei dati.
4- Il main processa i dati e torna al punto 2

Mi sfugge il come si fa a passare i dati dal thread al main facendo sapere anche al main quale processo lo ha sbloccato.

[pabloski]

Per bloccare/sbloccare il main thread bastano le variabili di condizione. Pero' non vedo proprio come un thread possa passare dati al main senza usare variabili globali. Il thread ritorna un valore, ma quando termina, non prima.

[das]

Originariamente inviato da pabloski

Per bloccare/sbloccare il main thread bastano le variabili di condizione. Pero' non vedo proprio come un thread possa passare dati al main senza usare variabili globali. Il thread ritorna un valore, ma quando termina, non prima.

Mi spiego meglio:

attualmente ho un main thread di questo tipo:

int tipoEvento=0;

pthread_cond_wait(&cond, &m);
switch(tipoEvento):
case 1: elaboraDatidallaIMU
case 2: elaboraDatiTCP
case 3: elaboraDatiMetroLaser

Poi ho tre thread, ciascuno dei quali aspetta l'arrivo dei dati e quando succede imposta (all'interno dei lock-unlock ovviamente) tipoEvento= 1 o 2 o 3 a seconda del thread e sbloccano il main.

Vorrei poter fare a meno di tipoEvento. E' possibile fare in modo che il thread1 faccia saltare direttamente il main a elaboraDatidallaIMU, il 2 a elaboraDatiTCP etc ?


Grazie,
Ciao

[pabloski]

Capisco cosa volevi fare. In pratica usare le variabili di condizione alla stregua dei segnali. Il main thread setta un handler e poi riceve dei segnali dai thread worker, in base ai quali effettua un salto in un punto arbitrario del main stesso.

Potresti usare pthread_kill per inviare segnali da thread worker al main. Ma hai a disposizione SIGUSR1 e SIGUSR2, non di piu'. Altrimenti devi comunque usare una variabile in cui setti, prima di inviare un segnale, l'id del thread che l'ha inviato. E ovviamente poi ci vorrebbe un vettore per non perdere eventuali segnali sovrascritti prima che l'handler nel main li abbia rilevati. Mi sa che si complica ancora di piu'.

[das]

Originariamente inviato da pabloski

Capisco cosa volevi fare. In pratica usare le variabili di condizione alla stregua dei segnali. Il main thread setta un handler e poi riceve dei segnali dai thread worker, in base ai quali effettua un salto in un punto arbitrario del main stesso.

Potresti usare pthread_kill per inviare segnali da thread worker al main. Ma hai a disposizione SIGUSR1 e SIGUSR2, non di piu'. Altrimenti devi comunque usare una variabile in cui setti, prima di inviare un segnale, l'id del thread che l'ha inviato. E ovviamente poi ci vorrebbe un vettore per non perdere eventuali segnali sovrascritti prima che l'handler nel main li abbia rilevati. Mi sa che si complica ancora di piu'.

OK, ma gli altri linguaggi come fanno a generare gli eventi ?

Per esempio in Delphi/Lazarus basta usare Synchronize(nomeFunzioneDelMain) per eseguire una funzione a piacere nel main.

[pabloski]

Originariamente inviato da das

OK, ma gli altri linguaggi come fanno a generare gli eventi ?

Per esempio in Delphi/Lazarus basta usare Synchronize(nomeFunzioneDelMain) per eseguire una funzione a piacere nel main.

I dettagli implementativi non li conosco, ma suppongo si tratta di thread user-mode, per cui e' il runtime del linguaggio ad averne il controllo, ragion per cui puo' deviare facilmente il flusso da un thread all'altro.

Il problema e' che pthread non ti consente di saltare da un thread all'altro arbitrariamente. Ogni thread e' un flusso di esecuzione separato. Un salto da qualche parte non implicherebbe comunque entrare nel contesto di un altro thread.

L'unica possibilita' e' usare una qualche libreria di threading tipo grand central dispatch.

C++ lo consente tramite async, ma non mi pare ci sia un equivalente meccanismo POSIX.

[das]

Originariamente inviato da pabloski

I dettagli implementativi non li conosco, ma suppongo si tratta di thread user-mode, per cui e' il runtime del linguaggio ad averne il controllo, ragion per cui puo' deviare facilmente il flusso da un thread all'altro.

Il problema e' che pthread non ti consente di saltare da un thread all'altro arbitrariamente. Ogni thread e' un flusso di esecuzione separato. Un salto da qualche parte non implicherebbe comunque entrare nel contesto di un altro thread.

L'unica possibilita' e' usare una qualche libreria di threading tipo grand central dispatch.

C++ lo consente tramite async, ma non mi pare ci sia un equivalente meccanismo POSIX.

OK, grazie