Comportement étrange Pthread et défaut de segmentation

Question

J'essaye d'écrire un simulateur parallèle, qui utilise des threads. Mais je ne peux pas trouver ce qui cause la faute de segmentation et pourquoi les threads semblent parfois coincés sur une barrière.

#include <stdlib.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <string.h> 
#include <pthread.h> 

int num_threads = 5; 

//Thread arguemnt struct 
struct ThreadArguments { 
     unsigned int id; 
     pthread_barrier_t* barrier; 
     char* array; 
     char* copy_array; 
}; 

void simulate(struct ThreadArguments* args); 

void initializeThreads(struct ThreadArguments* data, char* letters); 


// Main method 
int main(int argc, char *argv[]) { 

     int i; 
     char* letters = malloc((num_threads + 1) *sizeof(char)); //plus 1 for /0 
     struct ThreadArguments *data = malloc(num_threads * sizeof(struct ThreadArguments)); 
     initializeThreads(data, letters); 

     pthread_t *thread = malloc(num_threads*sizeof(pthread_t)); 

     // Launching Threads 
     for (i=0; i<num_threads; i++) { 
       printf("Create threads %d \n", i); 
       fflush(stdout); 
       pthread_create(&thread[i], NULL,(void *) &simulate,(void *) &data[i]); 
     } 

     // Waiting for Threads to Finish 
     for (i=0; i<num_threads; i++) { 
       pthread_join(thread[i], NULL); 
     } 
     return 0; 
} 

void initializeThreads(struct ThreadArguments* data, char* letters) 
{ 
     int i; 
     pthread_barrier_t barrier; //create a barrier 
     pthread_barrier_init (&barrier, NULL, num_threads); 

     char *copy_letters = malloc((num_threads + 1) * sizeof(char)); 
     if(copy_letters == NULL)  //Checking malloc 
     { 
       perror("Error mallocing"); 
       free(copy_letters); 
       return; 
     } 

     for (i = 0; i < num_threads; i++) 
     { 
       data[i].barrier = &barrier; 
       data[i].array = letters; 
       data[i].copy_array = copy_letters; 
       data[i].id = i; 
     } 

} 

void simulate(struct ThreadArguments* args) 
{ 

     struct ThreadArguments* my_args= (struct ThreadArguments*)args; 
     printf("thread %d started", my_args->id); 
     fflush(stdout); 

     if(my_args->id == 0) //print the initial state of the board 
     { 
       printf("0th thread prints out results"); 
     } 

     ///Main loop. Each iteration is one round of simulation 

     my_args->copy_array[my_args->id] = my_args->array[my_args->id]; 
     //DO SOME WORK HERE 

     //barrier 
     pthread_barrier_wait (my_args->barrier); 
} 

J'ai essayé de commenter des pièces et le suivi avec valgrind (et un outil Helgrind) mais n'a pas pu comprendre ce qui provoque une erreur. Le code a pu être testé avec ./simulator test.txt 0 0 1 où test.txt est le suivant

Qu'est-ce qui ne va pas avec la façon dont j'implémente les barrières? et quelles sont les causes de SEGFAULT? EDIT: Mise à jour avec une version plus courte du code. Ce code veut juste créer un nombre num_thread de threads et chacun d'eux copiera un élément d'un tableau à un autre.

Answer 1

void initializeThreads(struct ThreadArguments* data, char* letters) 
{ 
    int i; 
    pthread_barrier_t barrier; //create a barrier 

Vous avez créé barrier sur la pile dans initializeThreads, alors quand cette fonction retourne, il cesse d'exister. Ainsi, tous les threads que vous créez accèdent à un objet qui n'existe plus à travers un pointeur périmé.