|| || || || || || || ||

---

ArraySystem.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_ArraySystem_h
#define Impala_Core_Array_ArraySystem_h

#include <cstddef>
#include <map>
#include <iostream>
#include "Basis/ILog.h"

namespace Impala
{
namespace Core
{
namespace Array
{


class ArraySystem
{
public:

    ~ArraySystem()
    {
    }

    static ArraySystem&
    Instance()
    {
        static ArraySystem theSystem;
        return theSystem;
    }

    template<class StorT>
    StorT*
    Allocate(size_t n, StorT)
    {
        size_t oldMem = mMemUse;
        mMemUse += n * sizeof(StorT);
        mNrAlloc++;
        StorT* p = 0;
        try
        {
            p = (StorT*)(operator new(n * sizeof(StorT)));
        }
        catch (std::bad_alloc)
        {
            p = 0;
        }
        if (p == 0)
            ILOG_ERROR("Couldn't allocate " << n << " x " << sizeof(StorT));
        void* vp = p;
        ILOG_DEBUG("Alloc (0x" << vp << ") " << n << " times " << sizeof(StorT)
                   << ", usage from " << oldMem << " to " << mMemUse);
        mMap[p] = SysInf(n, sizeof(StorT), mNrAlloc-1);
        return p;
    }

    template<class StorT>
    void
    Deallocate(StorT* p, size_t n)
    {
        size_t oldMem = mMemUse;
        mMemUse -= n * sizeof(StorT);
        mNrDealloc++;
        void* vp = p;
        operator delete(vp);
        ILOG_DEBUG("Dealloc (0x" << vp << ") " << n << " times " << sizeof(StorT)
                   << ", usage from " << oldMem << " to " << mMemUse);
        mMap.erase(p);
    }

    template<class StorT>
    void
    External(size_t n, StorT* p)
    {
        size_t oldMem = mMemUse;
        mMemUse += n * sizeof(StorT);
        mNrAlloc++;
        ILOG_DEBUG("External (0x" << p << ") " << n << " times " << sizeof(StorT)
                   << ", usage from " << oldMem << " to " << mMemUse);
        mMap[p] = SysInf(n, sizeof(StorT), mNrAlloc-1);
    }

    size_t
    MemoryUsage() const
    {
        return mMemUse;
    }

    int
    NrAlloc() const
    {
        return mNrAlloc;
    }

    int
    NrDealloc() const
    {
        return mNrDealloc;
    }

    void
    MarkMemoryUsage(bool verb = false)
    {
        mMemUseMark = mMemUse;
        mNrAllocMark = mNrAlloc;
        mNrDeallocMark = mNrDealloc;
        if (verb)
        {
            ILOG_INFO("marking memory usage: " << mMemUse 
                      << " nr alloc " << mNrAlloc
                      << " nr dealloc " << mNrDealloc);
            DumpMap();
        }
    }

    size_t
    MemoryUsageSinceMark(bool verb = false) const
    {
        if (verb)
        {
            ILOG_INFO("memory usage since mark: " << MemoryUsageSinceMark()
                      << " nr alloc " << NrAllocMark()
                      << " nr dealloc " << NrDeallocMark()
                      << " alloc usage " << AllocUsageMark());
            ILOG_INFO("     total memory usage: " << mMemUse 
                      << " nr alloc " << mNrAlloc
                      << " nr dealloc " << mNrDealloc
                      << " alloc usage " << mNrAlloc - mNrDealloc);
            DumpMap();
        }
        return mMemUse - mMemUseMark;
    }

    void
    CheckMemoryUsageSinceMark(bool verb = false) const
    {
        size_t memUsed = MemoryUsageSinceMark(verb);
        if (memUsed > 0)
            ILOG_INFO("Memory leak " << memUsed << ", alloc usage "
                      << AllocUsageMark());
    }

    int
    AllocUsageMark() const
    {
        return NrAllocMark() - NrDeallocMark();
    }

    int
    NrAllocMark() const
    {
        return mNrAlloc - mNrAllocMark;
    }

    int
    NrDeallocMark() const
    {
        return mNrDealloc - mNrDeallocMark;
    }

    void
    DumpMap() const
    {
        ILOG_INFO("DumpMap start");
        for (SysInfMap::const_iterator i=mMap.begin() ; i!=mMap.end() ; i++)
            ILOG_INFO(i->second.mAllocNr << " = (0x" << i->first << ") " 
                      << i->second.mN << " elements of " << i->second.mSizeof
                      << " bytes");
        ILOG_INFO("DumpMap end");
    }

private:

    class SysInf
    {
    public:
        SysInf()
        {
        }

        SysInf(size_t n, size_t siz, int al)
        {
            mN = n;
            mSizeof = siz;
            mAllocNr = al;
        }

        size_t mN;
        size_t mSizeof;
        int    mAllocNr;
    };

    typedef std::map<void*,SysInf> SysInfMap;

    SysInfMap mMap;

    ArraySystem()
    {
        mMemUse = 0;
        mMemUseMark = 0;
        mNrAlloc = 0;
        mNrDealloc = 0;
        mNrAllocMark = 0;
        mNrDeallocMark = 0;
    }

    ArraySystem(const ArraySystem&)
    {
    }

    ArraySystem&
    operator=(const ArraySystem&);

    size_t mMemUse;
    size_t mMemUseMark;
    int    mNrAlloc; // includes external
    int    mNrDealloc;
    int    mNrAllocMark;
    int    mNrDeallocMark;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ArraySystem, Impala.Core.Array);

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---