Discussion :

[fraisdos]

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 :

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

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 :

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
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 :

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

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]

[gangsoleil]

Bonjour,

Qu'entends-tu par

Je commence à avoir pas mal de variable et constate que mon programme segfault si j'en déclare trop.

Qu'est-ce que trop ? 1 ? 10 ? 1000 ?

As-tu une idée de la taille globale de la structure que tu déclares ?
Si ce n'est pas le cas, pourrais-tu nous la donner ?

[Emmanuel Delahaye]

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.

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é.

Voici ce qui plante:

Code :

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

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 :

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

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).

[fraisdos]

Merci Emmanuel,

En effet avec static le programme passe.
Mais comme vous me le conseillez je vais faire de l'allocation dynamique.

Le programme que l'on développe avec mon collégue permettra de simuler les moteurs multicylindres (jusqu'à 20). Ces moteurs peuvent avoir enormément de collecteurs dans lesquels on résoud les phénoménes d'ondes par discrétisation. Donc beaucoup de tableaux pour beaucoup de variables.

Merci pour votre aide,


Frédéric

[fraisdos]

Puis avec l'allocation dynamique tout fonctionne parfaitement. J'ai pu augmenter le nombre de variables.

Merci beaucoup,

Je continue mon programme.


Frédéric