comment calculer le temps d'exécution total pour tous les processus enfants fonctionnant simultanément?

Question

Comment calculer le temps d'exécution de plusieurs processus fils, qui sont bifurqués pour s'exécuter en parallèle et avoir le même parent? Le code suivant est-il le processus à exécuter en parallèle ou s'exécute-t-il en série?

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <time.h> 
void forkChildren (int nChildren) { 
    int i,j; 
    pid_t pid; 
    pid_t my_id; 
    clock_t start, end; 
    double cpu_time_used; 
    for (i = 1; i <= nChildren; i++) { 
     pid = fork(); 
     if (pid == -1) { 
      /* error handling here, if needed */ 
      return; 
     } 
     if (pid == 0) { 
     /* printf("I am a child: %d PID: %d\n",i, getpid());*/ 
      for(j=0;j<20000000;j++) 
      { 
       if(j%100==0) 
       { 
        my_id = getpid(); 
       } 
      } 
      return; 
     } 
    } 
} 

int main (int argc, char *argv[]) { 
clock_t start,stop; 
double elapsed; 
start = clock(); 
    if (argc < 2) { 
     forkChildren (2); 
    } else { 
     forkChildren (atoi (argv[1])); 
    } 
    stop = clock(); 
    elapsed = (double)(stop - start) * 1000.0/CLOCKS_PER_SEC; 
    printf("Time elapsed in ms: %f", elapsed); 
    return 0; 
} 

Le code précédent génère plus d'un temps d'exécution de sortie, je pense pour chaque processus séparément. les résultats pour le code précédent montré ci-dessous. mais je veux calculer le temps d'exécution que tout le processus fourchu prend pour s'exécuter.

Answer 1

Vous avez juste besoin de bloquer le processus parent jusqu'à ce que tous les processus enfants ont pris fin:

pid = fork(); 
if (pid == -1) { 
    /* error handling here, if needed */ 
    return; 
} 
if (pid == 0) { 
    /* printf("I am a child: %d PID: %d\n",i, getpid());*/ 
    for (j = 0; j < 20000000; j++) { 
    if (j % 100 == 0) { 
     my_id = getpid(); 
    } 
    } 
    return; 
} else { 

    while (pid = waitpid(-1, NULL, 0)) { 
    if (errno == ECHILD) { 
     break; 
    } 
    } 
} 

Le parent se bloque dans la boucle while jusqu'à ce qu'aucun processus enfant ne soit laissé puis retourne. Donc vous calculez le temps total nécessaire pour que tous les enfants finissent l'exécution.