Probleme mit malloc und free

[Lars (Gast)]

Hallo,

hab grad Probleme mit malloc und free. Arbeite mit dem LPC1758 
Prozessor. Bei free() wird augenscheinlich nicht der komplette zuvor 
allokierte Speicher nicht wieder freigegeben.

Anbei ein kleines Testbeispiel:

unsigned char *GetMem(unsigned int *len)
{
  unsigned char *ptr; 
  ptr = (unsigned char *)malloc(sizeof(unsigned char) * *len); 
  if(ptr == NULL)
    return NULL;
  return ptr; 
}

int main(void)
{
  unsigned int length = 12; 
  unsigned char *ptr; 

  while(1)
  {
     ptr = GetMem(&length); 
     if(ptr != NULL)
     {
        //do something
        free(ptr); 
     }
  }
}

Wenn free(ptr) aufgerufen wird, werden im Speicher nur zwei Bytes auf 
0x00 zurückgesetzt, nicht die 12 Bytes.

Und nach ein paar Aufrufen hängt sich der Prozesor beim malloc() Call 
auf. Allerdings ohne einen Interrupt aufzurufen wie nen 
HardFault_Handler etc.

Mach ich bei malloc und free irgendetwas falsch?

Gruß
Lars

[PittyJ (Gast)]

Wenn free(ptr) aufgerufen wird, werden im Speicher nur zwei Bytes auf
0x00 zurückgesetzt, nicht die 12 Bytes.


Warum sollte bei free() überhaupt etwas auf 0x00 gesetzt werden?

[Frank M. (ukw) (Moderator)]

Lars schrieb:

>   if(ptr == NULL)
>     return NULL;
>   return ptr;

Dieses if ist unnötig, ein

    return ptr;

reicht hier. Wenn ptr == NULL wird auch NULL zurückgegeben ;-)

> Wenn free(ptr) aufgerufen wird, werden im Speicher nur zwei Bytes auf
> 0x00 zurückgesetzt, nicht die 12 Bytes.

Kommt auf die Implementation an. Wahrscheinlich wird der ehemals 
allokierte Bereich lediglich wieder zum erneuten Gebrauch von malloc() 
freigegeben, aber deshalb nicht unbedingt wieder frei.

> Und nach ein paar Aufrufen hängt sich der Prozesor beim malloc() Call
> auf.

Kann es sein, dass Dein erneuter Aufruf von malloc() mehr als vorher 
allokieren will? Wenn ja, kann der ehemals zur weiteren Benutzung 
freigegebene Speicherbereich evtl. nicht wieder genutzt werden und es 
wird wieder neuer Speicherplatz in Beschlag genommen. Das heisst: Du 
fragmentierst Dir mit der Zeit Deinen Speicher.

malloc() und free() sind auf nicht pagenden Systemen nur mit Vorsicht 
anzuwenden. Bei µCs würde ich sie eher meiden.

P.S.

Ich weiß nicht genau, warum Du einen Pointer auf length runtergibst und 
dann dieses Konstrukt

  malloc(sizeof(unsigned char) * *len);

verwendest.

Rufe GetMem() mit length auf und benutze

  malloc(len);

[Lars (Gast)]

Frank M. schrieb:
> malloc() und free() sind auf nicht pagenden Systemen nur mit Vorsicht
> anzuwenden. Bei µCs würde ich sie eher meiden.

das vermute ich auch. Der obige Code ist stark vereinfacht. Ich glaub 
ich habe eine Sache übersehen und zwar tritt der Fehler bei malloc nur 
dann auf, wenn ich zweimal hintereinander speicher allokiere.

unsigned char *GetMem(unsigned int *len)
{
  unsigned char *ptr; 
  ptr = (unsigned char *)malloc(sizeof(unsigned char) * *len); 
  if(ptr == NULL)
    return NULL;
  return ptr; 
}

void test(void)
{
  unsigned char *ptr2; 
  unsigned short number = 23; 
  ptr2 = (unsigned char *)malloc(sizeof(unsigned char) * number); 
  free(ptr2); 
}

int main(void)
{
  unsigned int length = 12; 
  unsigned char *ptr; 

  ptr = GetMem(&length);
  free(ptr); 
  //<- diese Aufrufe funktionieren und es werden 12 bytes auf 0x00
  //im speicher gesetzt 

  while(1)
  {
     ptr = GetMem(&length); 
     if(ptr != NULL)
     {
        test(); 
        free(ptr);  //hier werden nur noch vier bytes auf 0x00 gesetzt
                    //die ersten vier Bytes 
     }
  }
}

Beispiel: für ptr wird 0x100009C8 zurückgegeben nach malloc und für ptr2 
wird ebenfalls als Startaddr von malloc 0x100009C8 zurückgegeben...

Scheint überhaupt nicht zu funktionieren

[Frank M. (ukw) (Moderator)]

Ich kürze mal Deinen Source, weil hier viel Überflüssiges die Sicht 
vernebelt:

void test(void)
{
  unsigned char *ptr2; 
  unsigned short number = 23; 
  ptr2 = (unsigned char *)malloc(number); 
  free(ptr2); 
}

int main(void)
{
  unsigned int length = 12; 
  unsigned char *ptr; 

  ptr = malloc(length);
  free(ptr); 
  //<- diese Aufrufe funktionieren und es werden 12 bytes auf 0x00
  //im speicher gesetzt 

  while(1)
  {
     ptr = malloc(length);
     if(ptr != NULL)
     {
        test(); 
        free(ptr);  //hier werden nur noch vier bytes auf 0x00 gesetzt
                    //die ersten vier Bytes 
     }
  }
}

Was habe ich geändert:

1. Den Pointer beim Aufruf von GetMem() ersetzt durch den Wert von
   length, denn hier ist kein Pointer notwendig.

2. die Konstruktion sizeof (sizeof(unsigned char) * *len) durch (len)
   ersetzt, denn die Multiplikation ist unsinnig. Du willst length
   Bytes.

3. Deine NULL-Pointer-Abfrage in GetMem() komplett gestrichen.

4. Letztendlich GetMem() komplett rausgeworfen, denn nun macht es
   nichts anderes mehr als malloc() selbst.

Dass irgendwann 12 Bytes und später mal 4 Bytes im Speicher auf 0x00 
gesetzt werden, ist kein Kriterium für korrekte/inkorrekte 
Funktionalität. malloc() erhebt keinen Anspruch darauf, den allokierten 
Speicher auch zu löschen. Das macht nur calloc(). Bei malloc() ist der 
Inhalt des allokierten Speichers undefiniert.

> Beispiel: für ptr wird 0x100009C8 zurückgegeben nach malloc und für ptr2
> wird ebenfalls als Startaddr von malloc 0x100009C8 zurückgegeben...

Das gibt mir allerdings zu denken. Dürfte nicht sein.

Ich kürze mal weiter:

int main(void)
{
  unsigned char *ptr; 
  unsigned char *ptr2; 

  ptr = malloc(12);
  free(ptr); 

  while(1)
  {
     ptr = malloc(12);

     if(ptr != NULL)
     {
        ptr2 = malloc(23);  // ist hier nun ptr == prtr2?
        free(ptr2);
        free(ptr);
     }
  }
}

Ist an der markierten Stelle nun ptr == ptr2 ?

[Fred (Gast)]

Lars schrieb:
> sizeof(unsigned char)

Ist gleich 1 per Definition. Aus der Multiplikation also wegfallen 
lassen.