C - Fourches multiples itératives

Question

Je dois faire 4 fourchettes 1000 fois. J'ai écrit cela, mais il fonctionne toujours:

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#include <sys/types.h> 

#define N 512 

void chunk0(void); 
void chunk1(void); 
void chunk2(void); 
void chunk3(void); 
double get_time(void); 

void main(void) 
{ 
    int i,j,k,iterations=0; 
    unsigned int *a=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 
    unsigned int *b=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 
    unsigned int *c=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 
    pid_t pid; 

    for(iterations=0;iterations<1000;iterations++){ 
     srand (time(NULL)); 
     double start=get_time(); 

     pid = fork(); 
     if (pid == 0) { 
      chunk0(); 
     }else { 
      pid = fork(); 
      if (pid == 0){ 
       chunk1(); 
      }else { 
       pid = fork(); 
       if (pid == 0){ 
        chunk2(); 
       }else { 
        chunk3(); 
        wait(NULL); 
        double end=get_time(); 
        double diff=end-start; 
        printf("\n Time for run this code is: %lf seconds \n",diff); 
       } 
      }   
     } 
    }  
} 

void chunk0(void) 
{ 
/* int i,j,k,iterations=0; 
    unsigned int *a=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 
    unsigned int *b=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 
    unsigned int *c=(unsigned int *)malloc(N*N*(sizeof(unsigned int))); 

    for(iterations=0;iterations<1000;iterations++){ 
     //printf("iteration #%d: Generating Matrix - ",iterations+1); 
     for(i=0;i<N;i++){ 
      for(j=0;j<N;j++){ 
       //give int number between 0...1000 to a[i][j] , b[i][j] and reset c[i][j] 
       *(a+(i*N+j))=(rand()%1001); 
       *(b+(i*N+j))=(rand()%1001); 
       *(c+(i*N+j))=0; 
      } 
     } 
     //printf("Multiplying ... \n"); 
     for(i=0;i<N;i++){ 
      for(j=0;j<N;j++){ 
       for(k=0;k<N;k++){ 
        *(c+(i*N+j))= *(c+(i*N+j)) + ((*(a+(i*N+k)))*(*(b+(k*N+j)))); 
       } 
      } 
     } 
    } 

    free(a); 
    free(b); 
    free(c); 
*/ 
    printf(" *** Child process 0 is done ***\n"); 
} 
void chunk1(void) 
{ 
    int i; 
    printf(" *** Child process 1 is done ***\n"); 
} 
void chunk2(void) 
{ 
    int i; 
    printf(" *** Child process 2 is done ***\n"); 
} 
void chunk3(void) 
{ 
    int i; 
    printf(" *** Child process 3 is done ***\n"); 
} 

double get_time(void){ 
    struct timeval stime; 
    gettimeofday (&stime, (struct timezone*)0); 
    return (stime.tv_sec+((double)stime.tv_usec)/1000000); 
} 

Je sais pourquoi, mais je ne sais pas comment fixer

Answer 1

Car après chaque fourche() le processus enfant continue le code à partir duquel le processus parent est . Par conséquent, les processus parent et enfant continuent d'exécuter la boucle for et non seulement le processus parent, mais les processus enfants continuent à forker. Wait (NULL) provoque l'attente de votre thread principal jusqu'à ce que tous les enfants soient sortis.

Answer 2

Pour rompre la boucle infinie, chunk0, chunk1 et chunk2 appellent exit pour se terminer.

En outre, comme d'autres l'ont souligné, une instruction break est nécessaire après chaque appel à chunk0-chunk2.

Answer 3

Vous devez mettre un break; après chaque appel à chunkXXX() mais le dernier (processus père), et appelez exit() à partir des morceaux enfants.