running out of memory?

[helloworld03]

For a large program that does lots of data crunching (calculations) and lots of mallocs:

I have tried doing the cleanlist function below after I finish using the list created by each malloc.
However, nonetheless, I reach error 2 below ("Could not allocate memory - 2") after about 6 iterations
of an intensive calcuation loop. The address is the empty "oxc000 etc." one that cannot be accessed (i.e.,
malloc cannot allocate memory for the new listnode - I tested this by asserting that the listnode != NULL)).
I think I may be running out of heap memory.

Can you suggest a workaround (e.g., an alternative to malloc) or perhaps something that I should fix?
The code I use for defining, creating and deallocating the list is shown below.

NOTE: I am using ANSI C with MS Visual Studio in a console app

Thanks!



///////////////////////////////CODE:

//List definition

typedef struct list_node_s{
double p;
double pc;
double windowWeight;
struct list_node_s *next;

}list_node_t;


typedef struct{

list_node_t *head;
double size;

}ordered_list_t;


//List Creation

/**************************************************************/
list_node_t *
insert(ordered_list_t * listp, double p, double pc, double windowWeight){

++(listp->size);

listp->head = insert_in_order(listp->head,p,pc, windowWeight);

return (listp->head);
}
/********************************************************/


/************************************************************
not sorted
************************************************************/
list_node_t *
insert_in_order(list_node_t* head, double p, double pc, double windowWeight){


list_node_t * newnode = NULL;
list_node_t * tail = NULL;
list_node_t * headcopy = NULL;
headcopy = head;
tail = headcopy;


/*empty list*/
if(head == NULL){
newnode = (list_node_t *)malloc(sizeof(list_node_t));
//assert(newnode != NULL);
if(newnode == NULL){
printf("\nCOULD NOT ALLOCATE MEMORY - 1\n");
}

newnode->p = p;
newnode->pc = pc;
newnode->windowWeight = windowWeight;
newnode->next = NULL;
head = newnode;
}



else{

newnode = (list_node_t *)malloc(sizeof(list_node_t));
//assert(newnode != NULL);
if(newnode == NULL){
printf("\nCOULD NOT ALLOCATE MEMORY - 2\n"); //I GET THIS MESSAGE!!!!!!!!!!!!
}
newnode->p = p;
newnode->windowWeight = windowWeight;
tail = getTail(headcopy);
pc = (p-(tail->p))/tail->p;
newnode->pc = pc;
newnode->next = NULL;
tail->next = newnode;
tail = tail->next;
}


return (head);

}
/***********************************************************/


//List Cleanup (freeing, etc):
list_node_t * cleanlist(list_node_t * listToClean){

if(listToClean == NULL)
return NULL;

//otherwise:

list_node_t * temp = NULL;


while(listToClean != NULL){

temp = listToClean->next;

free(listToClean);
listToClean = temp;
}

//is this necessary? (SHOULD FREE THESE?)
free(temp);
listToClean = NULL;
temp = NULL;

return listToClean;

}

////////////
How they are used:

I create the linked list as below:
////////
list_node_t * createHistory(FILE * inp){

ordered_list_t myList = {NULL,0};
list_node_t * list;
double p;
char* tempStr= NULL;
//printf("creating list\n");
while(inp != NULL){
//printf("creating list");
//fscanf(inp, "%f", &p);

tempStr = getstring(inp);
if(tempStr != NULL){
p = atof(tempStr);
//printf("p is %f\n",p);
}
else{
break;
}
list = insert(&myList,p,0.0,1.0);
}
//printf("List created and returning\n");
return list;
}

/////////

I use and dealloc the list as below:

list_node_t * list = NULL
list = createHistory(inp);
double answer;
answer = numberCrunchList(list, other stuff);
list = cleanlist(list);
return;

[Paul McKenzie]

Originally posted by helloworld03
Can you suggest a workaround (e.g., an alternative to malloc) or perhaps something that I should fix?Please post a small program that can be compiled, linked and run. This includes a main() stub that demonstrates the problem. Your code could have a bug, it could have corrupted the heap, or you could have actually run out of memory. There is no way to really know this unless someone here can actually run a sample and look at it, and that requires a complete (and small) program.

Regards,

Paul McKenzie