Function to check memory left from malloc and free?

I just started learning malloc and free, but I'm not sure if I'm using them right. Is there a way to check how much memory is left after a free? I seem to be using up all the heap space pretty quickly in a test program.

> Is there a way to check how much memory is left after a free?
From within the program, or using some kind of "process monitor" ?
Either way, you need to say what you're using if you want a specific answer.

> I seem to be using up all the heap space pretty quickly in a test program.
Post your test program for further comments.

Typically, when you ask for lots of memory the program goes and gets a large block from the OS and then gives it to you as required. But when you free it, it doesn't automatically return to the OS.
So if you're just using a process monitor, you may see the amount of memory go up, but not down.

i use valgrind to check my memory leaks

i would like to check the memory that my program is using through a function. I've attached my code below.

I've never used a debugger, but i'll take a look at valgrind.

Code:

---

/*This hash table resizes the table once the size exceeds # of buckets */

#include <stdio.h>

#define        INITNUMBUCKETS                5
#define        LINKBLOCKSIZE                16
#define RESIZERATIO                1
#define NOMATCH                        -1
#define DEBUG                        1

typedef struct        Link {
  int                Key;
  int                Value;
  struct Link        *Next;
} Link;

typedef struct        {
  Link                **Buckets;
  int                NumBuckets;
  Link                *FreeLinks;
  int                Size;
} HashTable;

int main(int argc, char *argv[]) {
  HashTable        HT;
  FILE                *FP;
  int                NumVals, Key, Value;
  void                Initialize_Hash_Table(HashTable *HT);
  void                Insert(HashTable *HT, int Key, int Value);
  int                Lookup(HashTable *HT, int Key);
  void                Remove(HashTable *HT, int Key);
  void                Print_Hash_Table(HashTable *HT);

  if (argc != 2) {
    printf("usage: %s valuefile\n", argv[0]);
    exit(1);
  }
  FP = fopen(argv[1], "r");
  if (FP == NULL) {
      printf("%s could not be opened; check the filename\n", argv[1]);
      exit(1);
  } else {
      Initialize_Hash_Table(&HT);
      do {
        NumVals = fscanf(FP, "%d %d\n", &Key, &Value);
        if (NumVals == 2) {
            if (Key < 0) {
              printf("Remove(%d)\n", -Key);
              Remove(&HT, -Key);
            } else if (Value == -1) {
              Value = Lookup(&HT, Key);
              printf("%d = Lookup(%d)\n", Value, Key);
            } else {
              printf("Insert(%d, %d)\n", Key, Value);
              Insert(&HT, Key, Value);
            }
            if (DEBUG)
              Print_Hash_Table(&HT);
        }
      } while (NumVals == 2);
      Print_Hash_Table(&HT);
      fclose(FP);
      exit(0);
  }
}

/* Hash: This routine transforms the key into a bucket number. */

int Hash(HashTable *HT, int Key) {
  return Key % HT->NumBuckets;
}

/* Initialize Hash Table: This routine initializes a new hash table
object. Buckets are allocated and cleared; the Freelist is
initialized, and the size is zeroed. */

void Initialize_Hash_Table(HashTable *HT) {
  int                Index;
  void                *malloc(unsigned int);

  HT->NumBuckets = INITNUMBUCKETS;
  HT->Buckets = (Link **) malloc(HT->NumBuckets * sizeof(Link *));
  if (HT->Buckets == NULL) {
      printf("Out of heap memory\n");
      exit(1);
  }
  for (Index = 0; Index < HT->NumBuckets; Index++)
      HT->Buckets[Index] = NULL;
  HT->FreeLinks = NULL;
  HT->Size = 0;
}

/* Make New Links: This routine allocates, initializes, and returns a
new block of link objects. */

