#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main( int argc, char *argv[] )
{
  char   **doubleArray;
  int      arrayIndex;
  FILE    *meminfo;
  char    *lineBuffer;
  size_t   lineBufferSize;
  long int freeMemory;
  long int freeMemoryStart;
  int      loopCounter;

  freeMemoryStart = 0;
  loopCounter = 0;
  do
  {
    /* reset our free memory variable */
    freeMemory = 0;

    /* open /proc/meminfo to read system memory information.
       available system memory is reported on a line that starts with
       "MemFree:" -- read lines from the file until we find that particular
       line. We don't care about the units--just the numeric value, which
       drop if there is a memory leak */
    meminfo = fopen( "/proc/meminfo", "r" );
    do
    {
      lineBuffer = NULL;
      getline( &lineBuffer, &lineBufferSize, meminfo );
      if( strstr( lineBuffer, "MemFree:" ) )
        freeMemory = strtol( lineBuffer + strlen( "MemFree:" ), NULL, 10 );
      free( lineBuffer );
    } while( freeMemory == 0 );
    fclose( meminfo );

    /* store a baseline free memory so we don't bring the computer to a
       grinding halt if a memory leak is present */
    if( freeMemoryStart == 0 )
      freeMemoryStart = freeMemory;

    /* Display the free memory info */
    fprintf( stdout, "[%5d] Current free memory: %ld\n", loopCounter, freeMemory );

    /* Do the allocations: one allocation to store pointers to the "rows"
       and then another allocation for each row.
       Reserve sufficient memory that we don't need millions of allocations
       to see a drop (if a leak is present), but not so much that one
       one loop is all the system can afford to handle.
       In short: a 1024x1024 array (or 1 MiB) */

    doubleArray = (char **)malloc( sizeof( char * ) * 1024 );
    for( arrayIndex = 0; arrayIndex < 1024; arrayIndex++ )
      doubleArray[arrayIndex] = (char *)malloc( sizeof( char ) * 1024 );

    /* Only free the "containing" array */
    free( doubleArray );

    loopCounter++;

    /* Break the loop if the system memory drops by 10% of the original
       starting memory (or more). Or, if no leak, break after 10,000 loops */
  } while( ( freeMemoryStart - freeMemory < freeMemoryStart / 10 ) &&
           ( loopCounter < 10000 ) );

  if( loopCounter == 10000 )
    fprintf( stdout, "No memory leak!\n" );
  else
    fprintf( stdout, "Lost memory in loop!\n" );

  return 0;
}

typedef stuct MyTable {
    int n;
    int m;
    int **v;
} MyTable

int *AccessTable (MyTable *m, int i, int j);
MyTable *AllocTable (int n, int m);
void FreeTable (MyTable *t);