PerfData.h

Go to the documentation of this file.

/*  PerfData.h - Helpers for exposing performance counters

    Copyright (C) 2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_PerfData_h
#define OW32_PerfData_h

#include <OW32/OW32libs.h>
#include <OW32/windows.h>
#include <winperf.h>
#include <string>
#include <map>
#include <OW32/tstl.h>
#include <OW32/XHANDLE.h>
#include <OW32/SyncObjects.h>

namespace OW32
{

class OW32_LIB_EXPORT CPerfObject;
class OW32_LIB_EXPORT CPerfCounter;

class OW32_LIB_EXPORT CPerfDataException
{
public:
    CPerfDataException(
        LPCTSTR prefix, 
        DWORD   error = ERROR_INTERNAL_ERROR
    ) :
        m_prefix(prefix),
        m_error(error)
    {
    }

    DWORD getWin32Error() const { return m_error; }

    const std::_tstring &getPrefix() const { return m_prefix; }

    std::_tstring getFormattedError() const;

private:
    std::_tstring   m_prefix;
    DWORD           m_error;
};

#ifdef _MSC_VER
#pragma warning(disable: 4251)
#endif

class OW32_LIB_EXPORT CPerfData
{
public:
    typedef DWORD ObjectId;

    typedef DWORD CounterId;

    typedef DWORD InstanceId;
    
    enum { PERF_COUNTER_STORAGE = sizeof(__int64) };

    CPerfData(LPCWSTR appName);

    ~CPerfData();

    void addObject(CPerfObject *object);

    CPerfObject *getObjectById(ObjectId objectId);

    DWORD collect(LPWSTR values, LPVOID *ppData, LPDWORD pBytes, LPDWORD pcObjectTypes);

    void activate(bool fApplication);

    void deactivate();

    void install(LPCTSTR perfCollectorPath);

    void uninstall();

    InstanceId addInstance(ObjectId objectId, LPCWSTR name,
        ObjectId parentObjectId = 0, InstanceId parentInstanceId = 0)
    {
        return addInstance(objectId, name, PERF_NO_UNIQUE_ID, parentObjectId, parentInstanceId);
    }

    InstanceId addInstance(ObjectId objectId, LONG uniqueID,
        ObjectId parentObjectId = 0, InstanceId parentInstanceId = 0)
    {
        return addInstance(objectId, NULL, uniqueID, parentObjectId, parentInstanceId);
    }

    void removeInstance(ObjectId objectId, InstanceId instanceId);

    __int64 *getCounter64(ObjectId objectId, CounterId counterId, InstanceId instanceId = 0)
    {
        return (__int64 *)getCounter(objectId, counterId, instanceId);
    }

    LONG *getCounter32(ObjectId objectId, CounterId counterId, InstanceId instanceId = 0)
    {
        return (LONG *)getCounter(objectId, counterId, instanceId);
    }

    BYTE *getCounter(ObjectId objectId, CounterId counterId, InstanceId instanceId = 0);

    bool lock(DWORD timeout = INFINITE);

    void unlock();

private:

    InstanceId addInstance(ObjectId objectId, LPCWSTR name, LONG uniqueID,
        ObjectId parentObjectId, InstanceId parentInstanceId);

    void initialiseMMF();

    void computeMMFOffsets();

    void readCounterIndexes();

    void appendCounterTitle(std::wstring &data, LPCWSTR title);

    void appendHelpTitle(std::wstring &data, LPCWSTR title);

    CPerfObject *m_firstObject;

    CPerfObject *m_lastObject;

    DWORD       m_firstHelp;

    DWORD       m_lastHelp;

    DWORD       m_firstCounter;
    
    DWORD       m_lastCounter;

    LPCWSTR     m_appName;

    XHANDLE     m_hPerfData;

    BYTE        *m_pPerfData;

    typedef std::map<CPerfData::ObjectId, CPerfObject*> object_id_map_t;

    object_id_map_t m_objectIdMap;

    CEvent m_lockEvent;

    CEvent m_applicationEvent;

    bool m_fApplication;
};

#ifdef _MSC_VER
#pragma warning(default: 4251)
#endif

#ifdef _MSC_VER
#pragma warning(disable: 4251)
#endif

class OW32_LIB_EXPORT CPerfObject
{
public:
    CPerfObject(
        CPerfData               *perfData,
        CPerfData::ObjectId     objectId, 
        LPCWSTR                 name,
        LPCWSTR                 help,
        DWORD                   detailLevel,
        CPerfData::CounterId    defaultCounterId,
        DWORD                   maxInstances,
        DWORD                   maxInstanceName
    );

    DWORD addCounter(CPerfCounter *counter);

    void setNext(CPerfObject *next);

    void setTitleInfo(DWORD titleIndex, DWORD helpTitleIndex);

    void setPerfInstanceInfo(BYTE *firstInstance, DWORD instanceSize);

    void setPerfType(PERF_OBJECT_TYPE *type);

    bool getFreeInstance(PERF_INSTANCE_DEFINITION **instance, CPerfData::InstanceId *instanceId);

    DWORD getPerfInstanceIndex(CPerfData::InstanceId instanceId);

    BYTE *getCounter(CPerfData::InstanceId instanceId, CPerfData::CounterId counterId);

    void removeInstance(CPerfData::InstanceId instanceId);

    CPerfCounter *getCounterById(CPerfData::CounterId counterId);

    CPerfObject *getNext() const { return m_next; }

    CPerfCounter *getFirstCounter() const { return m_firstCounter; }

    CPerfData::ObjectId getId() const { return m_objectId; }

    LPCWSTR getName() const { return m_name; }

    LPCWSTR getHelp() const { return m_help; }

    DWORD getDetailLevel() const { return m_detailLevel; }

    CPerfData::CounterId getDefaultCounterId() const { return m_defaultCounterId; }

    DWORD getMaxInstances() const { return m_maxInstances; }

    bool singleInstance() const { return m_maxInstances == PERF_NO_INSTANCES; }

    DWORD getMaxInstanceName() const { return m_maxInstanceName; }

    DWORD getTitleIndex() const { return m_titleIndex; }

    DWORD getHelpTitleIndex() const { return m_helpTitleIndex; }

    DWORD collect(CPerfData *perfData, LPVOID *pBuffer, LPDWORD pBytes);

    void setCollect(bool fCollect) { m_fCollect = fCollect; }

    bool getCollect() const { return m_fCollect; }

    void checkChildDependencies(CPerfData *perfData);

    DWORD getCountersWithData() const { return m_countersWithData; }

private:
    CPerfData::ObjectId         m_objectId;

    LPCWSTR                     m_name;

    LPCWSTR                     m_help;

    DWORD                       m_detailLevel;

    CPerfData::CounterId        m_defaultCounterId;

    DWORD                       m_maxInstances;

    DWORD                       m_maxInstanceName;

    CPerfObject                 *m_next;

    CPerfCounter                *m_firstCounter;

    CPerfCounter                *m_lastCounter;

    DWORD                       m_titleIndex;

    DWORD                       m_helpTitleIndex;

    BYTE                        *m_firstInstance;

    DWORD                       m_instanceSize;

    PERF_OBJECT_TYPE            *m_perfObjectType;

    typedef std::map<CPerfData::CounterId, CPerfCounter*> counter_id_map_t;

    /*
     * The counterId->counter map
     */
    counter_id_map_t m_counterIdMap;

    bool                        m_fCollect;

    DWORD                       m_countersWithData;
};