Link *Make_New_Links() {
  Link                *NewLinks;
  int                Index;
  void                *malloc(unsigned int);
  void                Print_Next_Link(Link *Next);

  if (DEBUG)
      printf("  making more links\n");
  NewLinks = (Link *) malloc(LINKBLOCKSIZE * sizeof(Link));
  if (NewLinks == NULL) {
      printf("Out of heap memory\n");
      exit(1);
  }
  for (Index = 0; Index < LINKBLOCKSIZE; Index++) {
      NewLinks[Index].Key = -1;
      NewLinks[Index].Value = -1;
      if (Index == LINKBLOCKSIZE - 1)
        NewLinks[Index].Next = NULL;
      else
        NewLinks[Index].Next = &(NewLinks[Index + 1]);
  }
  if (DEBUG) {
      printf("  free list\n");
      Print_Next_Link(NewLinks);
  }
  return NewLinks;
}

/* Print Hash Table: This routine prints the size and contents of a
hash table object. */

void Print_Hash_Table(HashTable *HT) {
    int                Index;
    void        Print_Next_Link(Link *Next);

    if (DEBUG)
      printf("  [HashTable %u, size = %d]\n", HT, HT->Size);
    else
      printf("  [HashTable size = %d]\n", HT->Size);
    for (Index = 0; Index < HT->NumBuckets; Index++) {
      if (DEBUG)
          printf("  bucket %d\n", Index);
      Print_Next_Link(HT->Buckets[Index]);
    }
}

/* Print Next Link: This recursive routine prints the next non-NULL
link entry including its key and value. */

void Print_Next_Link(Link *NextLink) {
  if (NextLink != NULL) {
      if (DEBUG)
        printf("      <%u: %5d, %3d, %u>\n", NextLink, NextLink->Key, NextLink->Value, NextLink->Next);
      else
        printf("      <%5d:%5d>\n", NextLink->Key, NextLink->Value);
      Print_Next_Link(NextLink->Next);
  }
}

/* Insert: This routine inserts a key value pair in the hash table.
If the key already exists, the value is updated. Otherwise a new link
is allocated, initlized, and added to the appropriate bucket list. */

void Insert(HashTable *HT, int Key, int Value) {
  Link                *FoundLink;
  Link                *Find_Key(HashTable *HT, int Key);
  Link                *Make_New_Links();
  int                Hash(HashTable *HT, int Key);
  void                Resize_Hash_Table(HashTable *HT);
 
  FoundLink = Find_Key(HT, Key);
  if (FoundLink == NULL) {
      if (HT->FreeLinks == NULL)
        HT->FreeLinks = Make_New_Links();
      FoundLink = HT->FreeLinks;
      HT->FreeLinks = HT->FreeLinks->Next;
      FoundLink->Key = Key;
      FoundLink->Value = Value;
      FoundLink->Next = HT->Buckets[Hash(HT, Key)];
      HT->Buckets[Hash(HT, Key)] = FoundLink;
      HT->Size += 1;
      if (HT->Size > HT->NumBuckets * RESIZERATIO)
        Resize_Hash_Table(HT);
  } else
      FoundLink->Value = Value;
}

/* Lookup: This routine attempts to locate a key in the hash table. If
the key is located, the value is returned, otherwise NOMATCH is
returned. A interal function performs the search returning the
matching link if the key si found or NULL if it is not found. */

int Lookup(HashTable *HT, int Key) {
  Link                *FoundLink;
  Link                *Find_Key(HashTable *HT, int Key);

  FoundLink = Find_Key(HT, Key);
  if (FoundLink == NULL)
      return -1;
  else
      return FoundLink->Value;
}

/* Remove: This routine removes a key value pair from the hash table.
It pushes the removed link back on the FreeLinks list for later reuse. */

