structure alignée passée par valeur à une fonction

Version imprimable

Bonjour tout le monde,

Je suis entrain de tester le bout de code suivant:
Code:

1 2 3 4 5 //Initialise la donnée: FonctionWritingData(&W_Data_Str); //lire la donnée: FonctionReadingData(W_Data_Str);
W_Data_Str est du type structuré suivant:
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 typedef enum EnumType_e { Enum_1 , Enum_2 , Enum_3 } EnumType_t; typedef struct rxfqdc_Info_Common_s { unsigned char A[45]; EnumType_t B[45]; EnumType_t C[53]; EnumType_t D[53]; EnumType_t E[53]; EnumType_t F[53]; EnumType_t G[43]; EnumType_t H[43]; EnumType_t I[43]; EnumType_t J[2]; EnumType_t K[2]; EnumType_t L[2]; EnumType_t M[2]; EnumType_t N[2]; EnumType_t O[2]; EnumType_t P[2]; EnumType_t Q[2]; EnumType_t R[2]; EnumType_t S[2]; EnumType_t DataLastTable[2]; } My_struct_t __attribute__ ((aligned (2))) ;
Le problème que j'ai c'est que; quand j'appelle la fonction FonctionReadingData et je vérifie après si ce que je lui passe en entrée est bien ce que j'initialise dans FonctionWritingData. Le dernier élément du dernier champ ne prend pas la bonne valeur!

ie: Supposons que j'initialise tous les éléments de ma structure à 2 (dans FonctionWritingData), dans FonctionReadingData je récupère le dernier élément W_Data_Str.DataLastTable[1] avec une valeur de 0 alors que tous les autres éléments de tous les champs prennent bien 2.

