[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 subito il figlio nato dalla fork o no.
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...*-/
    int i = 0;
    while(i < 300)
    {
       printf("Child> nel ciclo");
       i++;
    }
    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 !

[Ed_Bunker]

Ho provato sperimentalmente e nel primo modo il tempo medio di fork() (Eseguendone mille una dietro l'altra) e' di circa 23 microsecondi mentre nel secondo modo risulta essere di 64 microsecondi.
Nessun parere ?!?

[ilsensine]

A me ritorna circa lo stesso valore.
Nota che il metodo che usi non è proprio affidabile, in quanto normalmente il controllo passa al child dopo una fork. Quindi in realtà quello che stai misurando è il tempo di fork, più il tempo di esecuzione del figlio (al più fino al suo naturale context switch, ma non è il tuo caso), più il tempo per effettuare un giro di scheduling dal figlio a nuovamente il padre. Questo tempo può dipendere da quello che fa il figlio, ma tra una exit e una sleep non c'è molta differenza.

[Ed_Bunker]

Originariamente inviato da ilsensine
A me ritorna circa lo stesso valore.
Nota che il metodo che usi non è proprio affidabile, in quanto normalmente il controllo passa al child dopo una fork. Quindi in realtà quello che stai misurando è il tempo di fork, più il tempo di esecuzione del figlio (al più fino al suo naturale context switch, ma non è il tuo caso), più il tempo per effettuare un giro di scheduling dal figlio a nuovamente il padre. Questo tempo può dipendere da quello che fa il figlio, ma tra una exit e una sleep non c'è molta differenza.

Il controllo non sempre passa al child. A priori non e' possibile dirlo. Provando infatti a fare una stampa sia nel codice del figlio che in quello del padre ed eseguendo piu' volte si ottengono risultati differenti. Quel che volevo constatare e':
se il figlio consuma completamente o in parte il suo quanto di tempo (Supponendo che il controllo dopo la fork sia passato proprio al figlio) il tempo misurato dal padre sara' poco attendibile. No ?
Invece se il figlio fa subito una exit (E non consuma quindi il suo quanto), sia che il controllo passi al padre, sia che passi al figlio (Ma non a qualche altro processo sulla macchina) il valore registrato dovrebbe essere piu' attendibile.

[Ed_Bunker]

Adesso ho modificato; il codice in rosso non e' quello con cui avevo fatto le prove. Facendo una sleep come prima, infatti, il processo figlio rilascia il controllo che, presumibilmente, viene preso dal padre che cosi' calcola un valore piuttosto attendibile. Adesso si dovrebbe notare qualche differenza. Prova...

[ilsensine]

Originariamente inviato da Ed_Bunker
Il controllo non sempre passa al child. A priori non e' possibile dirlo.

Linux si comporta così da diverso tempo. E' comunque errato presumerlo a priori, hai ragione, era solo per darti una spiegazione di quello che avveniva e del perché il tuo metodo di misurare il tempo di fork è inaffidabile. Prova ad esempio a sostituire la sleep con un for(;; ); e divertiti a vedere i risultati. E' forse cambiato il tempo per eseguire la fork? No, è quello che stai misurando che non è _solo_ il tempo di fork.