[unix c#] processi figli

[*MATRIX*]

ciao raga

dovrei creare 2 processi figli dallo stesso padre utilizzando la funzione fork

se faccio

pid_t figlio1, figlio2;

figlio1 = fork();
figlio2 = fork();

me li crea ma mi crea anche due padri diversi guardando il pid con getpid()

come posso risolvere?

[DanieleC88]

Questo è codice C#? :D

Be' se prima non controlli di essere il padre, quella seconda fork() la fa anche il processo figlio, o sbaglio? :p

[*MATRIX*]

come si fa a controllare di avere un solo padre?

[..::DAVE::..]

if(figlio1==0)
{//sei nel figlio
}
else
{//sei nel padre
}

[DanieleC88]

No, aspetta, ricapitoliamo come funziona la fork(): la chiami e leggi il valore di ritorno, a quel punto dovrai capire 1) se l'operazione è andata a buon fine, nel qual caso devi anche controllare 2) se il tuo processo attuale è il processo padre o se è il figlio.

Quindi, una cosa tipo:
pid_t nProcessID = fork();

switch (nProcessID)
{
case -1:
/* errore */
exit(EXIT_FAILURE);

case 0:
/* processo figlio */
break;

default:
/* processo padre */
break;
}

Questi controlli li puoi fare ovviamente anche con degli if, che forse ti saranno più comodi per altre cose.
In poche parole, una volta sdoppiato il processo padre, puoi fare una seconda fork() come padre per avere due figli (o come figlio, perché abbia a sua volta un processo figlio).

Scusa la curiosità, ma perché devi fare due fork() in quel modo?

[*MATRIX*]

a che mi serve? per esercitarmi nelle fork è un pezzettino di un maxi esercizio

cmq non ho capito nulla su come creare due figli da un solo processo padre


io già avevo creato un processo

facendo così ho uno figlio e uno padre

io ho bisogno di due figlii dello stesso padre

se faccio una seconda fork avrò un altro padre

come risolvere?

