Erreur glibc invalid pointeur

Version imprimable

Bonjour à tous,
Je cherche à paralléliser l'exécution d'un programme sur un ensemble de fichier à l'aide de thread et d'un accès via mutex à la liste des fichiers à traité.
Mon programme fonctionne (les fichiers sont tous bien traité) mais me génère l'erreur suivante lorsque je le fais tourner avec plus d'un thread.
Si j'ai bien compris je libère deux fois un accès mémoire mais je ne vois pas lequel.

Erreur :

Code:

1
2
3
4
5
6
7
 *** glibc detected *** ./cppMutliThread: free(): invalid pointer: 0x00007fdab4f286e8 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x7eb96)[0x7fdab92abb96]
/usr/lib/x86_64-linux-gnu/libstdc++.so.6(_ZNSsD1Ev+0x23)[0x7fdab98a1c13]
./cppMutliThread[0x4013be]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xed)[0x7fdab924e76d]
./cppMutliThread[0x4010a9]

Mon programme:
main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include <iostream>
#include <sstream>
#include <string>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <list>
#include <vector>
#include <dirent.h>
 
 
 
void *worker_thread(void *arg);
static pthread_mutex_t mutex_stock = PTHREAD_MUTEX_INITIALIZER;
using namespace std;
 
/*création de ma liste de commande contenant le nom du fichier à traité*/
pthread_t my_thread[NBPROC];
    int id;
    for(id = 1; id <= NBPROC; id++) {
                int ret =  pthread_create(&my_thread[id], NULL, &worker_thread, listeFichier);
                if(ret != 0) {
                        printf("Error: pthread_create() failed\n");
                        exit(EXIT_FAILURE);
                }
        }
 
    int toto;
    for(toto=1;toto<=NBPROC;toto++)
    {
 
        pthread_join(my_thread[toto],NULL);
    }
    return EXIT_SUCCESS;
 
}

La fonction utilisé par les threads

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
void *worker_thread(void *arg)
{
    vector<string>* listeFichier=(vector<string>*)arg;
    vector<string> test=*(vector<string>*)arg;
    string* fichier;
 
    while(1)
    {
        pthread_mutex_lock(&mutex_stock);
        if(listeFichier->size()>0)
        {
 
            fichier=&listeFichier->back();
 
            listeFichier->pop_back();
 
            int retour = system((const char *)fichier->c_str());
            if(retour!=0)
            {
                cout<<retour<<endl;
            }
        }
        else
        {
            pthread_mutex_unlock(&mutex_stock);
            return NULL;
        }
 
    }
 
       return NULL;
}

D'avance merci