void Remove(HashTable *HT, int Key) {
  int                Index;
  Link                *ThisLink;
  Link                **TrailingPointer;
  int                Hash(HashTable *HT, int Key);
  void                Print_Next_Link(Link *Next);

  Index = Hash(HT, Key);
  ThisLink = HT->Buckets[Index];
  TrailingPointer = &(HT->Buckets[Index]);
  while(ThisLink != NULL && ThisLink->Key != Key) {
      TrailingPointer = &(ThisLink->Next);
      ThisLink = ThisLink->Next; 
  }
  if (ThisLink != NULL) {
      *TrailingPointer = ThisLink->Next;
      ThisLink->Next = HT->FreeLinks;
      HT->FreeLinks = ThisLink;
      HT->Size -= 1;
      if (DEBUG) {
        printf("  free list\n");
        Print_Next_Link(HT->FreeLinks);
      }
  }
}

/* Find_Key: This internal routine performs a hash table lookup,
returning the located link is the key exists in the hash table, or
NULL if it does not. */

Link *Find_Key(HashTable *HT, int Key) {
  Link                *ThisLink;
  int                Index;
  int                Hash(HashTable *HT, int Key);

  Index = Hash(HT, Key);
  ThisLink = HT->Buckets[Index];
  while(ThisLink != NULL && ThisLink->Key != Key)
      ThisLink = ThisLink->Next; 
  return ThisLink;
}



void Resize_Hash_Table(HashTable *HT){
    //Initialize new HT   
        //printf("DOING THE RESIZE HASH TABLE \n"); /////////////////////REMOVE
   
  int                Index;
  void                *malloc(unsigned int);
  HashTable        HT2;
  int ind, num;
  Link *current=NULL, *temp=NULL;
  void insertCustom(HashTable *HT, int Key, int Value);
  void Custom_Print_Hash_Table(HashTable *HT);
 
 
 
    HT2.NumBuckets = 2*(HT->NumBuckets)+1;
  HT2.Buckets = (Link **) malloc(HT->NumBuckets * sizeof(Link *));
  if (HT2.Buckets == NULL) {
      printf("Out of heap memory\n");
      exit(1);
  }
  for (Index = 0; Index < HT2.NumBuckets; Index++)
      HT2.Buckets[Index] = NULL;
  HT2.FreeLinks = NULL;
  HT2.Size = 0;
 
  //end Initialize new HT

 
  //Begin copy old contents to new contents
  ind=1;
  num=0;
  while(num<HT->NumBuckets){
      current=HT->Buckets[num];
      if(current==NULL){
            num++; //If the rest of the bucket is empty, goto next bucket
      }
      else{
            while(current!=NULL){//Else, iterate through the bucket and insert
                insertCustom(&HT2, current->Key, current->Value);

                temp=current->Next;
                free(current);

                current=temp; //Next item in the bucket
               
            }
            num++;
           
      }
                     
  ind++;               
  }

    *HT=HT2;
   
   
    }
   
void insertCustom(HashTable *HT, int Key, int Value) {
          HT->Size =HT->Size + 1;
          if(HT->FreeLinks==0){ //If no free links
              Link *Make_New_Links();
              Link *freed=Make_New_Links();
              HT->FreeLinks=freed->Next;
              freed->Key=Key;
              freed->Value=Value;
              freed->Next=HT->Buckets[Hash(HT, Key)];
              HT->Buckets[Hash(HT, Key)]=freed;
          }
          else{ //If free links exist
              Link *current=HT->FreeLinks;
              current->Key=Key;
              current->Value=Value;
              HT->FreeLinks=current->Next;                     
              current->Next=HT->Buckets[Hash(HT, Key)];   
              HT->Buckets[Hash(HT, Key)]=current;
          }
             
       
}
 

void Custom_Print_Hash_Table(HashTable *HT) { /////////////////////REMOVE
    int                Index;
    void        Print_Next_Link(Link *Next);

      printf("  [HashTable %u, size = %d]\n", HT, HT->Size);

    for (Index = 0; Index < HT->NumBuckets; Index++) {

          printf("  bucket %d\n", Index);
      Print_Next_Link(HT->Buckets[Index]);
    }
}

---

http://cboard.cprogramming.com/showthread.php?t=78420
Closed