[Résolu] adressage mémoire avec gcc
Bonjour,
Je développe un programme sous linux.
Je commence à avoir pas mal de variables et je constate que mon programme segfault si j'en déclare trop.
Connaissez-vous la taille maximale d'une structure ?
Voici ce qui plante:
Code:
1
2
3
4
5
| engine_struct stre_mot;
engine_status liais;
stre_mot = get_engine_struct(argv[2]);
liais=defliaisons(stre_mot); //C'est là que ça plante, à l'appel de defliaisons. Aucune instruction dans defliaisons n'a le temps d'être exécutée. |
avec :
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
| typedef struct
{
tpe tpecol[401]; //etat thermo dans collec.
double rho[401]; // rho dans collec.
double u[401]; // vitesse particules dans collec.
double en[401]; // energie dans collec.
double dx; // dx mas du tuyau
double n; //nombre de noeud du tuyau
double d[401]; //diamètre dans tuyau
double s[401]; //Section dans tuyau
double x[401];
double epsilon; //rugosité tu pipe
double tw;// temperature paroie collect.
char *typeinlet; //type de l'élément connecté en entrée
num_el_st numinlet; // numéro de structure et d'élément de l'élément connecté en entrée
char *typeoutlet; //type de l'élément connecté en sortie
num_el_st numoutlet; // numéro de structure et d'élément de l'élément connecté en sortie
} col_status;
typedef struct
{
tpe tpe; //état thermo dans le cylindre.
int numel; //numéro d'élémént
char *typeinlet; //type de l'élément connecté en entrée
num_el_st numinlet; // numéro de structure et d'élément de l'élément connecté en entrée
char *typeoutlet; //type de l'élément connecté en sortie
num_el_st numoutlet; // numéro de structure et d'élément de l'élément connecté en sortie
char *type3; //type de l'élément connecté en 3
num_el_st num3; // numéro de structure et d'élément de l'élément connecté en 3
} cyl_status;
typedef struct
{
tpe tpe; //état thermo dans la jonction
int numel; //numéro d'élémént
int nb_of_connections; //nombre de connections
char *type[4]; //type de l'élément connecté en i
num_el_st num[4]; // numéro de structure et d'élément de l'élément connecté en i
} vol_status;
typedef struct
{
vol_status col_v[51]; //Status des collecteurs simulés par un volume
col_status col[[color=red]48[/color]]; //Status des collecteurs simulés par les équations ondes
vol_status vol[21]; //Status des volumes (ou jonctions)
cyl_status cyl[21]; //Status des cylindres
} engine_status; |
Voici ce qui passe:
même chose avec
Code:
1
2
3
4
5
6
7
8
|
typedef struct
{
vol_status col_v[51]; //Status des collecteurs simulés par un volume
col_status col[[color=red]41[/color]]; //Status des collecteurs simulés par les équations ondes
vol_status vol[21]; //Status des volumes (ou jonctions)
cyl_status cyl[21]; //Status des cylindres
} engine_status; |
Avez-vous une idée ? Est-ce qu'il existe une option pour augmenter la taille d'adressage d'un exécutable généré avec gcc ?
Merci d'avance
Frédéric
[Merci de penser à entourer votre code avec les balises prévues à cet effet. gansoleil]
Re: adressage mémoire avec gcc
Citation:
Envoyé par fraisdos
Je développe un programme sous linux.
Je commence à avoir pas mal de variables et je constate que mon programme segfault si j'en déclare trop.
Si elles sont définies en mémoire automatique (variables locales), c'est normal. Il faut absolument éviter les gros objets (tableaux, structure) en mémoire auto.
Citation:
Connaissez-vous la taille maximale d'une structure ?
Ce n'est probablement pas le problème. Si tu y tiens, les minimums garantis par le langage sont :
- C90 : 32768 bytes
- C99 : 65536 bytes
Pour une implémentation donnée, un objet automatique ou statique ne peut dépasser la taille de (size_t)-1 bytes.
Pour un objet dynamique, c'est le (size_t)-1 * (size_t)-1 bytes (pour ça, il faut calloc()). Il s'agit de limites absolues théoriques. Dans la réalité, il faut tester la valeur retournée par *alloc(). Si c'est NULL, l'allocation a échoué.
Citation:
Voici ce qui plante:
Code:
1
2
3
4
|
engine_struct stre_mot;
engine_status liais;
. |
Si ceci est défini en mémoire auto (pas clair, ton code est incomplet), tu as compris pourquoi ça plante. 2 monstres en mémoire auto -> crash.
Essayer en static pour lever le doute :
Code:
1
2
3
|
static engine_struct stre_mot;
static engine_status liais; |
mais c'est du code à la barbare. Ca peut suffire dans une bidouille, mais ça consomme de la mémoire de façon permanente (et je ne parle pas des problèmes de réentrance), pas sûr que l'application supporte ça...
Sinon, la solution est évidemment l'allocation dynamique (penser à liberer le monstre après usage).
