UTMemDebugTracker.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_MEMDEBUG_TRACKER_H_
#define _UT_MEMDEBUG_TRACKER_H_

#if UT_MEMDEBUG


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTLists.h"
#include "UTMutex.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class MemDebugPool_t;


//==================================================================================================
//=== Types and constants
//==================================================================================================
const int c_memdebug_num_stack_frames = 12;
const int c_memdebug_guard_size = 63;       // This makes sizeof(Alloc_t) a multiple of 4 bytes
const byte c_memdebug_guard_val = 0xca;
const int c_memdebug_num_block_sizes = 20;
struct MemDebugBlockSize_t
{
    size_t  max_block_size;
    int     allocate_per_pool;
};


//==================================================================================================
struct Alloc_t
//==================================================================================================
{
    Alloc_t*                    norecycle_newer;
    size_t                      alloc_size;
    size_t                      max_realloc_size;
    void*                       stack[c_memdebug_num_stack_frames];
    byte                        checksum;                           // norecycle_newer to stack
    byte                        head_guard[c_memdebug_guard_size];
};


//==================================================================================================
class MemDebugTracker_t
//==================================================================================================
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
                                                    MemDebugTracker_t();
                                                    ~MemDebugTracker_t();

    void*                                           Malloc(size_t size);
    void                                            Free(void* ptr);
    void*                                           Realloc( void* ptr, size_t size );

    void                                            ReportError(    const char* message,
                                                                    Alloc_t* alloc );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    void                                            SetNoRecycleLimit();
    void*                                           LargeMalloc(size_t size);
    MemDebugPool_t*                                 CreatePool(size_t block_size);
    void                                            DeleteOldestPoolIfStale();
    void                                            CheckNorecycleMemoryUsage();
    void                                            SetCaller(Alloc_t* alloc);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    MemDebugBlockSize_t                             m_pool_size_info[c_memdebug_num_block_sizes];

    Mutex_t                                         m_mutex;
    bool                                            m_already_in_memdebug_tracker;
    bool                                            m_error;

    OwnedBTree_t< MemDebugPool_t, MemDebugPool_t* > m_all_pools_by_addr;
    BTree_t< MemDebugPool_t, size_t >               m_avail_pools_by_size;
    LinkedList_t<MemDebugPool_t>                    m_delete_pools_by_age;
    BTree_t< MemDebugPool_t, size_t >               m_delete_pools_by_size;

    Alloc_t*                                        m_norecycle_oldest;
    Alloc_t*                                        m_norecycle_newest;
    size_t                                          m_norecycle_current_bytes;
    uint32                                          m_norecycle_max_kb;
    size_t                                          m_allocations_until_next_system_memcheck;
};


//==================================================================================================
class MemDebugPool_t
//==================================================================================================
:   public BTreeNode_t< MemDebugPool_t, MemDebugPool_t* >,
    public BTreeNode_t< MemDebugPool_t, size_t >,
    public LinkedListNode_t<MemDebugPool_t>
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    void*                   operator new( size_t size, int capacity, size_t block_size );
                            MemDebugPool_t( int capacity, size_t block_size );
                            ~MemDebugPool_t();
    void                    operator delete(void* malloced_block);

    inline size_t           BlockSize() const;
    inline int              Capacity() const;
    inline bool             AllBlocksAllocated() const;
    inline bool             AllBlocksAvailable() const;
    bool                    Contains(byte* block) const;
    inline void             InitDeleteCounter(int count);
    inline bool             DecrementDeleteCounter();

    Alloc_t*                Allocate();
    void                    Release(Alloc_t* block);

    inline int              Compare(MemDebugPool_t* address) const;
    inline                  operator MemDebugPool_t*() const;
    inline int              Compare(size_t block_size) const;
    inline                  operator size_t() const;

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    size_t                  m_block_size;
    int                     m_capacity;
    uint32                  m_avail_bitmap;
    uint32                  m_avail_bitmap_when_all_avail;
    int                     m_delete_counter;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations
//===
//==================================================================================================
//==================================================================================================
inline size_t
MemDebugPool_t::BlockSize() const
{
    return m_block_size;
}


inline int
MemDebugPool_t::Capacity() const
{
    return m_capacity;
}


inline bool
MemDebugPool_t::AllBlocksAllocated() const
{
    return (m_avail_bitmap == 0);
}


inline bool
MemDebugPool_t::AllBlocksAvailable() const
{
    return (m_avail_bitmap == m_avail_bitmap_when_all_avail);
}


inline void
MemDebugPool_t::InitDeleteCounter(int count)
{
    m_delete_counter = count;
}


inline bool
MemDebugPool_t::DecrementDeleteCounter()
{
    assert(m_delete_counter > 0);
    m_delete_counter--;
    return (m_delete_counter == 0);
}


inline int
MemDebugPool_t::Compare(MemDebugPool_t* address) const
{
    // If this comes before other, Compare should return a negative number
    if(this < address)
        return -1;
    else if(this == address)
        return 0;
    return 1;
}


inline
MemDebugPool_t::operator MemDebugPool_t*() const
{
    return const_cast<MemDebugPool_t*>(this);
}


inline int
MemDebugPool_t::Compare(size_t block_size) const
{
    // If this comes before other, Compare should return a negative number
    if(m_block_size < block_size)
        return -1;
    else if(m_block_size == block_size)
        return 0;
    return 1;
}


inline
MemDebugPool_t::operator size_t() const
{
    return m_block_size;
}


#endif // UT_MEMDEBUG

#endif // _UT_MEMDEBUG_TRACKER_H_