#ifdef _MSC_VER
#pragma warning(default: 4251)
#endif

class OW32_LIB_EXPORT CPerfCounter
{
public:
    CPerfCounter(
        CPerfObject             *object,
        CPerfData::CounterId    counterId,
        LPCWSTR                 name,
        LPCWSTR                 help,
        DWORD                   detailLevel,
        DWORD                   defaultScale,
        DWORD                   type,
        CPerfData::CounterId    counterIdParent = 0
    );
    
    void setNext(CPerfCounter *next);

    void setTitleInfo(DWORD counterTitleIndex, DWORD helpTitleIndex);

    DWORD getIndex() const { return m_index; }

    CPerfData::CounterId getId() const { return m_counterId; }
    
    CPerfCounter *getNext() const { return m_next; }

    LPCWSTR getName() const { return m_name; }

    LPCWSTR getHelp() const { return m_help; }

    DWORD getDetailLevel() const { return m_detailLevel; }

    DWORD getDefaultScale() const { return m_defaultScale; }

    DWORD getType() const { return m_type; }

    CPerfData::CounterId getParentCounter() const { return m_parentCounterId; }

    bool shared() const { return m_parentCounterId != 0; }

private:
    CPerfData::CounterId        m_counterId;

    LPCWSTR                     m_name;

    LPCWSTR                     m_help;

    DWORD                       m_detailLevel;

    DWORD                       m_defaultScale;

    DWORD                       m_type;

    DWORD                       m_index;

    CPerfCounter                *m_next;

    DWORD                       m_counterTitleIndex;

    DWORD                       m_helpTitleIndex;

