C'è un memory Leak in questo codice?

[prowler]

Ciao,
sto letteralmente impazzendo nel cercare di capire se in questo codice c'è un memory leak, ho veramente bisogno di aiuto :-)

Dunque ho definito le mie strutture dati in questo modo:

Codice:	Espandi/Riduci
typedef char IOTextZ[20+1]; typedef struct {   int       _sigId;   int       _sampleNumber;   int       _dataType;   float*    _numVal;   short*    _numNull;   // max string size limited to 20 char for the moment   IOTextZ*  _textVal;   short*    _textNull; } DataAcBufferItem;

In sostanza è una struct che contiene 3 interi e 4 array che in seguito allochero' dinamicamente.

Quello che voglio fare è pero' prima di tutto creare un array di struct.
Definisco pertanto 2 variabili globali...

Codice:	Espandi/Riduci
static DataAcBufferItem     *dataAcBuffer;  static int                   numElements;

La prima rappresenta un puntatore al primo elemento dell'array di struct.
La seconda tiene traccia di quanti elementi ci sono nell'array.

La grandezza di questo array è un parametro che conosco, diciamo 100.
Per allocare innanzitutto l'array di struct chiamo questa funzione:

Codice:	Espandi/Riduci
void DataAcBuffer_Allocate(int size) {   printf("Allocating... numElements = %d\n", size);   dataAcBuffer = (DataAcBufferItem *) malloc(sizeof(DataAcBufferItem) * size); /* allocate memory */   if(dataAcBuffer == NULL)     printf("Memory Allocation Failed!\n"); }

Fin qui tutto chiaro spero...
A questo punto ho un array di "size" elementi, diciamo 100.

Poi quello che faccio è chiamare una funzione che copia in ogni elemento di questo array dei dati passati come parametro:

Codice:

Espandi/Riduci

void DataAcBuffer_CreateAndAdd(                                int      sigId,                                int      sampleNumber,                                int      datatype,                                float    numVal[],                                short    numValNull[],                                char*    textVal[],                                short    textValNull[])                                 {   int                   i;   int                   position;   // search for the specified sigId in the shared buffer first   position = DataAcBuffer_Find(sigId);   // Add new element only if not found...   if (position < 0)   {     //copy stuff into new item     dataAcBuffer[numElements]._sigId = sigId;     dataAcBuffer[numElements]._sampleNumber = sampleNumber;     dataAcBuffer[numElements]._dataType = datatype;     dataAcBuffer[numElements]._numVal = (float *) malloc (sampleNumber * sizeof(float));     dataAcBuffer[numElements]._numNull = (short *) malloc (sampleNumber * sizeof(short));     dataAcBuffer[numElements]._textVal = (IOTextZ *) malloc (sampleNumber * sizeof(IOTextZ));     dataAcBuffer[numElements]._textNull = (short *) malloc (sampleNumber * sizeof(short));     for(i = 0; i < sampleNumber; i++)     {       strcpy(dataAcBuffer[numElements]._textVal[i], textVal[i]);       dataAcBuffer[numElements]._textNull[i] = textValNull[i];       dataAcBuffer[numElements]._numVal[i] = numVal[i];       dataAcBuffer[numElements]._numNull[i] = numValNull[i];     }     numElements++;   } } // DataAcBuffer_CreateAndAdd

Anche qui eseguo un'allocazione dinamica della memoria per ogni elemento...

Infine chiamo una funzione Free che in teoria libera la memoria...

Codice:

Espandi/Riduci

void DataAcBuffer_Free() {   int i = 0;   printf("Executing Free... numElements = %d\n", numElements);   for (i = 0; i < numElements; i++)   {     free(dataAcBuffer[i]._textVal);     free(dataAcBuffer[i]._textNull);     free(dataAcBuffer[i]._numVal);     free(dataAcBuffer[i]._numNull);     dataAcBuffer[i]._textVal = NULL;     dataAcBuffer[i]._textNull = NULL;     dataAcBuffer[i]._numVal = NULL;     dataAcBuffer[i]._numNull = NULL;   }   // free only if there are elements in the buffer, otherwise memory is corrupted!   if(numElements != 0)   {     free(dataAcBuffer);     dataAcBuffer = NULL;     numElements = 0;   } }

Quando eseguo il programma i "Private Bytes" mostrano un andamento crescente purtroppo, segno che la memoria allocata non viene liberata per qualche arcano motivo.
Spero che qualcuno mi aiuti a trovarlo! Sinceramente non so dove sbaglio...

Grazie in anticipo per l'aiuto!
Ciao

[prowler]

Uhm, nessuno risponde vedo

Aggiungo un'informazione che potrebbe fare la differenza, l'aggiungo solo ora in quanto ho appena realizzato anch'io una possibile causa del leak.

Tutto il codice postato viene chiamato da altro codice C# ma da 2 thread differenti...
Non sto a spiegare come C# chiami C, credo che non sia rilevante.

Il main thread esegue:

Allocate e Free

mentre il worker thread esegue la

CreateAndAdd

nello static buffer.

Ora, ho letto che malloc e free non sono thread safe, ma è anche vero che è solo un thread che scrive nella memoria, nessun altro.

Spero che qualcuno mi aiuti!

[ixamit]

Se hai una piattaforma Linux || Mac OS X ti consiglio valgrind
Io lo trovo in molti casi indispensabile.

Saluti,
Max