Programme marche en mode debug mais plante en mode run

Version imprimable

20/10/2010, 16h40
pKwan

Programme marche en mode debug mais plante en mode run

Bonjour,

J'ai un écrit un programme en c pour lire un fichier binaire et sauver les données dans une liste. J'utilise Code::Bloc (version 10.5) avec le GNU gcc.

Mon programme compile sans erreur et sans warning; il marche parfaitement en mode debugage (il va jusqu'au bout de programme); par contre, lorsque je le lance à partir de l'exécutable, il plante à un moment: c'est lors d'une allocation de mémoire d'une partie d'un élément de la liste. Il me renvoie un code -1073741819 (0xC0000005).

Est-ce que quelqu'un aurait un début d'explication?

Merci

Pascal
20/10/2010, 16h55
Invité(e)

Bonjour,

Pouvez vous poster le programme ou juste la partie qui pose problème ?

Sinon, ce genre de problème ressemble à un pointeur mal-initialisé.

Voilà la fonction qui plante en mode run

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
// Create an new element of the list to save the velocities and amplitudes.
struct AwacOrContConfigurationList* createNewElement(unsigned int nBins)
{
    // Allocation for the new element of the list.
    AwacOrContConfigurationList *element = malloc(sizeof(AwacOrContConfigurationList));
    //printf("Alloction pour element effectuee\n");
    if (element == NULL){
        fprintf(stderr, "%s: Out of memory\n", __FILE__);
        exit(MEMORY_ERROR);
    }
 
    // The element is a structure of one pointer for the data and one pointer towards the next element.
    // Allocation for the data.
    element->AwacOrContConfig = malloc(sizeof(AwacOrContConfiguration));
    //printf("Alloction pour element->AwacOrContConfig effectuee\n");
    if (element->AwacOrContConfig == NULL){
        fprintf(stderr, "%s: Out of memory\n", __FILE__);
        exit(MEMORY_ERROR);
    }
    // Memory allocation for the velocities and amplitude relativly to the number of cells.
    element->AwacOrContConfig->Vel1 = malloc(nBins * sizeof(double));
    if (element->AwacOrContConfig->Vel1 == NULL){
        fprintf(stderr, "%s: Out of memory\n", "createNewElement Vel1");
        exit(MEMORY_ERROR);
    }
    element->AwacOrContConfig->Vel2 = malloc(nBins * sizeof(double));
    if (element->AwacOrContConfig->Vel2 == NULL){
        fprintf(stderr, "%s: Out of memory\n", "createNewElement Vel2");
        exit(MEMORY_ERROR);
    }
    element->AwacOrContConfig->Vel3 = malloc(nBins * sizeof(double));
    if (element->AwacOrContConfig->Vel3 == NULL){
        printf( "%s: Out of memory\n", "createNewElement Vel3" );
        exit(MEMORY_ERROR);
    }
    element->AwacOrContConfig->amp1 = malloc(nBins * sizeof(int));
    if ( element->AwacOrContConfig->amp1 == NULL ){
        printf( "%s: Out of memory\n", "createNewElement amp1" );
        exit( MEMORY_ERROR );
    }
    //printf("Alloction pour element->AwacOrContConfig->amp1  effectuee\n");
 
 
    element->AwacOrContConfig->amp2 = malloc(nBins * sizeof(int)); // Plante ici 
    if ( element->AwacOrContConfig->amp2 == NULL ){
        printf( "%s: Out of memory\n", "createNewElement amp2" );
        exit( MEMORY_ERROR );
    }
    //printf("Alloction pour element->AwacOrContConfig->amp2 effectuee\n");
    element->AwacOrContConfig->amp3 = malloc(nBins * sizeof(int));
    if ( element->AwacOrContConfig->amp3 == NULL ){
        printf(  "%s: Out of memory\n", "createNewElement amp3" );
        exit( MEMORY_ERROR );
    }
    //printf("Alloction pour element->AwacOrContConfig->amp3 effectuee\n");
    element->next = NULL;
 
    return element;
}

Et voilà la structure correspondante:

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
typedef struct AwacOrContConfiguration AwacOrContConfiguration;
struct AwacOrContConfiguration{
    unsigned char Sync;         // Sync must == 165
    unsigned char Id;           // Id must == 36 for continental
    WORD Size;                  // Size of structure in number of words (1 word = 2 bytes)
    sysTime sClock;             //
    WORD Error;                 // Error code.
    WORD AnaIn1;                // Analog input1
    WORD Battery;               // Battery voltage (0.1 V)
    WORD SoundSpeed;            // Speed of sound (0.1 m/s) or analog input2.
    WORD Heading;               // compass heading (0.1°)
    WORD Pitch;                 // compass pitch (0.1°)
    WORD Roll;                  // compass roll (0.1°)
    unsigned char PressureMSB;  // pressure (MSB)
                                // (Pressure = 65536 * PressureMSB + PressureLSW)
    unsigned char Status;       // status code
    WORD PressureLSW;           // pressureLSW (mm)
    // A verifier format
    WORD Temperature;           // temperature (0.01°C)
    // Velocities
   double *Vel1;                  // velocity cell 1 to n, beam 1 or X or Eas (mm/s)
   double *Vel2;                  // velocity cell 1 to n, beam 2 or Y or North (mm/s)
   double *Vel3;                  // velocity cell 1 to n, beam 3 or Z or Up (mm/s)
   unsigned int *amp1;        // amplitude cell 1 to n, beam 1 (counts)
   unsigned int *amp2;        // amplitude cell 1 to n, beam 2 (counts)
   unsigned int *amp3;        // amplitude cell 1 to n, beam 3 (counts)
};

En mode run, le programme réussit à lire et à créer 3 éléments avant de planter au 4e.
En mode debug, il lit tout le fichier sans aucun problème....

Merci.

Pascal

20/10/2010, 17h26
jabbounet
peux-tu utiliser les balises codes?
[ CODE] [ /CODE]
pour formatter ton code comme ceci
Code:

1 2 3 4 if (a) { somethng... }
si je comprends bien, Tu as une structure AwacOrContConfigurationList que tu alloue dynamiquement.
Cette structure contiens un pointeur sur une structure AwacOrContConfig que tu alloue aussi dynamiquement.
et dans cette dernière tu alloue dynamiquement des tableaux de nbins double et unsigned int.

Quelle est la valeur de nbins a chaque appel?
20/10/2010, 17h36
pKwan

L'indentation a été perdue lorsque j'ai effectué le copier/coller.
Peux-tu préciser les balises code: dans mon éditeur code:block ou dans mon fureteur ?

Exact pour la description de la liste.

nbins en fait est identique pour tous les appels: dans ce cas 25 (mais il varie en fonction des fichiers à lire).

Toutes les suggestions pour optimiser le code seront les bienvenues (je ne suis pas un spécialiste du C).

Pascal
21/10/2010, 09h51
jabbounet

Citation:

Envoyé par pKwan

L'indentation a été perdue lorsque j'ai effectué le copier/coller.
Peux-tu préciser les balises code: dans mon éditeur code:block ou dans mon fureteur ?

non, quand tu poste un message sur le forum.

Citation:

nbins en fait est identique pour tous les appels: dans ce cas 25 (mais il varie en fonction des fichiers à lire).

As-tu affiché sa valeur à chaque appel voir si une valeur adhérente (a cause d'un souci quelconque) ne 'était pas glissé lors de l'exécution?

Donc tu as:

Code:

1
2
3
4
 struct AwacOrContConfigurationList {
  struct AwacOrContConfigurationList *next;
  struct AwacOrContConfiguration *AwacOrContConfig;
};

et pour effacer tu fais quelque chose dans ce style?

Code:

1
2
3
4
5
6
7
8
9
10
11
void deleteElement(struct AwacOrContConfigurationList *element) {
  free( element->AwacOrContConfig->amp3 );
  free( element->AwacOrContConfig->amp2 );
  free( element->AwacOrContConfig->amp1 );
 
  free( element->AwacOrContConfig->Vel3 );
  free( element->AwacOrContConfig->Vel2 );
  free( element->AwacOrContConfig->Vel1 );
  free( element->AwacOrContConfig);
  free( element );
}

pourquoi avoir deux pointeur dans ta structure List?

Avec:

Code:

1
2
3
4
struct AwacOrContConfigurationList {
  struct AwacOrContConfigurationList *next;
  struct AwacOrContConfiguration AwacOrContConfig;
};

Cela t'économise un allocation dynamique de AwacOrContConfig et t'évite le second malloc de createNewElement.
mais cela te change l'écriture pour les malloc de Velx et ampx "." à la place de "->"
par exemple avec la fonction de destruction cela donne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
void deleteElement(struct AwacOrContConfigurationList *element) {
  free( element->AwacOrContConfig.amp3 );
  free( element->AwacOrContConfig.amp2 );
  free( element->AwacOrContConfig.amp1 );
 
  free( element->AwacOrContConfig.Vel3 );
  free( element->AwacOrContConfig.Vel2 );
  free( element->AwacOrContConfig.Vel1 );
  /*  free( element->AwacOrContConfig);*/
  free( element );
}

Autrement j'ai essayé ton code, il semble correct, ton problème proviens d'ailleurs peu etre dans la façon de chainer la liste?

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
 
int main(void) {
 
  unsigned int i = 1;
  struct AwacOrContConfigurationList *initial =  createNewElement(10);
  struct AwacOrContConfigurationList *current = initial;
 
  for (i = 2 ; i < 25; i++) {
    printf("Allocation de l'element %d\n",i);
    struct AwacOrContConfigurationList * elt = createNewElement(i*10);
    current -> next = elt;
    current = current -> next;
  }
 
  current = initial;
  i = 1;
  while (current != NULL) {
    printf("Nettoyage d'un element %d\n",i++);
    struct AwacOrContConfigurationList * elt = current;
    current = current -> next;
    deleteElement(elt);
  }
 
  return EXIT_SUCCESS;
}

21/10/2010, 14h25
pKwan

Merci Jabounet,

Je vais lire attentivement ton dernier message et je reviens après.

Pascal

Comme demandé, j'ai regardé la valeur de nBins pour chaque itération et elle ne varie pas comme prévu.
Citation:
et pour effacer tu fais quelque chose dans ce style?
Code:

1 2 3 4 5 6 7 8 9 10 11 void deleteElement(struct AwacOrContConfigurationList *element) { free( element->AwacOrContConfig->amp3 ); free( element->AwacOrContConfig->amp2 ); free( element->AwacOrContConfig->amp1 ); free( element->AwacOrContConfig->Vel3 ); free( element->AwacOrContConfig->Vel2 ); free( element->AwacOrContConfig->Vel1 ); free( element->AwacOrContConfig); free( element ); }
Oui à peu près, mais je le fais juste à la fin de mon programme.
Citation:
pourquoi avoir deux pointeur dans ta structure List?
Avec:
Code:

1 2 3 4 struct AwacOrContConfigurationList { struct AwacOrContConfigurationList *next; struct AwacOrContConfiguration AwacOrContConfig; };
Je ne sais pas vraiment, comme la structure AwacOrContConfig est assez complexe, j'ai trouvé qu'utiliser un pointeur était plus efficace pour la gestion de la mémoire.
Je vais essayer ta proposition.
Citation:
Autrement j'ai essayé ton code, il semble correct, ton problème proviens d'ailleurs peu etre dans la façon de chainer la liste?
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 int main(void) { unsigned int i = 1; struct AwacOrContConfigurationList *initial = createNewElement(10); struct AwacOrContConfigurationList *current = initial; for (i = 2 ; i < 25; i++) { printf("Allocation de l'element %d\n",i); struct AwacOrContConfigurationList * elt = createNewElement(i*10); current -> next = elt; current = current -> next; } current = initial; i = 1; while (current != NULL) { printf("Nettoyage d'un element %d\n",i++); struct AwacOrContConfigurationList * elt = current; current = current -> next; deleteElement(elt); } return EXIT_SUCCESS; }
En fait, quand je lis le fichier de données, je ne connais pas le nombre d'élément à insérer dans ma liste.
Voici grossièrement l'algorithme:
Tant que la fin du fichier n'est pas atteinte
Lecture du fichier tant que la fin n'est pas atteinte.
Si le byte lu indique que c'est le début d'un ensemble de données:
Code:

1 2 3 4 5 6 7 8 9 // Create a new element for the data list. AwacOrContConfigurationList *maillon; maillon = createNewElement( nBins ); // Copy the data into the element. The variable data is the raw data. checkSum = copyElement( data, maillon, nBins); // Append the element to the list. appendElement( dataStruct->ptr, maillon );
Voilà,

Ce que je ne comprends pas, c'est quand mode run, mon programme plante à la lecture du 3è ensemble de données alors qu'en mode debugage, tout se passe s'en problème...

Pascal

21/10/2010, 22h02
jabbounet

Tout simplement parque en mode "run" le compilateur n'insère pas les informations de débuggage dans l'exécutable,la mémoire n'est pas organisée tout a fait de la même façon donc cela peux masquer temporairement des problèmes.

Cela ne veux pas dire que tu n'as pas le même problème en mode "debug" simplement qu'il ne se manifestera pas nécessairement avec les même conditions.

Peux tu montrer copyElement et appendElement?
Comment est lu/initialisé nBins?
Que représentent data et dataStruct?

Merci pour la différence entre le mode run et debug.

La variable data est le contenu brute de mon fichier de données sous forme d'un pointeur de unsigned char.

DataStruct est LA structure pour sauvegarder les données provenant de la variable data (attention c'est un peu une usine à gaz).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
// The main data structure.
typedef struct dataStructure dataStructure;
struct dataStructure {
    hardwareConfiguration *hardConfig;
    headConfiguration *headConfig;
    userConfiguration *userConfig;
    // The list of data.
    AwacOrContConfigurationList *dataList;
    listPtr *ptr;
    unsigned int ensembles; // Ensemble number
    char *instType; // Instrument type: Continental, Aquadopp, Awac .....
};

avec ma liste:

Code:

1
2
3
4
5
6
// A structure to remember the first and current element of the list.
typedef struct listPtr listPtr;
struct listPtr{
   AwacOrContConfigurationList *pStart;
   AwacOrContConfigurationList *pCurrent;
};

Mon code plante en mode run dans cette fonction

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
int copyElement(unsigned char *data, AwacOrContConfigurationList* maillon, int *offset, unsigned int nBins, double scale)
{
    // Variables.
    int i, checkSum, offsetTmp;
    bcdClock clock;
 
    // Get the data.
    maillon->AwacOrContConfig->Sync = *(data + *offset);
    maillon->AwacOrContConfig->Id = *(data + *offset + 1);
    maillon->AwacOrContConfig->Size = (*(WORD*)(data + *offset + 2));
    clock.cMinute = *(data + *offset + 4);
    clock.cSecond = *(data + *offset + 5);
    clock.cDay = *(data + *offset + 6);
    clock.cHour = *(data + *offset + 7);
    clock.cYear = *(data + *offset + 8);
    clock.cMonth = *(data + *offset + 9);
    maillon->AwacOrContConfig->sClock = clockToSystemTime(clock);
    maillon->AwacOrContConfig->Error = (*(WORD*)(data + *offset + 10));
    maillon->AwacOrContConfig->AnaIn1 = (*(WORD*)(data + *offset + 12));
    maillon->AwacOrContConfig->Battery = (*(WORD*)(data + *offset + 14));
    maillon->AwacOrContConfig->SoundSpeed = (*(WORD*)(data + *offset + 16));
    maillon->AwacOrContConfig->Heading = (*(WORD*)(data + *offset + 18));
    maillon->AwacOrContConfig->Pitch = (*(WORD*)(data + *offset + 20));
    maillon->AwacOrContConfig->Roll = (*(WORD*)(data + *offset + 22));
    maillon->AwacOrContConfig->PressureMSB = (*(data + *offset + 24));
    // Pressure = 65536 * PressureMSB + PressureLSW.
    maillon->AwacOrContConfig->Status = (*(WORD*)(data + *offset + 26));
    maillon->AwacOrContConfig->PressureLSW = (*(WORD*)(data + *offset + 26));
    maillon->AwacOrContConfig->Temperature = (*(WORD*)(data + *offset + 28));
 
   // Read the velocities.
   for(i = 0; i <= nBins - 1; i++){
//      *(vel1 + i) = (*(short*)(data + *offset + (118 + (2 * i))));
      maillon->AwacOrContConfig->Vel1[i] = ( double ) (*(short*)(data + *offset + (118 + (2 * i)))) * scale;
   }
   offsetTmp = *offset + (118 + (2 * i));
   for(i = 0; i <= nBins - 1; i++){
      maillon->AwacOrContConfig->Vel2[i] = ( double ) (*(short*)(data + offsetTmp + (2 * i))) * scale;
   }
   offsetTmp = offsetTmp + (2 * i);
   for(i = 0; i <= nBins - 1; i++){
      maillon->AwacOrContConfig->Vel3[i] = ( double ) (*(short*)(data + offsetTmp + (2 * i))) * scale;
   }
   offsetTmp = offsetTmp + (2 * i);
   // Read the amplitudes.
   for(i = 0; i <= nBins - 1; i++){
      maillon->AwacOrContConfig->amp1[i] = (unsigned int) (*(data + offsetTmp + (1 * i)));
   }
   offsetTmp = offsetTmp + (1 * i);
   for(i = 0; i <= nBins - 1; i++){
      maillon->AwacOrContConfig->amp2[i] = (unsigned int) (*(data + offsetTmp + (1 * i)));
   }
   offsetTmp = offsetTmp + (1 * i);
   for(i = 0; i <= nBins - 1; i++){
      maillon->AwacOrContConfig->amp3[i] = (unsigned int) (*(data + offsetTmp + (1 * i)));
   }
   offsetTmp = offsetTmp + (1 * i) ;
 
   // There is a "Fill" byte if the cell number is odd (impair).
   if (nBins % 2 == 1){
      offsetTmp++;
   }
   checkSum = (*(WORD*)(data + offsetTmp));
   *offset = (offsetTmp + 2);
   return checkSum;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Add an element (ie an ensemble) into the data list.
void appendElement(listPtr *ptr, AwacOrContConfigurationList *element)
{
   if(ptr){
      // A temporary pointer which points toward the current element of the list.
      AwacOrContConfigurationList *pTemp = ptr->pCurrent;
      // If the list is empty (ie firt element)
      if (pTemp == NULL){
         //
         ptr->pStart->next = element;
         element->next = NULL;
      }
      else {
      // The data list is not empty.
         element->next = pTemp->next;
         pTemp->next = element;
      }
      ptr->pCurrent = element;
   }
}

Au pire je peux envoyer tout mon code dans un zip ?

Pascal

22/10/2010, 17h24
pKwan

Je travaille normalement sous xp 32bits.
Je viens de compiler le même code sous linux. En exécutant le programme, il ne plante plus au même endroit mais juste à la fin du programme lors d'une libération de mémoire.
Cela commence à me prendre la tête ...
22/10/2010, 21h04
pKwan

J'ai résolu mon problème. :ccool:

Tout venait d'un malheureux problème d'allocation de mémoire pour une chaine de caractères. J'avais oublié à plusieurs endroit d'allouer de la place pour le caractère de fin de chaine !!!

Comme quoi, un petit oubli peut faire planter tout un programme.

Pascal
22/10/2010, 23h26
jabbounet

salut désolé je n'étais pas là aujourd'hui.

Si ton programme peux se compiler sous linux, je te conseille d'utiliser un outil comme valgrind afin de vérifier les problèmes liés à la mémoire.