[Sistemi Operativi, C] Processi

[Xemitron]

Salve, dovrei scrivere un programma C in cui un padre genera 4 figli, di cui 3 fanno la stessa cosa e ognuno dei tre comunica in un modo diverso con il quarto fratello(tipo il primo tramite socket, il secondo con pipe, il terzo con memoria condivisa).

Io starei lavorando in questo modo:

pid_t pid[4]

for(int i=0;i<4;i++){
if(pid[i]=fork()==0){
// produce risultato
if(i==0){
// comunica risultato tramite socket
}
if(i==1){
// comunica risutato con pipe
}
if(i==2){
// comunica risultato con memoria condivisa
}
if(i==3){
// riceve messaggi dai tre processi e ci fa qualcosa
}
}
}


Ecco, non sono sceso nei particolari del programma, ma più o meno può andar bene una struttura del genere? Perchè ho qualche dubbio...

[apatriarca]

Scrivere un ciclo per poi scomporre il comportamento per ogni iterazione mi sembra un po' inutile. Ha più senso avere qualcosa tipo:

Codice:

if (pid[0] == fork() == 0) {
    // figlio 1
}

if (pid[1] == fork() == 0) {
    // figlio 2
}

if (pid[2] == fork() == 0) {
    // figlio 3
}

if (pid[3] == fork() == 0) {
    // figlio 4
}


[Xemitron]

(Ovviamente nella condizione di ogni if il primo operatore è un assegnamento, non l’uguaglianza, giusto?)

Comunque in questo caso dovrei ripetere lo stesso codice per tutti gli if, cioè per tutti i figli, eccetto il modo con cui comunicano col quarto fratello?

[apatriarca]

Certo, il primo operatore avrebbe dovuto essere l'assegnamento ma l'ho scritto un po' di fretta. Per il codice comune puoi usare una o più funzioni per rimuovere la duplicazione del codice.

[Xemitron]

Salve, innanzitutto grazie per le risposte e mi scuso per il ritardo con cui ritorno qui ma sono stato impegnato con altro. Ritornando al mio problema di inizio post, spiego meglio cosa dovrebbe fare... Ognuno dei primi tre processi una volta al secondo deve leggere una riga da un file e inviarla secondo la sua modalità al quarto. E' giusto pensarla così?

Codice:

for(int i=0;i<4;i++){
      pid[i]=fork();
   }

while(fgets...!=null){
        if(pid[0]==0){
                 sleep(1)
                 // comunica con socket la riga
        }
        if(pid[1]==0){
                 sleep(1)
                // comunica con pipe la riga
        }
        if(pid[2]==0){
                sleep(1)
                // comunica con memoria condivisa
        }
        if(pid[3]==0){
                sleep(1)
                // riceve in ordine con socket, pipe e memoria
        }
}

Oppure ogni processo dovrebbe avere il ciclo per scandire il file al suo interno?

[apatriarca]

Rileggendo la discussione mi rendo conto di come abbia risposto un po' di fretta. Il tuo modo di generare i figli non è corretto. Stai infatti generando molti più figli di quanto pensi. La prima iterazione del ciclo viene eseguita una sola volta, ma la seconda viene eseguita da due processi, la terza da quattro e la quarta da otto. È quindi necessario assicurarsi che il fork sia lanciato dal solo primo processo. Un modo è il seguente:

Codice:

if (pid[0] = fork() == 0) {
    // codice per il primo figlio
} else if (pid[1] = fork() == 0) {
    // codice per il secondo figlio
} else if (pid[2] = fork() == 0) {
    // codice per il terzo figlio
} else if (pid[2] = fork() == 0) {
    // codice per il quarto figlio
} else {
    // codice per il processo padre
}


Volendo usare un ciclo puoi fare qualcosa come segue:

Codice:

int child_id = -1;
for (int i = 0; i < 4; ++i) {
    pid[i] = fork();
    if (pid[i] == 0) {  // se è il figlio
        child_id = i;
        break;  // esco dal ciclo così solo il padre chiamerà il fork successivo
    }
}

// qui puoi scrivere il test basato su child_id uguale a 0, 1, 2 o 3


[Xemitron]

Capito. Per quanto riguarda l’altro dubbio... Dato che ogni processo deve scandire un file e comunicare riga per riga una volta al secondo, quindi userei un ciclo while, dovrei inserirlo nel codice di ogni processo oppure posso inserire i test dei vari figli in un unico ciclo?

[apatriarca]

Se usi il secondo metodo descritto puoi usare un singolo ciclo, se no devi avere 4 cicli separati.