22/10/2013, 15h38
imperio
Compile ton programme en debug (avec l'option -g si tu utilises gcc) et lance ton programme avec valgrind (ou un debugger).

C'est pas super propre de declarer un mutex en global mais bon...

Y a une truc qui m'interpelle dans ta boucle :
Code:

1 2 3 4 pthread_t my_thread[NBPROC]; int id; for(id = 1; id <= NBPROC; id++) { int ret = pthread_create(&my_thread[id], NULL, &worker_thread, listeFichier);
Tu vas lire et ecrire dans la memoire la. La case x de ton tableau correspond a la case x + 1 en realite. Donc quand tu arrives a la case NBPROC, tu lis a case apres la derniere case de ton tableau. Autre question : pourquoi tu fais commencer ta boucle a 1 ? T'es sur que tu maitrises les tableaux ?

done:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
valgrind --leak-check=summary cppMutliThread/bin/Debug/cppMutliThread
==2808== Memcheck, a memory error detector
==2808== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
==2808== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
==2808== Command: cppMutliThread/bin/Debug/cppMutliThread
==2808== 
==2808== Invalid free() / delete / delete[] / realloc()
==2808==    at 0x4C2A4BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2808==    by 0x50EDC12: std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string() (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==2808==    by 0x401505: main (main.cpp:80)
==2808==  Address 0xb02a6e8 is not stack'd, malloc'd or (recently) free'd
==2808== 
==2808== 
==2808== HEAP SUMMARY:
==2808==     in use at exit: 8,174 bytes in 119 blocks
==2808==   total heap usage: 322 allocs, 204 frees, 68,570 bytes allocated
==2808== 
==2808== LEAK SUMMARY:
==2808==    definitely lost: 528 bytes in 60 blocks
==2808==    indirectly lost: 7,646 bytes in 59 blocks
==2808==      possibly lost: 0 bytes in 0 blocks
==2808==    still reachable: 0 bytes in 0 blocks
==2808==         suppressed: 0 bytes in 0 blocks
==2808== Rerun with --leak-check=full to see details of leaked memory
==2808== 
==2808== For counts of detected and suppressed errors, rerun with: -v
==2808== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)

C'est bien quand je quitte mon programme mais je ne vois pas en quoi le return final peut causer le problème

22/10/2013, 17h53
imperio
Le truc c'est qu'on n'a pas tout ton code donc on peut pas voir ce qu'il se passe concretement. Cependant je pense que ton probleme vient du faire que tu vas ecrire sur des zones memoires qui ne te sont pas allouees (tout du moins pas a l'objet avec lequel tu ecris dessus) comme ici par exemple :
Code:

1 2 for(id = 1; id <= NBPROC; id++) { int ret = pthread_create(&my_thread[id], NULL, &worker_thread, listeFichier);
Ou encore la :
Code:

1 2 3 4 5 for(toto=1;toto<=NBPROC;toto++) { pthread_join(my_thread[toto],NULL); }

Je doute que le reste de mon code puisse poser problème mais dans le doute:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include <iostream>
#include <sstream>
#include <string>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <list>
#include <vector>
#include <dirent.h>
 
 
 
void *worker_thread(void *arg);
static pthread_mutex_t mutex_stock = PTHREAD_MUTEX_INITIALIZER;
using namespace std;
 
#define NBPROC 10
 
int main (void)
{
 
    vector<string>* listeFichier=new vector<string>();
    string fic;
    string cmd;
    string prog="/var/www/rep/script/executable";
    DIR * rep = opendir("/var/www/rep/file");
 
    if (rep != NULL)
    {
        struct dirent * ent;
 
        while ((ent = readdir(rep)) != NULL)
        {
            fic=string(ent->d_name);
            if(fic!="."&&fic!="..")
            {
                //cout<<fic<<endl;
                cmd=prog+" /var/www/rep/file/"+fic+" 1>/dev/null";
 
                //cout<<cmd<<endl;
                listeFichier->push_back(*new string(cmd));
 
 
            }
 
        }
 
        closedir(rep);
    }
 
 
 
 
 
    int tailleListe=4;
    for (int i =0;i<tailleListe;i++)
    {
      //  listeFichier->push_back(*fichier);
        //cout<<*fichier<<endl;
    }
 
    pthread_t my_thread[NBPROC];
    int id;
    for(id = 1; id <= NBPROC; id++) {
                int ret =  pthread_create(&my_thread[id], NULL, &worker_thread, listeFichier);
                if(ret != 0) {
                        printf("Error: pthread_create() failed\n");
                        exit(EXIT_FAILURE);
                }
        }
 
    int toto;
    for(toto=1;toto<=NBPROC;toto++)
    {
 
        pthread_join(my_thread[toto],NULL);
    }
    pthread_join(pthread_self(),NULL);
 
      //  pthread_exit(NULL);
   // return EXIT_SUCCESS;
 
}
void *worker_thread(void *arg)
{
    vector<string>* listeFichier=(vector<string>*)arg;
    vector<string> test=*(vector<string>*)arg;
    string* fichier;
 
    while(1)
    {
        pthread_mutex_lock(&mutex_stock);
        //cout<<"Indice :"<<listeFichier->size()<<endl;
        if(listeFichier->size()>0)
        {
 
            //cout<<listeFichier->size()<<endl;
            fichier=&listeFichier->back();
            //cout<<"ici"<<endl;
           // cout<<*fichier<<endl;
            listeFichier->pop_back();
            pthread_mutex_unlock (& mutex_stock);
          //  string toto=*fichier;
          //  const char *tata =fichier->c_str();
 
            int retour = system((const char *)fichier->c_str());
            if(retour!=0)
            {
                cout<<retour<<endl;
            }
        }
        else
        {
            pthread_mutex_unlock(&mutex_stock);
            return NULL;
           // cout<<"Ici"<<endl;
        }
 
    }
 
        //printf("This is worker_thread #%ld\n", (long)arg);
 
       return NULL;
}

Je ne fais réellement que ça.

23/10/2013, 13h08
imperio

Est-ce que tu comptes un jour corriger les 2 erreurs que je t'ai deja cite ? Apres ca on verra si il y a du changement.
23/10/2013, 14h13
cyril_M

http://franckh.developpez.com/tutoriels/posix/pthreads/

Je ne vois pas de différence avec le tuto et ne sais donc quoi/comment le corriger
23/10/2013, 16h49
imperio

Je te l'ai deja ecrit en toute lettre mais recommencons...

tuto :

Code:

for (i = 0; i < NB_CLIENTS; i++)

ton code :

Code:

for(id = 1; id <= NBPROC; id++)

Tu vois mieux maintenant ?
23/10/2013, 16h53
cyril_M

En effet c'était ça, merci