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

---

MemoryInfo.h

Go to the documentation of this file.

#ifndef Impala_Process_MemoryInfo_h
#define Impala_Process_MemoryInfo_h

#include "Basis/ILog.h"
#include "Basis/String.h"
#include "Basis/NativeTypes.h"
#ifdef WIN32
#include <psapi.h>
#else
#include <unistd.h>
#endif
#include <vector>

namespace Impala
{
namespace Process
{

class MemoryInfo
{
public:

    MemoryInfo(CString tag, int dumpFreq)
    {
        mTag = tag;
        mDumpFreq = dumpFreq;
        mIsActive = false;
        mTotalMemIncr = 0;
        mMemFrom = 0;
        mNrCalls = 0;
        mNrCallsIncr = 0;
        mNrCallsDecr = 0;
    }

    // returns -1 if not supported; -2 if retrieval failed
    static Int64
    GetUsage()
    {
        Int64 usage = -1;
#ifdef WIN32
        PROCESS_MEMORY_COUNTERS info;
        bool result = GetProcessMemoryInfo(GetCurrentProcess(), &info,
                                           sizeof(info));
        if (result)
        {
            usage = info.WorkingSetSize + info.QuotaPagedPoolUsage +
                info.QuotaNonPagedPoolUsage + info.PagefileUsage;
        }
        else
        {
            usage = -2;
        }
#else
        long pageSize = sysconf(_SC_PAGE_SIZE);
        char buf[100];
        sprintf(buf, "/proc/%u/statm", (unsigned) getpid());
        FILE* fp = fopen(buf, "r");
        if (fp)
        {
            unsigned size;
            fscanf(fp, "%u", &size);
            usage = (Int64) size * (Int64) pageSize;
            fclose(fp);
        }
        else
        {
            usage = -2;
        }
#endif
        return usage;
    }

    static String
    GetUsageString()
    {
        Int64 usage = GetUsage();
        if (usage < 0)
            return "no memory info available";
        return Bytes2String(usage);
    }

    static String
    Bytes2String(Int64 nr)
    {
        const char* units[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB"};
        String sign("");
        if (nr < 0)
        {
            sign = "-";
            nr = -nr;
        }
        std::vector<int> vec;
        for (int i=0 ; i<7 ; i++)
        {
            vec.push_back(nr % 1024);
            nr /= 1024;
        }
        if (nr != 0)
            return "Out of range";
        int u = 6;
        while ((vec[u] == 0) && (u > 0))
            u--;
        String val = MakeString(vec[u]);
        if (u > 0)
            val += "." + MakeString(vec[u-1]);
        return sign + val + String(units[u]);
    }

    static void
    PrintUsage(CString message)
    {
        ILOG_INFO("print usage");
        Int64 nr = GetUsage();
        if (nr < 0)
        {
            ILOG_INFO("Could not establish memory usage");
        }
        else
        {
            ILOG_INFO(message << ", usage = " << nr << " = " << Bytes2String(nr));
        }
    }

    void
    MarkFrom()
    {
        if (mIsActive)
        {
            ILOG_WARN("Already active (" << mTag << ")");
            return;
        }
        mMemFrom = GetUsage();
        mIsActive = true;
    }

    Int64
    GetUsageSinceMark()
    {
        if (!mIsActive)
        {
            ILOG_WARN("Not active (" << mTag << ")");
            return -1;
        }
        return GetUsage() - mMemFrom;
    }

    String
    GetUsageSinceMarkString()
    {
        if (!mIsActive)
        {
            ILOG_WARN("Not active (" << mTag << ")");
            return "not active";
        }
        Int64 memIncr = GetUsage() - mMemFrom;
        return Bytes2String(memIncr);
    }

    void
    MarkTo()
    {
        if (!mIsActive)
        {
            ILOG_WARN("Not active (" << mTag << ")");
            return;
        }
        mNrCalls++;
        Int64 memTo = GetUsage();
        Int64 memIncr = memTo - mMemFrom;
        if (memIncr != 0)
        {
            if (mMemFrom < memTo)
                mNrCallsIncr++;
            else
                mNrCallsDecr++;
            mTotalMemIncr += memIncr;
        }
        mIsActive = false;

        if (mDumpFreq > 0)
            if (mNrCalls % mDumpFreq == 0)
                Dump();
    }

    void
    Dump()
    {
        if (mIsActive)
            ILOG_WARN("Still active (" << mTag << ")");

        Int64 avg = mTotalMemIncr / Int64(mNrCalls);
        ILOG_INFO("Dump (" << mTag << ") : " <<
                  "NrCalls=" << mNrCalls <<
                  ", TotalMemIncr=" << mTotalMemIncr <<
                  " (" << Bytes2String(mTotalMemIncr) << ")" <<
                  ", AvgMemIncr=" << avg <<
                  " (" << Bytes2String(avg) << ")" <<
                  ", NrCallsIncr=" << mNrCallsIncr <<
                  ", NrCallsDecr=" << mNrCallsDecr);
    }

private:

    String mTag;
    int    mDumpFreq;
    bool   mIsActive;
    Int64  mTotalMemIncr;
    Int64  mMemFrom;
    int    mNrCalls;
    int    mNrCallsIncr;
    int    mNrCallsDecr;

    ILOG_VAR_DECL;

}; //class

ILOG_VAR_INIT(MemoryInfo, Impala.Process);

} // namespace 
} // namespace 

#endif

---