Bonjour a tous, voilà dans le cadre de mon projet de fin d'année de BTS, je dois mettre en place les threads une carte ColdFire sous uClinux (noyau de linux pour les systemes embarqué).
Jusque là pas de probleme, seulement lors de la compilation de mon programme (exemple trouvé sur internet), j'obtien une erreur de type : undefined reference to `__rpc_thread_destroy'

Je n'ai aucune idée d'ou l'erreur peut venir.

Je developpe sous Linux Red Hat 9 avec Eclipse.

J'espere que vous pourrez m'eclairer la dessus, merci d'avance.

voici le-dit code
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
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>    // pour sleep
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 
 
 // mutex => MUtuelle EXclusion (permet d'éviter un accès simultané à une variable)
 static pthread_mutex_t mutex;
 static int tab[5];
 
 
 void* threadLectureTableau(void* arg)
 {
     for (int i = 0 ; i != 5 ; i++)
     {
         // blocage du mutex
         // (attente éventuelle de sa libération s'il est déjà bloqué)
         pthread_mutex_lock (&mutex);
 
         printf ("Lecture du tableau 1 : tab[%d] vaut %d\\n", i, tab[i]);
 
         // déblocage du mutex
         pthread_mutex_unlock (&mutex);
 
         sleep(1);
     }
 
     pthread_exit (0);
 }
 
 
 void* threadLectureTableau2(void* arg)
 {
     for (int i = 0 ; i != 5 ; i++)
     {
         // blocage du mutex
         // (attente éventuelle de sa libération s'il est déjà bloqué)
         pthread_mutex_lock (&mutex);
 
         printf ("Lecture du tableau 2 : tab[%d] vaut %d\\n", i, tab[i]);
 
         // déblocage du mutex
         pthread_mutex_unlock (&mutex);
 
         sleep(2);
     }
          pthread_exit (0);
 }
 
 
 void* threadEcritureTableau(void* arg)
 {
     // blocage du mutex
     // (attente éventuelle de sa libération s'il est déjà bloqué)
     pthread_mutex_lock (&mutex);
 
     for (int i = 0 ; i != 5 ; i++)
     {
         tab[i] = 2 * i;
         printf ("Ecriture du tableau : tab[%d] vaut %d\\n", i, tab[i]);
         sleep(1);
     }
 
     // déblocage du mutex
     pthread_mutex_unlock (&mutex);
 
     pthread_exit (0);
 }  
 
 int main(int argc, char *argv[])
 {
     pthread_t thread1, thread2, thread3;
     void *retour;
 
     pthread_mutex_init (&mutex, NULL);
 
     if (pthread_create (&thread1, NULL, threadEcritureTableau, NULL) < 0)
     {
         fprintf (stderr, "Impossible de créer le thread 1\\n");
         exit (1);
     }
     if (pthread_create (&thread2, NULL, threadLectureTableau, NULL) < 0)
     {
         fprintf (stderr, "Impossible de créer le thread 2\\n");
         exit (1);
     }
     if (pthread_create (&thread3, NULL, threadLectureTableau2, NULL) < 0)
     {
         fprintf (stderr, "Impossible de créer le thread 2\\n");
         exit (1);
     }
                 // le processus principale est ainsi contraint d'attendre la fin d'exécution
                 // des threads fils
     (void)pthread_join (thread1, &retour);
     (void)pthread_join (thread2, &retour);
     (void)pthread_join (thread3, &retour);
}