MercuryMemory.cpp

Go to the documentation of this file.

//DO NOT INCLUDE MERCURYMEMORY.H!!!
//If you include MercuryMemory.h, it'll try using the macro'd functions
#include <stdio.h>
#include <stdlib.h>
#include "MercuryThreads.h"

#include <map>
using namespace std;

void MercuryAMalloc( void * ptr, const char * file, const int line );
void MercuryAFree( void * ptr );

//YUCK! Redefinition of class, since we can't #include it.
//Note: all this actually does is provide an instanciaton point for OVERALLFREE.
class MercuryMemoryThrough
{
public:
    MercuryMemoryThrough() {}
    MercuryMemoryThrough( const char * fn, int ln ) { FILENAME=fn; LINENUMBER=ln; }
    template< class G >
    G * operator << ( G * t ) { MercuryAMalloc( (void*)t, FILENAME, LINENUMBER ); return t; }
    template< class G >
    G * operator >> ( G * t ) { MercuryAFree( (void*)t ); return t; }
    int LINENUMBER;
    const char * FILENAME;
} OVERALLFREE;

struct MInfoPair
{
    MInfoPair() { }
    MInfoPair( const char * f, int l, int s ) { file = f; line = l; size = s; }
    const char * file;
    int line;
    int size;
};

bool        bMutexSetUp = false;
COND_MUTEX( MemoryMutex );

//Map for all currently allocated memory
map< void *, MInfoPair > * AllMemoryMap = NULL;

//Remove entry from allocated memory map
void MapFree( void * addy )
{
    LOCK_MUTEX( MemoryMutex );

    if ( AllMemoryMap == NULL )
        AllMemoryMap = new map< void *, MInfoPair >;
    if ( AllMemoryMap->find( addy ) == AllMemoryMap->end() )
        return;
    AllMemoryMap->erase(  AllMemoryMap->find( addy ) );

    UNLOCK_MUTEX( MemoryMutex );
}

//Add new entry for malloc'd data
void MapAlloc( void * addy, const char * file, int line, int size )
{
    if ( !bMutexSetUp )
    {
        bMutexSetUp = true;
        SETUP_MUTEX( MemoryMutex );
    }
    
    LOCK_MUTEX( MemoryMutex );

    if ( AllMemoryMap == NULL )
        AllMemoryMap = new map< void *, MInfoPair >;
    (*AllMemoryMap)[addy] = MInfoPair( file, line, size );

    UNLOCK_MUTEX( MemoryMutex );
}

void ResetAllLeakInfo()
{
    if ( AllMemoryMap )
    {
        //NOTE: "delete" will still use the primary delete.
        //      so we can't actually use that here.
        //      free WILL LEAK LIKE A SIEVE! it's just a token attemp.

        //Why can't we use delete? (Call the destructor so we don't leak)

        //On second thought, let's not do this.  It can actually break because
        // of a circular dependency with delete _if_ the tempalate gets created
        // with MercuryMemory.h.  Besides,we only do this once, at the
        // beginning of the program, we won't miss this leaked ram.
        
        //AllMemoryMap->~map< void *, MInfoPair >();
        //free( AllMemoryMap );
    }
    AllMemoryMap = new map< void *, MInfoPair >;
}

//Just dump out all pending allocated memory
void PrintAllLeakInfo()
{
    for ( map< void *, MInfoPair >::iterator g = AllMemoryMap->begin(); g != AllMemoryMap->end(); g++ )
        printf( "Leak: %p: %s:%d\n", g->first, (g->second).file, (g->second).line );
}

class MemoryWatchForDestroy
{
public:
    ~MemoryWatchForDestroy() { if ( Print ) PrintAllLeakInfo(); }
    bool Print;
};

MemoryWatchForDestroy DPM;

void SetPrintOnEnd( bool POD )
{
    DPM.Print = POD;
}

void * MercuryMalloc( size_t x, const char * file, int line )
{
    void * ret = malloc(x);
    MapAlloc( ret, file, line, x ); 
    return ret;
}

void * MercuryCalloc( size_t x, size_t y, const char * file, const int line )
{
    void * ret = calloc(x,y);
    MapAlloc( ret, file, line, x*y ); 
    return ret;
}

void * MercuryRealloc( void * ptr, size_t x, const char * file, const int line )
{
    void * ret = realloc(ptr,x);
    MapFree( ptr );
    MapAlloc( ret, file, line, x ); 
    return ret;
}

void MercuryAMalloc( void * ptr, const char * file, const int line )
{
    MapAlloc( ptr, file, line, -1 ); 
}

void MercuryFree( void * ptr )
{
    MapFree( ptr ); 
    free( ptr );
}

void MercuryAFree( void * ptr )
{
    MapFree( ptr ); 
}

/* 
 * Copyright (c) 2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by