en passant struct pour pthread comme argument

Ok je suis en train de passer une paire de nombres à travers struct à pthread_create fonction dans pthread. Mais les chiffres, je suis de passage et les chiffres que j'obtiens lorsque la fonction est appelée sont différents et aléatoires

Ici est la struct

struct Pairs {
    long i,j;
};

Et, à l'intérieur du

void main()
{
    long thread_cmp_count = (long)n*(n-1)/2;
    long t,index = 0;
    struct Pairs *pair;
    pair = malloc(sizeof(struct Pairs));

    cmp_thread = malloc(thread_cmp_count*sizeof(pthread_t));
    for(thread = 0;(thread < thread_cmp_count); thread++){
        for(t = thread+1; t < n; t++){
            (*pair).i = thread;
            (*pair).j = t;
            pthread_create(&cmp_thread[index++], NULL, Compare, (void*) pair);

        }
    }

    for(thread= 0;(thread<thread_cmp_count); thread++){
        pthread_join(cmp_thread[thread], NULL);
    }

    free(cmp_thread);
}

Et de la fonction Comparer

void* Compare(void* pair){
    struct Pairs *my_pair = (struct Pairs*)pair;
    printf("\nThread %ld, %ld", (*my_pair).i, (*my_pair).j);
    return NULL;
}

Nombre que je suis arriver et il est également aléatoire.

Thread 0,2
Thread 1,2
Thread 2,3
Thread 2,3
Thread 2,3
Thread 2,3

suis-je en passant la struct mal ?

Veuillez noter qu'en C, struct accède à l'aide d'un pointeur ne sont jamais écrit que (*foo).bar: au lieu d'utiliser foo->bar.

OriginalL'auteur Jos | 2013-11-25

  1. 16

    C'est parce que vous passez le pointeur de même pour tous les pthreads.

    Lorsque vous appelez pthread_create(..., (void*) pair) vous passez le pointeur vers le nouveau thread, mais dans la prochaine itération, vous l'écrasez que la mémoire (potentiellement avant le nouveau thread a extrait de ces valeurs).

        long thread_cmp_count = (long)n*(n-1)/2;
    long t,index = 0;
    struct Pairs *pair;

    cmp_thread = malloc(thread_cmp_count*sizeof(pthread_t));
    for(thread = 0;(thread < thread_cmp_count); thread++){
        for(t = thread+1; t < n; t++){
            //allocate a separate pair for each thread
            pair = malloc(sizeof(struct Pairs));
            (*pair).i = thread;
            (*pair).j = t;
            pthread_create(&cmp_thread[index++], NULL, Compare, (void*) pair);

        }
    }

    for(thread= 0;(thread<thread_cmp_count); thread++){
        pthread_join(cmp_thread[thread], NULL);
    }

    free(cmp_thread);

    .

    void* Compare(void* pair){
    struct Pairs *my_pair = (struct Pairs*)pair;
    printf("\nThread %ld, %ld", (*my_pair).i, (*my_pair).j);

    //free that memory after it has been used
    free (pair);
    return NULL;
}
    vous avez eu le problème de droit, mais qui n'est pas le résoudre. j'ai utilisé un pointeur comme un tableau de struct afin d'éviter le chevauchement. merci quand même.

    OriginalL'auteur Sergey L.

  2. 3

    Le problème est résolu. Problème était avec chevauchement. à l'aide de pointeur comme array de type struct Paires, il est résolu

    Voici le bon code

    long thread_cmp_count = (long)n*(n-1)/2;
long t,index = 0;
Pair * pair;
pair = malloc(thread_cmp_count*sizeof(Pair));

free(thread_handles);

thread_handles = malloc(thread_cmp_count*sizeof(pthread_t));
for(thread = 0;(thread < n-1); thread++){
    for(t = thread+1; t < n; t++){
        (pair+index)->i = thread;
        (pair+index)->j = t;
        pthread_create(&thread_handles[index], NULL, Compare, (void*) (pair+index));
        index++;
    }
}
for(thread= 0;(thread<thread_cmp_count); thread++){
    pthread_join(thread_handles[thread], NULL);
}

free(thread_handles);

    Et la fonction de Comparer

    void* Compare(void* pair){
    long t,i,j;
    Pair *my_pair = (Pair*)pair;
    i = my_pair->i;
    j = my_pair->j;
    printf("\n..................................................................");
        if((x_array[i] < x_array[j])&&(x_array[i] != x_array[j])){
            w_array[i] = 0;
            printf(
                "\nThread T(%ld,%ld)"
                " compares x[%ld] = %ld and x[%ld] = %ld,"
                " and writes 0 to w[%ld]", i, j,
                i,x_array[i],
                j,x_array[j],
                i);
        }
        else if((x_array[i] > x_array[j])&&(x_array[i] != x_array[j])){
            w_array[j] = 0;
            printf(
                "\nThread T(%ld,%ld)"
                " compares x[%ld] = %ld and x[%ld] = %ld,"
                " and writes 0 to w[%ld]", i, j,
                i,x_array[i],
                j,x_array[j],
                j);
        }
        else
            return NULL;
    return NULL;
}
    J'ai essayé ce code mais d'avoir d'erreur un déréférencement de pointeur à incomplète de type ‘struct Paires "

    OriginalL'auteur Jos