[C] Il tempo di una... fork()...

[Ed_Bunker]

Ciao, vorrei sapere se, volendo calcolare il tempo necessario per effettuare una fork(), e' indifferente far terminare immediatamente o meno il figlio nato dalla fork stessa.
Ovvero: questi 2 modi di calcolare il tempo di fork si "equivalgono" ?

Modo 1:

int pid;
long int forkTime;

struct timeval * start = (struct timeval*) malloc(sizeof(struct timeval));
struct timeval * end =  (struct timeval*) malloc(sizeof(struct timeval));

gettimeofday(start, NULL);

pid = fork();/*Ometto il controllo sull'errore per brevita'...*/
if (pid == 0)
   exit(EXIT_SUCCESS);
/*Qui arriva solo il padre*/

gettimeofday(end, NULL);

forkTime = (end->tv_sec - start->tv_sec) * 1000000 + (end->tv_usec - start->tv_usec); /*Tempo in microsecondi/*

free(start);
free(end);

Modo 2:

 
int pid;
long int forkTime;

struct timeval * start = (struct timeval*) malloc(sizeof(struct timeval));
struct timeval * end =  (struct timeval*) malloc(sizeof(struct timeval));

gettimeofday(start, NULL);

pid = fork();/*Ometto il controllo sull'errore per brevita'...*/
if (pid == 0)
{
     /*Qua faccio qualcosa*/
    /*Ad esempio...*-/
    sleep(2); 
    exit(EXIT_SUCCESS);
}

/*Qui arriva solo il padre*/

gettimeofday(end, NULL);

forkTime = (end->tv_sec - start->tv_sec) * 1000000 + (end->tv_usec - start->tv_usec); /*Tempo in microsecondi/*

free(start);
free(end);

Grazie !

[anx721]

Non mi pare che siano equivalenti perche se dopo la fork il processo attivo diventa il processo filgio, nel secondo caso il tempo rilevato è pari al tempo effettivo per l'esecuzione della fork + il quanto di tempo assegnato al processo filgio prima che il controllo della cpu ritorni al processo padre. Quindi io utilizzerei la prima forma, oppure inserirei le istruzioni

gettimeofday(end, NULL);
forkTime = (end->tv_sec - start->tv_sec) * 1000000 + (end->tv_usec - start->tv_usec); /*Tempo in microsecondi/*

sia nel processo padre che nel processo filgio come prime istruzioni dopo la fork; cosi sia che sia il padre sia che sia il figlio il primo ad essere eseguito dopo la fork viene rilevato il tempo effettivo della fork; di fatti nel primo esempio di codice, anche se il filgio esce immediatamente, la chiusura del processo del figlio comuqnue consuma un po di tempo. Un 'idea puo essere quindi quella di inserire le istruzioni per rilevare il tempo finale anche nel figlio; inoltre il tempo rilevato dal filgio puo essere scritto in un file in modo che se è il filgio il primo a calcolare il tempo di esecuzione, possa comunicarlo al padre scrivendolo in un file appunto. Queste sono considerazioni che pero non tengono affato in conto di come avvine la gestione dei procssi su linux, che in efetti non conosco, non so se ad esempio puoi avere la sicurezza che dopo la fork il controllo passa sempre prima al padre; inoltre devi considerare anche la presenza di altri processi sul sistema che potrebbero sovrapporsi a quelli del tuo programa, anche se mi sembra poco probabile. In linea di masima direi che il primo esempio mi pare piu affidabile.

[Ed_Bunker]

Originariamente inviato da anx721
Non mi pare che siano equivalenti perche se dopo la fork il processo attivo diventa il processo filgio, nel secondo caso il tempo rilevato è pari al tempo effettivo per l'esecuzione della fork + il quanto di tempo assegnato al processo filgio prima che il controllo della cpu ritorni al processo padre. Quindi io utilizzerei la prima forma, oppure inserirei le istruzioni

gettimeofday(end, NULL);
forkTime = (end->tv_sec - start->tv_sec) * 1000000 + (end->tv_usec - start->tv_usec); /*Tempo in microsecondi/*

sia nel processo padre che nel processo filgio come prime istruzioni dopo la fork; cosi sia che sia il padre sia che sia il figlio il primo ad essere eseguito dopo la fork viene rilevato il tempo effettivo della fork; di fatti nel primo esempio di codice, anche se il filgio esce immediatamente, la chiusura del processo del figlio comuqnue consuma un po di tempo. Un 'idea puo essere quindi quella di inserire le istruzioni per rilevare il tempo finale anche nel figlio; inoltre il tempo rilevato dal filgio puo essere scritto in un file in modo che se è il filgio il primo a calcolare il tempo di esecuzione, possa comunicarlo al padre scrivendolo in un file appunto. Queste sono considerazioni che pero non tengono affato in conto di come avvine la gestione dei procssi su linux, che in efetti non conosco, non so se ad esempio puoi avere la sicurezza che dopo la fork il controllo passa sempre prima al padre; inoltre devi considerare anche la presenza di altri processi sul sistema che potrebbero sovrapporsi a quelli del tuo programa, anche se mi sembra poco probabile. In linea di masima direi che il primo esempio mi pare piu affidabile.

Ho provato "sperimentalmente" e nel primo modo il tempo medio di fork risulta essere di circa 24 microsecondi mentre nel secondo caso (Inserendo qualche stampa a video e qualche chiamata di sistema nel codice del figlio) risulta essere di 64 microsecondi.
Differenza sostanziale direi. Il controllo dopo la fork() puo' essere passato sia al figlio che al padre. Non e' "predicibile" a priori.