Erreur glibc invalid pointeur

**cyril_M** · 22/10/2013, 12h25

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**imperio** · 22/10/2013, 15h38

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

**cyril_M** · 22/10/2013, 15h45

done:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**imperio** · 22/10/2013, 17h53

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Ou encore la :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**cyril_M** · 23/10/2013, 09h10

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.