Newsgroup: it.comp.lang.c
Titolo: Variabile intera condivisa tra pr. padre e n pr. figli

Ciao a tutti,
so che molto probabilmente questo è il newsgroup sbagliato, ma
provando a postare su "it.comp.linux.development", ottengo il
messaggio:
I seguenti gruppi usenet sono archiviati e non è possibile postare su
di essi: "it.comp.linux.development"
Vi spiego il mio problema:
per studio devo fare un programma che utilizza praticamente tutto ciò
che riguarda la gestione dei processi più l'IPC.
Vi metto un semplice listato che illustra a grandi linee il mio
programma e poi spiego bene il mio problema/dubbio:
-8<----------------------------------------------------------------------
#define        MAX        5
int main(int argc, char *argv[])
{
    int x = 0;
    while (1)
    {
        int pid = fork();
        if (pid==(-1))
        {
            exit(1);
        }
        else if (pid==0) /* figlio */
        {
	    if (x<MAX)
            {
                /* qui fa una serie di cose */
                x++;
            }
            else
            {
                /* altrimenti qui ne fa altre */
            }
            printf("Valore: %d\n", x);
            exit(0);
        }
        else /* padre */
        {
            w = wait(0);
            printf("Valore: %d\n", x);
        }
    }
}
-8<----------------------------------------------------------------------
Ecco, in sostanza, il problema è che x, ad ogni printf, è sempre 0 o
tuttalpiù 1, ovvero non viene incrementata (ad esempio io avrei
bisogno che, se vengono creati 8 processi figli, alla fine x fosse
uguale a 4, vista la condizione "minore di MAX").
Cosa dovrei fare per poter lavorare sulla stessa variabile da più
processi figli? Io ho pensato ad un segmento di memoria condivisa, o
eventualmente di appoggiarmi ad un file che ad ogni iterazione aggiorna
il valore di x, ma mi sembrano soluzioni un po' "estreme"... Non c'è
un metodo più semplice e rapido per poter lavorare sulla stessa
variabile? Magari un modo per esternarla, visto che il motivo per cui
ad ogni fork essa torna ad essere 0 è dovuto al fatto che ogni figlio
eredita una copia delle variabili del padre (per questo presumo che x
venga ogni volta ereditata uguale a 0, giusto?).
Grazie per ogni prezioso aiuto!

 processi figli? Io ho pensato ad un segmento di memoria condivisa
Può essere giusta la scelta di usare la memoria condivisa, prestando la
dovuta attenzione alle questioni di sincronizzazione e locking. 
Certamente era giusta la scelta di non ricorrere a questo newsgroup. Memoria
condivisa, fork, figli, padri son tutti concetti che non appartengono al
linguaggio C.
Consiglio: prima di sottoporre a un newsgroup una questione così generale,
come quella della comunicazione e condivisione di informazioni tra
processi, è meglio cercare di farsi una cultura, leggendo tutorial, FAQ e
quant'altro offra la rete (che è tanto, se uno cerca un pochino), oppure
comprandosi un buon libro.
Max

Grazie per la risposta.
Mi sono dimenticato di precisare che la cultura di base ce l'ho (e ho
già letto molta documentazione), so usare piuttosto bene semafori,
memoria condivisa e code di messaggi, ma volevo sapere se esiste un
sistema più immediato per un problema così, in un certo senso,
"insulso".
Soprattuto perchè ho una traccia dell'esercizio da svolgere, e dovrei
rispettare le linee guida ovvero: usare una sola coda di messaggi tra
diversi processi, usare una sola area di memoria condivisa per un certo
tipo di dati (che assolutamente non contemplano quella dannata
variabile), più un set di semafori.
Inoltre quella variabile sarà spesso utilizzata come indice di un
array di stringhe, e trovo esagerato dover ogni volta prestare
attenzione a sincronizzazione e locking per delle operazione quasi
atomiche :-)
Comunque, se proprio non ci sono soluzioni alternative (ne ho giù
provate diverse, ma sempre invano), userò la shmem.
Un saluto e grazie comunque!

Grazie, ci avevo pensato anch'io!
Il problema è che la fork avviene data una certa condizione iniziale,
ma la variabile deve necessariamente essere gestita da un figlio che
gestisce una specifica richiesta (che gli viene passata dal padre). In
sostanza è un demone dove i figli lavorano e il padre resta in
ascolto. E io non posso lavorare sulla variabile dal padre, ma solo dal
figlio, perchè il padre non può sapere quali operazioni i figli
faranno in seguito in base a certe condizioni.
Credo che userò la shared memory come a suggerito Max...
Ciao e grazie!