    CPerfData::CounterId        m_parentCounterId;
};

#define PERF_DECLARE_MAP(appName) \
    extern OW32::CPerfData g_perfData_##appName;

#define PERF_DEFINE_OBJECT(sym, val) \
    const OW32::CPerfData::ObjectId sym = (OW32::CPerfData::ObjectId)val;

#define PERF_DEFINE_COUNTER(sym, val) \
    const OW32::CPerfData::CounterId sym = (OW32::CPerfData::CounterId)val;

#define PERF_MAP_BEGIN(appName) \
    OW32::CPerfData g_perfData_##appName(L#appName); \
    class CPerfMapConstructor \
    { \
    public: \
        CPerfMapConstructor(OW32::CPerfData *perfData); \
    }; \
    \
    CPerfMapConstructor::CPerfMapConstructor(OW32::CPerfData *perfData) \
    {

#define PERF_MAP_BEGIN_OBJECT(objectId, name, help, detailLevel, defaultCounterId, maxInstances, maxInstanceName) \
        { \
            static OW32::CPerfObject currentObject( \
                perfData, objectId, L##name, L##help, detailLevel, defaultCounterId, \
                static_cast<DWORD>(maxInstances), maxInstanceName);

#define PERF_MAP_COUNTER(counterId, name, help, detailLevel, defaultScale, type) \
            { \
                static OW32::CPerfCounter currentCounter( \
                    &currentObject, counterId, L##name, L##help, detailLevel, \
                    static_cast<DWORD>(defaultScale), type); \
            }

#define PERF_MAP_COUNTER_SHARED(counterId, counterIdData, name, help, detailLevel, defaultScale, type) \
            { \
                static OW32::CPerfCounter currentCounter( \
                    &currentObject, counterId, L##name, L##help, detailLevel, defaultScale, type, counterIdData); \
            }

#define PERF_MAP_END_OBJECT() \
        } \


#define PERF_MAP_END(appName) \
    } \
    static CPerfMapConstructor s_constructPerfData(&g_perfData_##appName);

#define PERF_IMPLEMENT_COLLECTOR(appName) \
    extern OW32::CPerfData g_perfData_##appName; \
    extern "C" { \
    DWORD WINAPI OW32_PerfData_##appName##_Open(LPWSTR /*lpDevNames*/) \
    { \
        try \
        { \
            g_perfData_##appName.activate(false); \
            return ERROR_SUCCESS; \
        } \
        catch (const OW32::CPerfDataException &e) \
        { \
            return e.getWin32Error(); \
        } \
    } \
    \
    DWORD WINAPI OW32_PerfData_##appName##_Close() \
    { \
        g_perfData_##appName.deactivate(); \
        return ERROR_SUCCESS; \
    } \
    \
    DWORD WINAPI OW32_PerfData_##appName##_Collect(LPWSTR values, LPVOID *ppData, LPDWORD pBytes, LPDWORD pcObjectTypes) \
    { \
        try \
        { \
            return g_perfData_##appName.collect(values, ppData, pBytes, pcObjectTypes); \
        } \
        catch (const OW32::CPerfDataException &e) \
        { \
            return e.getWin32Error(); \
        } \
    } \
    }

#define PERF_IMPLEMENT_COLLECTOR_REGISTRATION(appName) \
    extern OW32::CPerfData g_perfData_##appName; \
    extern "C" { \
    HINSTANCE ghInstance; \
    \
    BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) \
    { \
        if (dwReason == DLL_PROCESS_ATTACH) \
        { \
            ghInstance = hInstance; \
            DisableThreadLibraryCalls(hInstance); \
        } \
        return TRUE; \
    } \
    \
    STDAPI DllRegisterServer() \
    { \
        TCHAR path[MAX_PATH*2]; \
        if (GetModuleFileName((HMODULE)ghInstance, path, sizeof(path)/sizeof(path[0]))==0) \
            return HRESULT_FROM_WIN32(::GetLastError()); \
        try \
        { \
            g_perfData_##appName.install(path); \
        } \
        catch (const OW32::CPerfDataException &e) \
        { \
            return HRESULT_FROM_WIN32(e.getWin32Error()); \
        } \
        return S_OK; \
    } \
    \
    STDAPI DllUnregisterServer() \
    { \
        try \
        { \
            g_perfData_##appName.uninstall(); \
        } \
        catch (const OW32::CPerfDataException &e) \
        { \
            return HRESULT_FROM_WIN32(e.getWin32Error()); \
        } \
        return S_OK; \
    } \
    }

}; // namespace OW32

#endif // OW32_PerfData_h

---