[C/C++] problemi coi thread

[misterx]

ciao,
ho due thread che ho chiamato come di consueto PRODUTTORE e CONSUMATORE.

Il produttore popola una array mentre come viene ovvio pensare CONSUMATORE lo usa.

Ho settato una variabile semaforica in modo che il CONSUMATORE non può accedere all'array sino a quando questo non è aggiornato completamente e da qui il problema: come faccio a fare in modo che l'aggiornamento non avvenga a CPU time ma ad esempio ogni 50 ms mentre il consumatore fa la sua parte ogni 250 ms ?

Essendoci in mezzo il semaforo se ritardo il produttore di conseguenza ritardo anche il consumatore ma desidererei tenere separati i due thread in modo che i rispettivi "lavori" avvengano in tempi differenti per mantenendo i vincoli dell'accesso all'array da parte del consumatore.

grazie

[misterx]

edit

[banryu79]

Risposta banale (spero di non suggerirti cavolate): fai eseguire a entrambi i thread (quando non hanno il lock sull'array ovviamente) una sleep; prodottore dormirà 50ms, consumatore dormirà 250ms.

[misterx]

Originariamente inviato da banryu79

Risposta banale (spero di non suggerirti cavolate): fai eseguire a entrambi i thread (quando non hanno il lock sull'array ovviamente) una sleep; prodottore dormirà 50ms, consumatore dormirà 250ms.

ho provato questa strada ma mi sonon accorto che i due thread attendenndo reciprocamente il semaforo verde, sono soggetti entrambi al tempo più lungo.
Magari è la mia implementazione ad essere bacata.

semaforo=0;
thread_1
{
         if(semaforo==0)
         {
                popola array;
        }
        semaforo=1;
}

thread_2
{
         if(semaforo==1)
         {
                consumaa array;
        }
        semaforo=0;
}

[marco.r]

Originariamente inviato da misterx

ciao,
ho due thread che ho chiamato come di consueto PRODUTTORE e CONSUMATORE.

Il produttore popola una array mentre come viene ovvio pensare CONSUMATORE lo usa.

Ho settato una variabile semaforica in modo che il CONSUMATORE non può accedere all'array sino a quando questo non è aggiornato completamente e da qui il problema: come faccio a fare in modo che l'aggiornamento non avvenga a CPU time ma ad esempio ogni 50 ms mentre il consumatore fa la sua parte ogni 250 ms ?

Essendoci in mezzo il semaforo se ritardo il produttore di conseguenza ritardo anche il consumatore ma desidererei tenere separati i due thread in modo che i rispettivi "lavori" avvengano in tempi differenti per mantenendo i vincoli dell'accesso all'array da parte del consumatore.

grazie

Il produttore gira a frequenza quadrupla rispetto il consumatore: va bene che il produttore acceda solo alla versione piu' recente, e "perda" le tre precedenti ? O deve poter accedere anche alle elaborazioni intermedie ?

Nell'ipotesi che sia vera la prima affermazione, e' relativamente semplice:
devi avere due scheduler distinti nel primo e secondo thread. Uno impostato a 250ms e l'altro a 50ms. Se il tuo ambiente non te fornisce si puo' crearne uno a base di (sotto unix) clock_gettime e clock_nanosleep (o le equivalenti sotto windows). Devi solo tenere presente che non puoi fare semplicemente una sleep di 50ms, ma devi tenere conto di quanto dura il singolo loop
Fatto questo, non devi far altro che fare una cosa come la seguente:

// producer
scheduler sched(50000); // usec
while(!done)
{
    do_something();
    lock_array();
    perform_changes();
    unlock_array();
    sched.wait_next();
}

// consumer
scheduler sched(250000); // usec
while(!done)
{
    lock_array();
    read_changes();
    unlock_array();
    do_something_else();
    sched.wait_next();
}

Tieni presente che idealmente devi solo copiare i dati necessari da/verso l'array, mentre lo blocchi. Non vuoi che il produttore aspetti 250ms frattanto che il consumatore fa i cavoli suoi bloccandoti l'array.

[marco.r]

Originariamente inviato da misterx

ho provato questa strada ma mi sonon accorto che i due thread attendenndo reciprocamente il semaforo verde, sono soggetti entrambi al tempo più lungo.
Magari è la mia implementazione ad essere bacata.

semaforo=0;
thread_1
{
         if(semaforo==0)
         {
                popola array;
        }
        semaforo=1;
}

thread_2
{
         if(semaforo==1)
         {
                consumaa array;
        }
        semaforo=0;
}

Come dicevo sopra devi tenere bloccato l'array per il tempo minimo per copiare i dati. Meglio ancora, invece di usare un semafoto usa qualcosa di piu' alto livello tipo una coda di messaggi, e ottieni questo quasi automaticamente (ed il codice e' piu' pulito).

[misterx]

grazie marco.r

quello che interessa a me è avere sempre l'array aggiornato ma impedire che il consumatore vi acceda se non è stato completamente aggiornato.

Il semaforo risponde allo scopo ma i due thread viaggiano sincroni anzi, il più lento "rallenta" quello più veloce.

Sto sviluppando in Borland Builder C++

[marco.r]

Originariamente inviato da misterx

grazie marco.r

quello che interessa a me è avere sempre l'array aggiornato ma impedire che il consumatore vi acceda se non è stato completamente aggiornato.

Il semaforo risponde allo scopo ma i due thread viaggiano sincroni anzi, il più lento "rallenta" quello più veloce.

Sto sviluppando in Borland Builder C++

Perche' per come usi tu il semaforo, il produttore aspetta che il consumatore abbia eseguito il suo loop.
Come ti suggerisco io invece, con u nsemplice lock, il produttore puo' bloccare/sbloccare l'accesso all'array quante volte vuole, ma essendo sincronizzato, cmq produttore e consumatore non possono accedervi contemporaneamente
per usare la tua notazione, dovresti usare qualcosa tipo

semaforo=0;
thread_1
{
    popola_array();
    sem_post(semaforo);
    while( ... )
    {
        aspetta prossimi 50ms
        sem_wait(semaforo);
        popola array;
        sem_post(semaforo);
    }
}

thread_2
{
    while( ... )
   {
        aspetta prossimi 250ms
        sem_wait(semaforo);
        consumaa array;
        sem_post(semaforo);
    }
}

[misterx]

Originariamente inviato da marco.r

Perche' per come usi tu il semaforo, il produttore aspetta che il consumatore abbia eseguito il suo loop.
Come ti suggerisco io invece, con u nsemplice lock, il produttore puo' bloccare/sbloccare l'accesso all'array quante volte vuole, ma essendo sincronizzato, cmq produttore e consumatore non possono accedervi contemporaneamente
per usare la tua notazione, dovresti usare qualcosa tipo

semaforo=0;
thread_1
{
    popola_array();
    sem_post(semaforo);
    while( ... )
    {
        aspetta prossimi 50ms
        sem_wait(semaforo);
        popola array;
        sem_post(semaforo);
    }
}

thread_2
{
    while( ... )
   {
        aspetta prossimi 250ms
        sem_wait(semaforo);
        consumaa array;
        sem_post(semaforo);
    }
}

non mi è chiara la tua implementazione di sem_wait(semaforo); e sem_post(semaforo);

int array[100];

thread_1
{
       while(1)
       {
          Sleep(50);
          for(i=0; i<100; i++)
          array[i]=rand();
        }
}

thread_2
{
       while(1)
       {
          Sleep(250);
          for(i=0; i<100; i++)
          printf("%d\n",array[i]);
        }
}

una cosa di questo tipo credo sia fuori controllo in quanto non saprei quando verranno eseguiti i due thread

[misterx]

ora ho capito cosa intendevi, così funziona molto bene

int array[100];

thread_1
{
       while(1)
       {
          sem=0;          
          for(i=0; i<100; i++)
          array[i]=rand();
          sem=1;
          Sleep(50);
        }
}

thread_2
{
       while(1)
       {
          if(sem==1)
          {
          for(i=0; i<100; i++)
          printf("%d\n",array[i]);
        }
         Sleep(250);
        }
}

[marco.r]

Non puoi usare una semplice variabile per la sincronizzazione. Innanzi tutto non puoi garantire che l atray venga copiato ogni 250 ms. Perché invece di attendere che venga finita la scrittura dal produce, aspetti la volta dopo. Potenzialmente se hai sfoga la copia non avviene mai. Peggio ancora eventuali ottizzazioni del compilatore possono causare problemi di sincronizzazione del valore del semaforo tra due thread.
Invece che un intero usa un semaforo vero e proprio o più precisamente un mutex. Li trovi tra le api di windows

[misterx]

ed haai ragione. Funzionava meglio la prima implementazione mentre questa seconda potrebbe avvenire che il produttore porta a termine sempre il suo compito ma quando termina e parte il consumatore, se il thread consumatore finisce il suo quantum di tempo a disposizione, si torna al produttore che inibisce il funzionamento del consumatore

non ho mai usato i mutex

[misterx]

ciao,
non sono molto convinto di come sto usando i mutex

int array[100];

/* PRODUTTORE */

hMutex=CreateMutex(NULL, FALSE,NULL);
while(.....)
{
               WaitForSingleObject(hMutex,INFINITE);

               for(int i=0; i<100; i++)
               array[i]=rand();

               ReleaseMutex(hMutex);
              Sleep(50);

}


/* CONSUMATORE */

hMutex=CreateMutex(NULL, FALSE,NULL);
while(.....)
{
               WaitForSingleObject(hMutex,INFINITE);

               for(int i=0; i<100; i++)
               printf(%d\n,array[i]);

               ReleaseMutex(hMutex);
              Sleep(250);

}

funziona a questo modo ?
Come lo verifico ?

grazie 1000

[marco.r]

Originariamente inviato da misterx

ciao,
non sono molto convinto di come sto usando i mutex

Devi usare lo stesso mutex, oppure crearlo "named"(non ho idea di come si faccia sotto windows) usando lo stesso nome in entrambi i thread.

[misterx]

ma va creato un mutex globale allora ?

Oppure si crea un mutex PRODUTTORE e lo si usa in consumatore e viceversa?

Non mi è chiaro il meccanismo

[marco.r]

Ti serve un unico mutex. Concettualmente e'come la variabile intera che usavi tu, solo che e' implementata opportunamente.

[misterx]

ho fatto cisì e sembra funzionare

int array[100];
hMutex=CreateMutex(NULL, FALSE,NULL);

/* PRODUTTORE */


while(.....)
{
               WaitForSingleObject(hMutex,INFINITE);

/* SEZIONE CRITICA */

               for(int i=0; i<100; i++)
               array[i]=rand();

/* FINE SEZIONE CRITICA */

               ReleaseMutex(hMutex);
              Sleep(50);

}


/* CONSUMATORE */

while(.....)
{
               WaitForSingleObject(hMutex,INFINITE);

/* SEZIONE CRITICA */

               for(int i=0; i<100; i++)
               printf(%d\n,array[i]);

/* FINE SEZIONE CRITICA */

               ReleaseMutex(hMutex);
              Sleep(250);

}

difatti se a PRODUTTORE o a CONSUMATORE elimino ReleaseMutex(hMutex); l'altro thread non viene mai eseguito.

Mi chiedo però se la parte di codice sottostante a WaitForSingleObject(hMutex,INFINITE); viene eseguita completamente sino al ReleaseMutex(hMutex); ?

[marco.r]

Originariamente inviato da misterx

Mi chiedo però se la parte di codice sottostante a WaitForSingleObject(hMutex,INFINITE); viene eseguita completamente sino al ReleaseMutex(hMutex); ?

Non sono sicuro di aver capito cosa intendi dire.
Se e' quel che penso io, la risposta e' si', ovvero quando tu chiami WaitForSingleObject e qualcun altro l'ha gia' fatto, il thread resta in attesa finche' l'altro non chiama ReleaseMutex.
per cui solo uno alla volta dei due thread esegue la parte tra le due chiamate.

[misterx]

Originariamente inviato da marco.r

Non sono sicuro di aver capito cosa intendi dire.
Se e' quel che penso io, la risposta e' si', ovvero quando tu chiami WaitForSingleObject e qualcun altro l'ha gia' fatto, il thread resta in attesa finche' l'altro non chiama ReleaseMutex.
per cui solo uno alla volta dei due thread esegue la parte tra le due chiamate.

hai capito benissimo, grazie per la conferma.

[misterx]

c'è un aspetto che non avevo considerato: se ora devo riordinare in tempo reale una parte dell'array prima che venga usato da "consumatore" devo usare mutex ed un nuovo thread vero?