Thread: process memory allocation

Well what you describe in a production scenario is Valgrind Home
But coming up with that for a school assignment is impractical.

A very simple memory tracker on the other hand is easy to implement.

Code:

void *myMalloc ( size_t size ) {
  void *result = malloc(size);
  // save result in an internal data structure
  return result;
}
void myFree( void *ptr ) {
  // locate ptr in the internal structure
  free( ptr );
}

At the end of the program, anything remaining in internal store is a memory leak.

Well valgrind is open source, so I suggest you get to it and start studying it thoroughly.

Originally Posted by alexcalin

That's ok, but I really have to do it Valgrind style

What Salem posted is how Valgrind does it.

well you can do it in simpler way i think.
you first take the name of the c programme filename as command line argument and read the whole code into a array using getc().
u assume at first that there is no loops involved in allocating memory.
then you search the names of the memory allocating function names like malloc,calloc...
suppose there are n times occurance of these functions.that means n different memory space is allocated.
now search for the occurance of the "free(" in that array.
if threre are less than n occurance you can tell that all alocated memory arent deallocated.

hope you found my words usefull.
cheers.

Trivial counter example of why that won't work.

Code:

int main ( int argc, char *argv[] ) {
  int n;
  int *p;
  if ( argc <= 1 ) {
    n = 10;
    p = malloc( n * sizeof *p );
  } else {
    n = atoi(argv[1]);
    p = malloc( n * sizeof *p );
  }
  // do stuff
  free( p );
  return 0;
}

Two malloc, one free, no leak.

Originally Posted by Dibyayan Chakra

parse the programme into several section.
check for patterns like condition statement,loops,functions.
and then use counter.

Write a parser for C! That will be taking the LONG, LONG way around. Also it will still not work, because memory allocation is a RUNTIME event:

Code:

int bytes;
unsigned char *buffer;
printf("Input: ");
scanf("%d", &bytes);
buffer = malloc(bytes);

You simply CANNOT do this by analyzing source code. "Process memory allocation" is about a running process, not source code.

Originally Posted by Dibyayan Chakra

then how can it be done?
using the ptrace function might be help full?

Ptrace is open source and written in C, like valgrind. So you could look at those to find out how they work. I don't know enough about executable formats to say more. I would image the executable needs debugging symbols built into it.

You could probably also write a kernel module to do this, then nature of the executable would be irrelevant, so you would not need debugging symbols in it. I'm sure this could tell you what blocks were not de-allocated at the end, but I don't think it could provide all the information a user space tool would.