int main()
{
figlio = fork();

if (figlio==0)
{
printf("PROCESSO FIGLIO 1 ");
printf(" PID figlio1 %d\n",getpid());
}

else if (figlio>0)
{

printf("processo padre ");
printf("PID padre 1 %d\n",getpid());
}

[DanieleC88]

Prova questo, un po' di ricorsione e puoi creare N_MASSIMO figli:
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#define N_MASSIMO 2
void CreaFigli(unsigned int);

int main()
{
CreaFigli(0);
return EXIT_SUCCESS;
}

void CreaFigli(unsigned int uCount)
{
pid_t nProcessID;

if (uCount >= N_MASSIMO) {
return;
}

++uCount;
nProcessID = fork();
if (nProcessID == -1) {
fprintf(stderr, "ERRORE! Numero di figli precedentemente creati: %u.\n", uCount);
exit(EXIT_FAILURE);
}

/* Se sono nel processo padre */
if (nProcessID > 0) {
printf(" [!!] Mio figlio ha l'ID %d.\n", nProcessID);

CreaFigli(uCount);

waitpid(nProcessID, NULL, 0);
}
/* Se sono nel processo figlio */
else {
printf(" -> Sono il figlio numero %u.\n", uCount);
}
}

[arara]

cmq non ho capito nulla su come creare due figli da un solo processo padre



// Qua sei nel parent.

// Crei il primo child:
if ( fork()==0 ) {
// Qua sei nel primo child, esegui il suo codice
codiceFiglio1();

// Quando il child finisce, esci.
return;
}

// Qua il parent continua ad andare avanti per conto suo.
// Questo codice non viene eseguito dal primo child, a causa del return.

// Creo il secondo child:
if ( fork()==0 ) {
// Come prima...
codiceFiglio2();
return;
}

// Qua sei sempre nello stesso parent di prima...

[Piojolopez2406]

guarda il discorso è molto piu semplice di quanto pare, per creare 2 figli dello stesso padre devi fare in questa maniera:

int main ()
{

pid_t pid1,pid2;

if ((pid1=fork())==0)
{
//qui entri se la creazione del primo figlio va a buon fine
}
if((pid2=fork())==0)
{
//qui entri se la creazione del seconod figlio va a buon fine
}
//e qui c'è il codice del padre
}


te lo scritto in maniera molto semplice ma eventualmente potresti mettere degli ulteriori if per controllare qualora la creazione dei figli non andasse a buon fine.
Ma cmq il succo della questione è che facendo le 2 fork una immediatamente dopo l'altra praticametne è come se creassi un terzo figlio.

[*MATRIX*]

si però se volessi crare 50 processi devo dichiarare 50 pid?

con il for come si potrebbe fare tenendo presente che ogni processo fa una cosa diversa?

[arara]

Se devi far eseguire delle operazioni diverse a ognuno dei 50 child ti conviene mettere il codice che fa la fork dentro a una funzione e richiamarla passandoli come argomento la funzione col codice da far eseguire, tipo cosi:

createNewChild(&pid1, function1);
createNewChild(&pid2, function2);
createNewChild(&pid3, function3);
...

[*MATRIX*]

Se devi far eseguire delle operazioni diverse a ognuno dei 50 child ti conviene mettere il codice che fa la fork dentro a una funzione e richiamarla passandoli come argomento la funzione col codice da far eseguire, tipo cosi:

createNewChild(&pid1, function1);
createNewChild(&pid2, function2);
createNewChild(&pid3, function3);
...

però dovrei dichiarare da pid1 a pid50

quindi poi chiamare delle sottofunzioni per ogni pid

[arara]

potresti fare una cosa de genere:

//esempi di funzioni da far eseguire ai child:
void print() { ... }
void clear() { ... }
void reset() { ... }
void start() { ... }
void stop() { ... }

int createNewChild( void (*function)(void) ) {
pid == fork();
if (pid) {
// se è il child esegue la funzione.
function();
}
// se è il parent esce senza far niente e va avanti con gli altri.
return pid;
}

int main() {
createNewChild( print );
createNewChild( clear );
createNewChild( reset );
createNewChild( start );
createNewChild( stop );
...
}


Se il pid non ti serve nel resto del programma puoi anche scartarlo, tanto la funzione si arrangia da sola.

[DanieleC88]

però dovrei dichiarare da pid1 a pid50
Non basta un'array con un contatore incrementato durante il ciclo? ;)

[*MATRIX*]

nt createNewChild( ) {
pid == fork();
if (pid) {
printf(" PID CREZIONEfiglio 1 %d\n",getpid());
}
// se è il parent esce senza far niente e va avanti con gli altri.
return pid;
}

int main() {
createNewChild( );
createNewChild( );

}

dove sbaglio?

voglio creare due processi figli che mi visualizzano il loro pid

[DanieleC88]

if (pid) {

Qui. :D
Lì la condizione è vera solo se pid non è 0, cioè se la fork() fallisce o se sei nel genitore.

[arara]

Qui. :D
Lì la condizione è vera solo se pid non è 0, cioè se la fork() fallisce o se sei nel genitore.

colpa mia che avevo scritto sta castroneria :asd::

int createNewChild( void (*function)(void) ) {
pid == fork();
if (pid) {
....
}


cosi funziona:

#include <stdio.h>
#include <stdlib.h>

//esempi di funzioni da far eseguire ai child:
void print() { printf("printing...\n"); }
void clear() { printf("clearing...\n"); }
void reset() { printf("resetting...\n"); }
void start() { printf("starting...\n"); }
void stop() { printf("stopping...\n"); }

int createNewChild( void (*function)(void) ) {
int pid = fork();
if (pid==0) {
// se è il child esegue la funzione.
function();
// quando il child finisce deve terminare, seno va avanti e lancia a sua volta gli altri child...
exit(0);
}
// se è il parent esce senza far niente e va avanti con gli altri.
return pid;
}

int main() {
createNewChild( print );
createNewChild( clear );
createNewChild( reset );
createNewChild( start );
createNewChild( stop );
return;
}

[*MATRIX*]

ok grazie adesso ho capito cosa fare con i processi