[C] funzione di controllo

[Stefania84]

Salve a tutti,

sono nuova nel forum ed ho un problema. Supponiamo di avere due funzioni, chiamiamole A e B. A dovrà abilitare B sotto controllo. Ovvero, ci sarà un indice binario posto ad 1 da A e solo in questo caso viene richiamata la B. Dopodichè l'indice verrà riportato a 0. Qualcuno mi può dare un aiuto? Grazie. Ciao.

[Andrea Simonassi]

Non ho capito tanto bene il problema.

Ovvero, ci sarà un indice binario posto ad 1 da A e solo in questo caso viene richiamata la B

Chi chiama A? E cosa vuol dire "solo in questo caso viene richiamata la B" ? anzi cosa vuol dire "viene richiamata B"? richiamata da chi?

Si potrebbe risolvere con un mutex per evitare problemi di race condition.

Suppongo che stiamo parlando di programmazione multithreading altrimenti non si porrebbe nemmeno il problema, in tal caso basterebbe mantenere una variabile globale.

[Stefania84]

Ciao, grazie per aver risposto.
Provo a spiegare meglio, che sono stata poco chiara.
Vorrei creare due funzioni che agiscano come processi paralleli. Ovvero, solo quando una funzione ha completato il suo compito può partire la seconda. E questo lo vorrei fare con un indice binario, che vale uno quando la seconda può partire e poi rimesso a zero. Cioè se dovessi controllare se è stato raggiunto un certo valore e quindi chiamare la seconda lo saprei fare, ma ora il controllo lo devo fare tenendo conto se è stata o meno terminata una funzione. Non so se mi sono spiegata un po' di più...

[MItaly]

Stai parlando di programmazione multithreading? In tal caso la cosa corretta sarebbe utilizzare un semaforo. D'altra parte tutto questo mi pare inutile, visto che per far partire B dopo che A è terminata basta fare

A();
B();

.

[Andrea Simonassi]

Molto più chiaro adesso.

Scusa se vado di fretta nella risposta, l'argomento mi piace ma non ho tantissimo tempo.

Devi utilizzare delle primitive fornite dal sistema operativo che permettano la comunicazione di processi paralleli.

Purtroppo il C come linguaggio non fornisce assolutamente dei meccanismi di sincronizzazione, a differenza di molti linguaggi moderni come ad esempio Java.

Ad ogni modo ogni sistema operativo fornisce delle librerie multithreading di comunicazione / sincronizzazione tra processi.

Uno dei più noti meccanismi di sincronizzazione è chiamato MUTEX.

un MUTEX è un intero che può avere due valori, Acceso/Spento, 1/0 quello che vuoi.

Il sistema operativo mette a disposizione delle funzioni per governare questo mutex e garantisce che queste operazioni siano ATOMICHE, ovvero se un processo chiede accesso ad un MUTEX tutti gli altri non possono accedervi fintanto che l'insieme di operazioni necessarie alla gestione del MUTEX non sono completate, mentre invece se tu controlli una variabile globale con un meccanismo tipo semaforo=semaforo+1 in assembly avrai una roba del tipo

1) Carica semaforo in un registro
2) In un altro registro metti 1
3) Somma i registri
4) Trasferisci in memoria

... il sistema operativo potrebbe interrompere il tuo processo con conseguenze disastrose dopo ogni istruzione assembly.

Ogni SO ha le sue chiamate che non sono mai compatibili con gli altri sistemi, quindi per aiutarti bisognerebbe sapere su che sistema lavori.

Ad ogni modo in teoria le funzioni sono di solito del tipo:

MUTEX m = CreaUnMutex("Nome del Mutex", StatoIniziale);
MUTEX m = ApriUnMutex("Nome Del Mutex");
RichiediMutex(MUTEX m);
RilasciaMutex(MUTEX m);
EliminaMutex (m);

il tuo codice sarà del tipo:

MUTEX m;

int main(...)
{...
   MUTEX b = CreaUnMutex("B aspetta A", BLOCCATO);
   MUTEX a = CreaUnMutex("A aspetta B", APERTO);
   Processo A = LanciaIlProcesso(FuncA);
   Processo B = LanciaIlProcesso(FuncB);
   ... 
   AttendiFineDelProcesso(A);
   AttendiFineDelProcesso(B);
   EliminaIlMutex(a);
   EliminaIlMutex(b);
}

int FuncA()
{
     MUTEX a = ApriUnMUtex("A aspetta B");
     MUTEX b = ApriUnMUtex("B aspetta A");
    while(condizione){

    Faccio_le_cose_che_posso_fare_in_parallelo_con_B();
/*
aspetto che B finisca l'elaborazione precedente
*/
        RichiediIlMutex(a); 
/*
se sono in questo punto significa che B ha finito di lavorare e sta lavorando solo A
*/
        ...
        FaiQualcheElaborazione
        .  ..
        RilasciaIlMutex(b); // faccio partire B 
    }
}

int FuncB()
{
     MUTEX a = ApriUnMUtex("A aspetta B");
     MUTEX b = ApriUnMUtex("B aspetta A");
     while(condizione){

    Faccio_le_cose_che_posso_fare_in_parallelo_con_A();
          /*
aspetto che A finisca l'elaborazione precedente
*/
          RichiediIlMutex(b); 
        /* A questo punto A ha finito la sua elaborazione quindi non sta girando*/
        FaccioLeCoseCheDevoFareSoloDopoCheAHaFinito();
         RilascioIlMutex(a);
      }
}

//Salvo miei errori ed omissioni :D

Qua trovi una generalizzazione del classico problema del produttore e del consumatore con N produttori (nel tuo caso il processo A) ed M consumatori (nel tuo caso il processo B)

http://it.wikipedia.org/wiki/Problem...re/consumatore

[Stefania84]

Grazie mille!!! Scusatemi se per farmi capire ce ne ho voluto... ora penso di saper risolvere. Grazie! Ciao.