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

---

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"
#include "Process/MemoryInfo.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)
        {
            String b = Process::MemoryInfo::Bytes2String(n * sizeof(StorT));
            ILOG_ERROR("Couldn't allocate " << n << " x " << sizeof(StorT) <<
                       " (" << b << ")");
            Process::MemoryInfo::PrintUsage("At out of memory");
        }
        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;
    }

    int
    AllocUsage() const
    {
        return mNrAlloc - mNrDealloc;
    }

    void
    MarkMemoryUsage(bool verb = false)
    {
        mMemUseMark = mMemUse;
        mNrAllocMark = mNrAlloc;
        mNrDeallocMark = mNrDealloc;
        if (verb)
        {
            String b = Process::MemoryInfo::Bytes2String(mMemUse);
            ILOG_INFO("Marking memory usage: " << mMemUse << " (" << b << ")"
                      << ", nr alloc: " << mNrAlloc
                      << ", nr dealloc: " << mNrDealloc);
            DumpMap();
        }
    }

    Int64
    MemoryUsageSinceMark(bool verb = false) const
    {
        Int64 memUseSinceMark = mMemUse - mMemUseMark;
        String b1 = Process::MemoryInfo::Bytes2String(mMemUse - mMemUseMark);
        String b2 = Process::MemoryInfo::Bytes2String(mMemUse);
        if (verb)
        {
            ILOG_INFO("Memory usage since last mark: " << memUseSinceMark
                      << " (" << b1 << ")"
                      << ", nr alloc: " << NrAllocMark()
                      << ", nr dealloc: " << NrDeallocMark()
                      << ", alloc usage: " << AllocUsageMark());
            ILOG_INFO("     total memory usage: " << mMemUse
                      << " (" << b2 << ")"
                      << ", nr alloc: " << mNrAlloc
                      << ", nr dealloc: " << mNrDealloc
                      << ", alloc usage: " << mNrAlloc - mNrDealloc);
            DumpMap();
        }
        return memUseSinceMark;
    }

    void
    CheckMemoryUsageSinceMark(bool verb = false) const
    {
        Int64 memUseSinceMark = MemoryUsageSinceMark(verb);
        if (memUseSinceMark > 0)
        {
            String b = Process::MemoryInfo::Bytes2String(memUseSinceMark);
            ILOG_INFO("Memory usage increased since last mark by: " <<
                      memUseSinceMark << " (" << b << "), alloc usage by: " <<
                      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

---