probléme lecture tableau dynamique d'une structure pointée en C
Bonjour à tous !
J'ai un problème de lecture dans un tableau dynamique dans une structure pointée, ça fait quelques jours que je butte dessus sans trouver pourquoi.
Voici les parties de mon code qui posent soucis je pense :
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
| typedef struct {
char* carac;
int taille;
int next_libre;/*index de la prochaine case libre dans le tableau*/
int next_occupe;/*index de la prochaine case occupée dans le tableau*/
pthread_mutex_t prot_tab; /* assure l'exclusion mutuelle */
sem_t sem_plein;/*semaphore dans le cas ou le tableau est plein*/
sem_t sem_vide;/*semaphore dans le cas ou le tableau est vide*/
} monTube_exo5_partagee;
typedef struct {
monTube_exo5_partagee * partage; /*pointeur de projection en mémoire*/
int df, err; /*file descriptor*/
} monTube_exo5_t;
int monTube_exo5_ecrire(monTube_exo5_t *mt, char c)
{
int err;
/**le process se bloque en attendant le signal de départ de la part du process lecteur, pour être bien synchro*/
err=sem_wait(&(mt->partage->sem_plein));
if(err==-1){
return -1;/**erreur lors du changement du semaphore*/
}
/*Debut de la SC, exclusion mutuele assurée*/
pthread_mutex_lock( &(mt->partage->prot_tab) );
(mt->partage->carac[ mt->partage->next_libre ]) = c;/*insertion dans le tableau*/
printf("\n\necriture : [%c] INDEX %d ADRESS %X\n",mt->partage->carac[ mt->partage->next_libre ],mt->partage->next_libre,&(mt->partage->carac[ mt->partage->next_occupe ]));
mt->partage->next_libre = ( mt->partage->next_libre + 1 ) % mt->partage->taille;/*on définit la prochaine case libre*/
pthread_mutex_unlock( &(mt->partage->prot_tab) );
/*Fin de la SC*/
/**une donnée à été écrite, donc débloquage du sémaphore pour lecture*/
err=sem_post(&(mt->partage->sem_vide));
if(err==-1){
return -1;/**erreur lors du changement du semaphore*/
}
return 1;
}
int monTube_exo5_lire(monTube_exo5_t *mt, char *c)
{
int err;
/**le process lecteur débloque le process qui écrit puis se bloque en attendant son signal*/
err=sem_post(&(mt->partage->sem_plein));
if(err==-1){
return -1;/**erreur lors du changement du semaphore*/
}
err=sem_wait(&(mt->partage->sem_vide));/*se bloque ici*/
if(err==-1){
return -1;/**erreur lors du changement du semaphore*/
}
/*Debut de la SC, exclusion mutuele assurée*/
pthread_mutex_lock( &(mt->partage->prot_tab) );
(*c)= (mt->partage->carac[mt->partage->next_occupe]);/*lecture dans le tableau*/
printf("lecture : [%c] INDEX %d ADRESS %X\n",(mt->partage->carac[ mt->partage->next_occupe ]),mt->partage->next_occupe,&(mt->partage->carac[ mt->partage->next_occupe ]) );
mt->partage->next_occupe = ( mt->partage->next_occupe + 1 ) % mt->partage->taille;/*on définit la prochaine case occupee*/
pthread_mutex_unlock( &(mt->partage->prot_tab) );
/*Fin de la SC*/
return 1;
} |
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
| int monTube_exo5_init(monTube_exo5_t *mt, int taille)
{
mt->df = shm_open("/exo5_partagee", O_CREAT | O_RDWR, S_IRWXU );
if ( mt->df == -1 ) {
fprintf( stderr, "Erreur lors de la création du segment de mémoire partagée\n" );
return -1;
}
mt->err = ftruncate(mt->df, sizeof( monTube_exo5_partagee ));
if (mt->err != 0) {
fprintf( stderr, "Erreur lors du redimensionnement de mémoire partagée\n" );
return -1;
}
mt->partage = ( monTube_exo5_partagee * ) mmap( NULL, sizeof( monTube_exo5_partagee ), PROT_READ | PROT_WRITE, MAP_SHARED, mt->df, 0);
if ( mt->partage == MAP_FAILED ) {
fprintf( stderr, "Erreur lors de la projection en mémoire\n" );
return -1;
}
/**initialisation des sémaphores*/
mt->err = sem_init(&(mt->partage->sem_plein),1,0);
if (mt->err != 0)
{
fprintf( stderr, "Erreur lors de l'initialisation du sémaphore\n" );
return -1;
}
mt->err = sem_init(&(mt->partage->sem_vide),1,0);
if (mt->err != 0)
{
fprintf( stderr, "Erreur lors de l'initialisation du sémaphore\n" );
return -1;
}
/**initialisation de la file*/
mt->partage->next_occupe= 0;
mt->partage->next_libre= 0;
/**initialisation du mutex*/
mt->err=pthread_mutex_init( &(mt->partage->prot_tab), NULL );
if(mt->err!=0)
{
fprintf( stderr, "Erreur lors de l'initialisation du mutex\n" );
return -1;
}
/**initialisation du tableau dynamique*/
mt->partage->taille = taille;
mt->partage->carac = (char*) malloc(taille * sizeof(char));
printf("INIT:taille[%d]\n",mt->partage->taille);
return 0;
} |
Sans forcément tenir compte des mutex/sémaphores, car ce n'est pas ce qui me pose problème, lorsque j’écris dans mon tableau, pas de soucis, mais dés que je sort de la fonction d'écriture, et que j'essaie de lire dans carac, impossible de mettre la main sur la donnée, alors que ça fonctionne avec un tableau statique, même si j'arrive sur la bonne adresse, au début j'ai pensé à un problème de cast avec le malloc, mais ça n'a pas l'air de venir de la, j'ai aussi essayé de faire 2 zones de mémoire partagée, mais ca ne fait que déplacer le problème.
Au passage ce n'est pas le même processus qui exécute la fonction lecture et la fonction écriture, le process de base est forké après l’exécution de la fonction init ci dessus.
j'ai ce genre de sortie pour être plus parlant :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| Exo5, test avec un tube de taille 4
INIT:taille[4]
ecriture : [a] INDEX 0 ADRESS C01010
lecture : [] INDEX 0 ADRESS C01010
->
ecriture : [b] INDEX 1 ADRESS C01011
lecture : [] INDEX 1 ADRESS C01011
->
ecriture : [c] INDEX 2 ADRESS C01012
lecture : [] INDEX 2 ADRESS C01012
->
ecriture : [d] INDEX 3 ADRESS C01013
lecture : [] INDEX 3 ADRESS C01013
->
ecriture : [e] INDEX 0 ADRESS C01010
lecture : [] INDEX 0 ADRESS C01010
-> |
