Segmentation fault - Struct d'array

Version imprimable

Bonjour,

Je chercher � utiliser un curseur qui fetch des donn�es dans une struct de tableaux (PRO*C) mais j'ai une segmentation fault de c que j'aimerai �lucider.

Voici la struct que j'utilise :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /* Peut-être trouver une façon de faire dynamique ... */ #define ARRAY_LENGTH 100 /**************************** Struct definition ************************************************************/ /* Structure de donnée représentant l'ensemble des tableaux utilisés pour stocker les données de rating_score. */ typedef struct { long PersonIdn[ARRAY_LENGTH]; char RatingModel[ARRAY_LENGTH][CODE_LENGTH]; char ModelVar[ARRAY_LENGTH][CODE_LENGTH]; char ModelValue[ARRAY_LENGTH][51]; long RatingScoreSeq[ARRAY_LENGTH]; long RequestNumber[ARRAY_LENGTH]; } DataToInsert;
Et le probl�me que j'ai est que si je change ARRAY_LENGTH et que je met cela � 1000, cela me fait une segmentation fault alors qu'a 100 ou m�me 200 comme indiqu�, tout se passe bien.

Une raison � cela?

Merci beaucoup de votre aide et de votre temps,
Albin.

ps : j'ai pas forc�ment besoin d'utiliser une taille de 1000 mais j'aime pas laisser ce genre de question en suspens...

07/12/2011, 10h08
diogene

Avec le peu d'informations que tu communiques (valeur de CODE_LENGTH ? mode de cr�ation des variables DataToInsert ? code qui fait planter ?...), la seule chose qu'on puisse dire est que la taille de la structure est peut �tre alors trop grande pour �tre cr��e en allocation automatique (variable locale sur la pile).

Comme j'ai dit, le probl�me vient de la taille de ARRAY_LENGTH qui devient trop grande.

La valeur de CODE_LENGTH est de 10. Et comme j'ai dit aussi, la struct est remplie par un curseur de PRO*C :
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 EXEC SQL CONTEXT USE :*ctx; /* On déclare un curseur */ EXEC SQL WHENEVER SQLERROR DO OracleDBError(); EXEC SQL WHENEVER NOT FOUND DO break; EXEC SQL DECLARE RatingScore_Curs CURSOR FOR SELECT person_idn, rating_model, model_var, model_value, rating_score_seq, request_number FROM rating_score ORDER BY person_idn, rating_model, model_var; EXEC SQL OPEN RatingScore_Curs; if (sqlca.sqlcode != 0) { printf("Error openning RatingScore_Curs - SqlCode : %d\n", sqlca.sqlcode); return (void *) -1; } /* On ouvre le curseur et on fetch continuellement dans une struc d'array (DataToInsert) représentant une ligne. */ for(;;) { /* Structures de données utilisées pour le fetch : -selectedData : les données récupérées. -indicatorData : indicateur sur chaque champs permettant de savoir si la valeur retournée était NULL ou non (utilisé pour éviter une ORA-1455). */ DataToInsert selectedData; DataIndicator indicatorData; EXEC SQL FETCH RatingScore_Curs INTO :selectedData:indicatorData; if (sqlca.sqlcode != 0) { printf("Error fetching RatingScore_Curs - SqlCode : %d\n", sqlca.sqlcode); return (void *) -1; } }
Et c'est ce bout de code qui plante (le seul � utiliser la struct pour le moment). Oui je me doutais que la valeur devait �tre trop grande mais m�me si c'est une struct de 6 tableaux, 6 tableaux de taille 1000 c'est quand m�me minuscule compar� � certain programme non? J'ai d�j� trait� des matrice bien plus gigantesque sans avoir aucune segmentation fault...

Merci,
Albin.

07/12/2011, 10h35
Elijha

Bonjour,

Si je me rappel bien de mes cours de C, les variables globales sont stock�es sur le tas. Pour un programme C, le tas est limit� � 65536 octets. Si l'on prend la taille de ta structure en octets (avec un long � 4 octets par exemple, car cela peu changer d'une machine � une autre) on obtient :

Citation:

taille = (1000�4)+(1000�10x1)+(1000�10x1)+(1000�51x1)+(1000�4)+(1000�4) = 83000 octets

Donc il te manque environs 17ko.

Dans ce cas, il te reste plus que la solution de l'allocation dynamique de m�moire de ton tableau (malloc() et free()) qui te permettra d'utiliser beaucoup plus de m�moires.

A toi de jouer et bonne continuation.
07/12/2011, 10h40
diogene

Citation:

Si je me rappel bien de mes cours de C, les variables globales sont stock�es sur le tas

Non. Elles sont stock�es en g�n�ral dans une zone "programme". Les allocations sur le tas sont obtenues par allocation dynamique.