Sachant que:
1- Quand je fais pas d'alignement (je supprime le __attribute__ ((aligned (2))) ) le problème disparaît!
2- Quand je passe la sortie de la premiere fonction à la deuxieme par adresse (FonctionReadingData)là aussi le problème disparaît! (en gardant l'alignement)

Je n'arrive pas à trouver une explication à:
- ce qui arrive avec et sans l'instruction d'alignement.
- et avec le passage de la donnée par adresse et par valeur.

S'il vous plaît pouvez vous m'éclaircir un peu.
Par avance, je vous remercie énormément!

Cordialement,

16/10/2018, 12h59
Matt_Houston

Comment est allouée la variable en question (W_Data_Str) ?
16/10/2018, 13h02
o_Nejma

Citation:

Envoyé par Matt_Houston

Comment est allouée la variable en question (W_Data_Str) ?

Elle est déclarée comme variable local dans la fonction appelante des deux fonctions FonctionWritingData(&W_Data_Str) et FonctionReadingData(W_Data_Str).
17/10/2018, 08h28
Bktero

Tu peux nous donner un code minimaliste reproduisant le problème stp ? Le but est qu'on puisse l'essayer et constater le problème.

Bonjour,

Désolée pour ma réponse un peu tardive.

Je ne pense pas que ce soit évident de reproduire le problème car je travaille avec un compilateur diab (wind river) et j'utilise un outils de test (de ibm), et il me semble que ce soit un problème très lié au compilateur.

Mais je mets un code que j'ai développé pour tester sur gcc et effectivement je n'ai pas eu le même problème.

Le fichier source:

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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
#include <stdio.h>
#include "Header.h"
 
 
 
//Declare data For writing test:
My_struct_t * R_Data_Ptr;
My_struct_t   R_Data_Str;
 
//Declare data For reading test:
My_struct_t * W_Data_Ptr;
My_struct_t   W_Data_Str;
My_struct_t   test_str;
 
 
 
//functions stubbing:
void FonctionReadingData(My_struct_t My_Data)
{ 
               R_Data_Str =  My_Data;
               R_Data_Ptr = (My_struct_t *)(&My_Data);
}
 
void FonctionWritingData(My_struct_t *  const My_Data)
{
               unsigned char i;
 
               for(i=0;i<45;i++)
               {
                              My_Data->A[i]             	=   W_Data_Str.A[i]   ;
               }                                                            
               for(i=0;i<45;i++)                                            
               {                                                            
                              My_Data->B[i]	               =   W_Data_Str.B[i]    ;
               }                                                            
               for(i=0;i<53;i++)                                            
               {                                                               
                              My_Data->C[i]                 =   W_Data_Str.C[i]    ;
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {              	                  								       
                              My_Data->D[i]                 =   W_Data_Str.D[i]     ;
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {                 	                  							       
                              My_Data->E[i]                 =   W_Data_Str.E[i]  ; 
               }  		                  										       
               for(i=0;i<53;i++)	                  								       
               {              	                  								       
                              My_Data->F[i]                 =   W_Data_Str.F[i]  ;
               }  													       
               for(i=0;i<43;i++)										       
               {                										       
                              My_Data->G[i]           	=   W_Data_Str.G[i]   ;
               }  													       
               for(i=0;i<43;i++)										       
               {  													       
                              My_Data->H[i]          	=   W_Data_Str.H[i]   ;
               }  			              								       
               for(i=0;i<43;i++)									       
               {  												       
                              My_Data->I[i]         	=   W_Data_Str.I[i]   ; 
               }  												       
               for(i=0;i<2;i++)									       
               { 												       
                              My_Data->J[i]    	=  W_Data_Str.J[i]   ; 
               }                                             
               for(i=0;i<2;i++)                              
               {                                             
                              My_Data->K[i]         	=   W_Data_Str.K[i]         ;
               }  												             
               for(i=0;i<2;i++)									             
               {													             
                              My_Data->L[i]           	=   W_Data_Str.L[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->M[i]             	=   W_Data_Str.M[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->N[i]             	=   W_Data_Str.N[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->O[i]             	=   W_Data_Str.O[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->P[i]           	=   W_Data_Str.P[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->Q[i]             	=   W_Data_Str.Q[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->R[i]            	=   W_Data_Str.R[i]         ;
               }  													             
               for(i=0;i<2;i++)										             
               {														             
                              My_Data->S[i]            	=   W_Data_Str.S[i]         ;
               }  																					              
               for(i=0;i<2;i++)																		              
               {																						              
                              My_Data->DataLastTable[i]     =   W_Data_Str.DataLastTable[i] ;
               }   
               test_str = *My_Data;
               *((&test_str.S[1])+2)  = *(&(My_Data->S[1]) +2) ;
}
 
 
 
//main program:
void main(void)
{
               unsigned char i;
 
 
 
               for(i=0;i<45;i++)
               {
                              W_Data_Str.A[i] =1  ;
               }                                                                
               for(i=0;i<45;i++)                                                
               {                                                                
                              W_Data_Str.B[i] =2   ;
               }                                                                
               for(i=0;i<53;i++)                                                
               {                                                                   
                              W_Data_Str.C[i] =1        ;
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {              	                      								       
                              W_Data_Str.D[i] =2         ;
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {                 	                      							       
                              W_Data_Str.E[i] =1      ; 
               }  		                      										       
               for(i=0;i<53;i++)	                      								       
               {              	                      								       
                              W_Data_Str.F[i] =2      ;
               }  		                   										       
               for(i=0;i<43;i++)	                   								       
               {                	                   								       
                              W_Data_Str.G[i] =1       ;
               }  		                   										       
               for(i=0;i<43;i++)	                   								       
               {  		                   										       
                              W_Data_Str.H[i] =2       ;
               }  		                                 								       
               for(i=0;i<43;i++)	                   							       
               {  		                   									       
                              W_Data_Str.I[i] =1       ; 
               }  		                   									       
               for(i=0;i<2;i++)	                   							       
               { 		                   									       
                              W_Data_Str.J[i] =2       ; 
               }                                                 
               for(i=0;i<2;i++)                                  
               {                                                 
                              W_Data_Str.K[i] =3             ;
               }  		                   									             
               for(i=0;i<2;i++)	                   							             
               {		                   										             
                              W_Data_Str.L[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.M[i] =2             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.N[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.O[i] =2             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.P[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.Q[i] =2            ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.R[i] =1             ;
               }  		                   										             
               for(i=0;i<2;i++)	                   								             
               {		                   											             
                              W_Data_Str.S[i] =2             ;
               }  																					              
               for(i=0;i<2;i++)																		              
               {																						              
                              W_Data_Str.DataLastTable[i]=1  ;
               }   
 
               FonctionWritingData(&W_Data_Str);
               FonctionReadingData(W_Data_Str);
 
               printf("Print the last item value of the last struct filed:\n");
               printf("After Reading: %d \n",R_Data_Str.DataLastTable[1]);
               printf("After Writing (read inside writing function): %d \n ",test_str.DataLastTable[1]);
               system("pause");
}

Le fichier header:

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
typedef enum EnumType_e
{ 
   Enum_1       ,
   Enum_2 ,
   Enum_3
}
EnumType_t;
 
 
typedef struct rxfqdc_Info_Common_s
{
   unsigned char   A[45];
 
   EnumType_t  B[45];
 
   EnumType_t  C[53];
 
   EnumType_t  D[53];
 
   EnumType_t  E[53];
 
   EnumType_t  F[53];
 
   EnumType_t  G[43];
 
   EnumType_t  H[43];
 
   EnumType_t  I[43];
 
   EnumType_t  J[2]; 
 
   EnumType_t  K[2];
 
   EnumType_t  L[2];
 
   EnumType_t  M[2];
 
   EnumType_t  N[2];
 
   EnumType_t  O[2];
 
   EnumType_t  P[2];
 
   EnumType_t  Q[2];
 
   EnumType_t  R[2];
 
   EnumType_t  S[2];
 
   EnumType_t  DataLastTable[2];
}
My_struct_t __attribute__ ((aligned (2))) ; 
 
 
 
//functions prototypes:
 
void FonctionWritingData( My_struct_t *  const My_Data) ;
 
void FonctionReadingData(My_struct_t My_Data) ;

Merci d'avance.

Code:

1 2 3 4 5 6 //functions stubbing: void FonctionReadingData(My_struct_t My_Data) { R_Data_Str = My_Data; R_Data_Ptr = (My_struct_t *)(&My_Data); }
Tu assignes un pointeur local dans R_Data_Ptr, peu de chance qu'il soit encore valide par la suite.

17/10/2018, 14h49
o_Nejma

En fait dans mon code réel je n'ai pas de pointeur, ici j'ai voulu juste voir s'il y'aurait une différence au niveau du champ altéré de ma structure en utilisant un pointeur.
17/10/2018, 14h58
Bousk

En fait pour debuguer un code, il faut voir le code et pas un truc qui n'a qu'une vague ressemblance ou rien à voir :calim2:
Compilateur spécifique ou pas, il est très certainement possible d'avoir un résultat correct.
17/10/2018, 15h07
o_Nejma

Oui, je comprends, tu as tout à fait raison. Mais d'une part le code n'est pas le mien, je fais uniquement le test. Et d'autres part je n'ai enlevé que d'autres appels de fonctions qui n'ont rien avoir avec les deux que j'ai gardées ou les données qu'elles utilisent.

Merci
18/10/2018, 11h56
Sve@r
Bonjour

Citation:

Envoyé par o_Nejma

Et d'autres part je n'ai enlevé que d'autres appels de fonctions qui n'ont rien avoir avec les deux que j'ai gardées ou les données qu'elles utilisent.

Donc puisque tu n'as fait qu'enlever des appels, alors cette fonction que tu as postée hier
Code:

1 2 3 4 5 6 //functions stubbing: void FonctionReadingData(My_struct_t My_Data) { R_Data_Str = My_Data; R_Data_Ptr = (My_struct_t *)(&My_Data); }
n'a pas été modifiée et correspond bien au code d'origine.

Donc, comme dit Bousk, tu récupères l'adresse d'une variable locale (le paramètre "My_Data") ; variable qui est supprimée à la fin de la fonction et où l'emplacement mémoire (donc l'adresse) est réaffecté à autre chose.

Merci pour vos remarques et éclaircissements.
Mais dans la fonction main() j'appelle les deux fonctions en leur communiquant la même structure locale W_Data_Str et quand je récupère le dernier élément du dernier champ (R_Data_Str.DataLastTable[1]) sa valeur n'est pas mis à jour! Sachant que une fois je supprime la fonction d'alignement du typedef (__attribute__ ((aligned (2))))le champ est mis à jour.

Je ne comprends pas ce que le compilateur fait avec et sans alignement de cette structure! Comment la modification de ce champ dépend de cet alignement?
Code:

1 2 3 4 5 6 FonctionWritingData(&W_Data_Str); FonctionReadingData(W_Data_Str); printf("Print the last item value of the last struct filed:\n"); printf("After Reading: %d \n",R_Data_Str.DataLastTable[1]);
cordialement,

18/10/2018, 13h54
Sve@r

Citation:

Envoyé par o_Nejma

Mais dans la fonction main() j'appelle les deux fonctions en leur communiquant la même structure locale W_Data_Str et quand je récupère le dernier élément du dernier champ (R_Data_Str.DataLastTable[1]) sa valeur n'est pas mis à jour! Sachant que une fois je supprime la fonction d'alignement du typedef (__attribute__ ((aligned (2))))le champ est mis à jour.

Citation:

Envoyé par o_Nejma

2- Quand je passe la sortie de la premiere fonction à la deuxieme par adresse (FonctionReadingData)là aussi le problème disparaît! (en gardant l'alignement)

Personnellement, je ne passe jamais de structure par valeur à une fonction mais toujours par adresse. D'une part parce que le passage recopie l'intégralité de l'élément passé (et vaut mieux recopier une adresse de 4/8 octets qu'une structure de 4/8 milliards d'octets). Et d'autre part parce que je me suis toujours méfié de la façon qu'a l'optimiseur d'optimiser des trucs un peu complexes. Donc s'il optimise une seule structure et que je récupère n fois son adresse dans n fonctions il n'y a toujours qu'une seule et même structure une seule fois optimisée. Mais si je copie n fois la structure dans n fonctions alors là l'optimisation se fera n fois et va t'en savoir comment l'optimisation se fait et de quoi elle dépend... Et il semble justement que tu me donnes raison sur ce point.

Donc puisque tu as une solution qui fonctionne, et que c'est aussi la solution que je préconise de façon générale, ben voilà quoi. Quant au pourquoi du comment de l'échec de l'autre solution...
18/10/2018, 14h51
o_Nejma

Oooooh qu'est ce que j'adore tes explications :ave::ave::ave:
Donc Quoiqu'il ne y'ait rien qui empêche de passer une structure par valeur mais on n'a moins de maîtrise de ce qui se passerait lors de la compilation.
Merci beaucoup!

L'alignement n'est l'origine du problème. Il fait apparaître ou cache un autre problème.

On dirait que ton code ressemble à ça :
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 #include <stdio.h> typedef struct { int a; int b; int c; int d; } S; void print(const S* s) { if (s != NULL) { printf("%p : %d %d %d %d\n", (void*) s, s->a, s->b, s->c, s->d); } else { puts("NULL"); } } S* pointer = NULL; void read(S s) { pointer = &s; // s est copie faite sur la pile et sera bientôt effacée... printf("Inside read --> "); print(pointer); } // ici, pointer pointe sur n'importe quoi! int main() { S s = {10, 11, 12, 13}; puts("Initial"); print(&s); puts("0"); print(pointer); read(s); print(pointer); puts("1"); print(pointer); read(s); print(pointer); }
Chez moi, maintenant, tout de suite, sur ce PC, il affiche :
Initial
000000000061FE40 : 10 11 12 13
0
NULL
Inside read --> 000000000061FDE0 : 10 11 12 13
000000000061FDE0 : 10 11 12 13
1
000000000061FDE0 : 1 0 1 0
Inside read --> 000000000061FDE0 : 10 11 12 13
000000000061FDE0 : 10 11 12 13
On tente d'afficher les données présentes à une adresse sur la pile. Les données sont valides dans la fonction, mais le pointeur est invalide dés qu'on sort de la fonction. Tu n'auras peut-être pas le même comportement en testant chez toi.

23/10/2018, 14h56
o_Nejma

Citation:

Envoyé par Bktero

L'alignement n'est l'origine du problème. Il fait apparaître ou cache un autre problème.

Merci pour ta réponse Bktero et désolée pour ma réponse tardive.

Je voulais pas répondre avant d'analyser. Pour m'assurer que l'alignement ne cache pas un problème potentiel j'ai alignée la structure manuellement et réexecuter mon test (avec et sans alignement) et j'ai eu le même résultats (qui est bon dans ce cas aucun champ n'est altéré...).

Du coup je pense que Sve@r avait bien raison, et que le fait de laisser la main à l'optimiseur sur une structure passée par valeur n'est pas du tout "safe"!

Je ne sais pas qu'avait mis la discussion à Résolue mais en tout cas merci :).
24/10/2018, 11h33
Matt_Houston

Cela n'a rien à voir : il s'agit purement et simplement d'un bug du fait de l'auteur du programme. Ce programme C n'est pas écrit correctement et son exécution entraîne un comportement indéterminé, tu ne peux rien en conclure.