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

---

ProcessInfo.h

Go to the documentation of this file.

#ifndef Impala_Process_ProcessInfo_h
#define Impala_Process_ProcessInfo_h

#ifdef PSAPI_USED
#include <psapi.h>
#endif

inline bool
PsApiUsed()
{
#ifdef PSAPI_USED
    return true;
#else
    return false;
#endif
}

#include "Basis/ILog.h"

namespace Impala
{
namespace Process
{

//* returns -1 if not supported; -2 if retrieval failed
inline const Int64
GetMemUsage()
{
    Int64 usage = -1;
#ifdef PSAPI_USED
    PROCESS_MEMORY_COUNTERS info;
    bool result = GetProcessMemoryInfo(
        GetCurrentProcess(), &info, sizeof(info));
    usage = result ? info.WorkingSetSize : -2;
#endif
    return usage;
}


/****************************************************************************
 * This class provides support for memory usage tracing;
 * currently for Windows only;
 *
 * possible extensions yet to implement:
 * - option to store state between calls for e.g. table/graph presentation
 *   this would however aggravate the side effect that memory tracing 
 *   itself consumes memory
 * - have instances support "nested" calls of MarkFrom/To
 * - add timing info
 * - add linking of (info contained in) different instances for a more 
 *     complete overview 
 ****************************************************************************/

class ProcessInfo
{

public:

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

    virtual
    ~ProcessInfo()
    {
    }

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

        mMemFrom = GetMemUsage();
        mIsActive = true;
    }

    void
    MarkTo()
    {
        if (!mIsActive)
        {
            ILOG_WARN("Not active (" << mTag << ")");
            return;
        }

        mNrCalls++;
        Int64 memTo = GetMemUsage();
        Int64 memIncr = memTo - mMemFrom;
        if (memIncr != 0)
        {
            if (mMemFrom < memTo)
                mNrCallsIncr++;
            else
                mNrCallsDecr++;
            mNetMemIncr += memIncr;
        }
        mIsActive = false;

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

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

        ILOG_INFO("Memory info (" << mTag << ") : " <<
            "total_calls=" << mNrCalls <<
            ", total_mem_incr=" << mNetMemIncr <<
            ", avg_mem_incr=" << (mNetMemIncr / Int64(mNrCalls)) <<
            ", calls_incr=" << mNrCallsIncr <<
            ", calls_decr=" << mNrCallsDecr);
    }

private:

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

    ILOG_VAR_DECL;

}; //class

ILOG_VAR_INIT(ProcessInfo, Impala.Process);

} // namespace 
} // namespace 

#endif

---