Memory leak in C Program - c

Question

I have made a C program in which I have used structures defined as:
typedef struct Move{
int from_x;
int from_y;
int to_x;
int to_y;
int piece;
}Move;
typedef struct ListofMove{
Move* array;
int len;
}ListofMove;
typedef struct Board{
int B[8][8];
double value;
double value_w;
double value_b;
int material_w;
int material_b;
int mobility_w;
int mobility_b;
int dev_w;
int dev_b;
int center_w;
int center_b;
int devArr[4][8];
int side;
ListofMove moves_w;
ListofMove moves_b;
struct Board* children_w;
struct Board* children_b;
int len_w;
int len_b;
struct Board *parent;
double alpha;
double beta;
}Board;
The data in ListofMove and Board* children_w and children_b are added using realloc() function.The main() contains only a single function call for some iterations (here let us say 30)
int main(){
double BW[4] = {5.689821, 39.038832, 26.088224, 60.491498};
double WW[4] = {82.091284, 83.026237, 46.478279, 49.979957};
int outres, in;
for(in = 0 ; in<20; in++){
depth = 0; Nply = 0; count = 0;
outres = gameplay(BW, WW);
}
return 0;
}
All the variables are declared locally in the function gameplay() and are used further by other function call made in gameplay(either by call by value or call by address). Once used all the variables are explicitly deleted using the function del(Board* b) and delm(Move* m).
int gameplay(double blwght[], double whwght[]){
int i, ind;
Board pre;
Board result;
Board current;
Move cur_B, cur_W;
.............
..............
.......
del(&pre);
del(&result);
del(&current);
delm(&cur_B);
delm(&cur_W);
}
The definition for deleting functions
void del(Board* b){
b->beta = 0;
b->alpha = 0;
b->material_w = 0;
b->material_b = 0;
b->mobility_w = 0;
b->mobility_b = 0;
b->center_w = 0;
b->center_b = 0;
b->dev_w = 0;
b->dev_b = 0;
b->value_w = 0;
b->value_b = 0;
b->value = 0;
b->side = 0;
free(&b->value_w);
free(&b->value_b);
free(&b->center_w);
free(&b->center_b);
free(&b->dev_w);
free(&b->dev_b);
free(&b->mobility_w);
free(&b->mobility_b);
free(&b->material_w);
free(&b->material_b);
free(&b->side);
free(&b->len_w);
free(&b->len_b);
free(&b->alpha);
free(&b->beta);
free(b->B);
free(b->devArr);
free(b->parent);
ClearWBoardList(b);
ClearBBoardList(b);
ClearMoveList(&b->moves_w);
ClearMoveList(&b->moves_b);
free(&b->moves_w.array);
free(&b->moves_b.array);
free(&b->moves_w);
free(&b->moves_b);
}
void delm(Move* m){
m->from_x = 0;
m->from_y = 0;
m->to_x = 0;
m->to_y = 0;
m->piece = 0;
free(&m->from_x);
free(&m->from_y);
free(&m->to_x);
free(&m->to_y);
free(&m->piece);
}
The problem is even after the variables are deleted and the function call is executed completely for few iterations the program crashes (after about 14 iteration in my case where system has a 3GB RAM). the problem detected was that before crashing it used about 2GB memory as memory used in one function call is not freed after its execution completes. Can anyone Pls suggest by the memory is retained by variables even after function call returned the value and even when they are explicitly deleted and any solution to solve this problem.

Answer 1

As per the formatting of your question, its too hard to understand the problem, but at first look, it seems, you're passing non-malloced pointers to free() . The result is undefined behaviour.
Please remove
free(&b->value_w);
free(&m->from_x);
and the remaining compile-time allocated variable addresses.
As per the rules, free()-ing is only allowed [rather, required] for dynamically allocated memory. OTOH, Compile-time memory need not to be freed explicitly from your program.
Related Reading: According to Chapter 7.20.3.2, C99 standard, paragraph 2
The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation. If ptr is a null pointer, no action occurs. Otherwise, if the argument does not match a pointer earlier returned by the calloc, malloc, or realloc function, or if the space has been deallocated by a call to free or realloc, the behavior is undefined.
Also, you should refer to the manual page for free().
Other than this, for the leak in your case, you're freeing the b->parent but did not free the nested allocated memory for b->parent. Again, you did not free children_w and children_b at all. They all need to be taken care properly.

Answer 2

In your void del(Board* b)() function, you freeing free(b->parent); which is a linked list but you have two more linked lists struct Board* children_w; and struct Board* children_b; which also needs to be freed properly.
In Linked lists, you have to reach to and delete each node explicitly using free().
take a look at this aspect in your code. It is not clear from code above about these linked lists.

Answer 3

Sourav is correct you don't free the parameters of Board unless u explicitly allocated memory for them, otherwise it result in undesirable effects (you may be freeing random memory and leaving dangling pointers in memory). I suggest u run Valgrind: valgrind --leak-check=yes myprog arg1 arg2 and read http://valgrind.org/docs/manual/quick-start.html for more infomation