Citation:

Pour un programme C, le tas est limit� � 65536 octets.

Tu confonds avec la pile utilis�e par les variables en allocation automatique et qui est beaucoup plus limit�e en taille que le tas (mais 65536 est bien peu)

Les "grosses" variables doivent donc �tre cr��es en global ou par allocation dynamique.
07/12/2011, 11h06
AlbinOSG

Ce qui signifie que je dois soit cr�er ma struct en utilisant malloc/free ou alors la d�clarer en globale donc... mais comment faire?

Comme j'ai apprit la programmation en JAVA j'ai quelques souci avec les fa�ons de faire plus bas niveau. Par exemple, comme je fais pour d�clarer une struct avec des tailles de tableau dynamique?

Par exemple en voulant cr�er une struct ayant 6tableaux de taille 10 et une autre avec des tableaux de taille 20? Je dois cr�er les tableaux et les donner � la truc � l'aide de pointeur ? Ou y'a il un moyen de le faire � l'int�rieur m�me de la struct?

Merci infiniment,
Albin.

Citation:

Si je me rappel bien de mes cours de C, les variables globales sont stock�es sur le tas

mea culpa. C'est triste la vieillesse.

Apr�s quelques recherches (sur architecture x86) :
Segment de texte : code
Segment de donn�es : variables statiques et globales
Segment bss : variables non initialis�es
Segment de tas : variables allou�es dynamiquement
Segment de pile : variables, appels de fonctions etc.

[A v�rifier] La taille maximum en allocation serai limit�e � SIZE_MAX qui d�pend de la machine (size_t). Pour une machine 32 bits, cela serait 4294967295 octets.

En C l'allocation dynamique est tr�s simple, mais il faut absolument v�rifier l'�tat des pointeurs au retour des fonctions d'allocation et faire tr�s attention lors de l'utilisation, car en C il n'y a pas contr�le. Tu peux facilement te retrouver � �crire dans une zone m�moire qui n'appartient pas au programme.
Dans ton cas, il te faut d�clarer une structure de pointeurs, puis attribuer ces pointeurs en fonction de la taille voulue
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 // Déclarations typedef struct { long *PersonIdn ; char *RatingModel ; char *ModelVar ; char *ModelValue ; long *RatingScoreSeq ; long *RequestNumber; } DataToInsert ; DataToInsert table ; // Allocations table.PersonIdn = malloc(ARRAY_LENGTH * sizeof(long)) ; if(table.PersonIdn==NULL) { printf("Erreur d'allocation sur PersonIdn.\n") ; return -1 ; } table.RatingModel = malloc(ARRAY_LENGTH * CODE_LENGTH * sizeof(char)) ; if(table.RatingModel==NULL) { printf("Erreur d'allocation sur RatingModel.\n") ; free(table.PersonIdn) ; // Libération avant la sortie return -1 ; } // etc...
A la fin de ton programme, il faut lib�rer toute la m�moire qui a �t� pr�c�demment allou�e (fonction free).

Bonne continuation.

07/12/2011, 12h01
themadmax

Citation:

[A v�rifier] La taille maximum en allocation serai limit�e � SIZE_MAX qui d�pend de la machine (size_t). Pour une machine 32 bits, cela serait 4294967295 octets.

En th�orie sur une machine x86, mais ce chiffre est bien plus faible il est limit� par la m�moire physique et celle affect� au programme par l'OS, qui s'en garde une peu pour lui et les autres programmes programme.

Citation:

Tu peux facilement te retrouver � �crire dans une zone m�moire qui n'appartient pas au programme.

Pour �tre un peu tatillon si ton OS est r�cent il est impossible de sortir de sa zone m�moire une exception sera lev� avant. Mais en tout cas le r�sultat est le m�me il ne faut pas d�pass� la taille allou�.

@Elijha :

Citation:

Dans ton cas, il te faut d�clarer une structure de pointeurs, puis attribuer ces pointeurs en fonction de la taille voulue...

Cette complication est inutile.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct
{
	long		PersonIdn[ARRAY_LENGTH];
	char 		RatingModel[ARRAY_LENGTH][CODE_LENGTH];
	char		ModelVar[ARRAY_LENGTH][CODE_LENGTH];
	char		ModelValue[ARRAY_LENGTH][51];	
	long  	        RatingScoreSeq[ARRAY_LENGTH];
	long		RequestNumber[ARRAY_LENGTH];
} DataToInsert; 
 
// ----en globale
DataToInsert table ;
// ----ou en allocation dynamique :
DataToInsert *table = malloc(sizeof *table) ;
....
free(table);

07/12/2011, 12h46
AlbinOSG

Un grand merci � vous deux, je me sens d�j� un peu plus � l'aise quand je joue avec les pointeurs et allocations dynamique !

Albin.