SystemInfo.h

Go to the documentation of this file.

#ifndef SYSTEMINFO_H
#define SYSTEMINFO_H

// An ability to periodically check various information
// and write them to the debug log.

#include <windows.h>

#include <vrecko/Ability.h>
#include <vrecko/World.h>
#include <vrecko/EventDispatcher.h>


namespace base {

#define SI_UNKNOWN_THREAD_NAME  "?"

class SystemInfo: public vrecko::Ability {
public:

    class MessageSIThreadCreated : public vrecko::VreckoMessage {
    public:
        virtual const char* getMessageId() { return "MessageSIThreadCreated"; }

        MessageSIThreadCreated() {};
        MessageSIThreadCreated(DWORD _dwThreadId, const char *_name) { dwThreadId = _dwThreadId; name = _name; }
        virtual bool setValueFromString(const char *valueAsString) { return false; }
        virtual bool isEqualTo(VreckoMessage *otherMsg) { return false; }

        DWORD dwThreadId;
        std::string name;
    };

    SystemInfo();
    ~SystemInfo();

    virtual void preInitialize();
    virtual void postInitialize();

    bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parametersNode);
    //XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *saveXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *);

    virtual void update();

    static bool TryToSendThreadCreatedEvent(DWORD dwThreadId, const char *pName) {
        SystemInfo *siInst = (SystemInfo*)vrecko::world->getAbility("base::SystemInfo");
        if (!siInst)
            siInst = (SystemInfo*)vrecko::world->getAbility("SystemInfo");
        if (!siInst)
            return false;

        return vrecko::world->getEventDispatcherPtr()->reportEvent(siInst, "ThreadCreated", new MessageSIThreadCreated(dwThreadId, pName));
    }
    
protected:
    DWORD dwLastTick;

    bool bWritePeriodicInfo;

    bool initThread(DWORD dwThreadId, std::string &threadName);

    struct SIThreadInfo {
        // statistical information about a thread
    public:
        SIThreadInfo() : bThreadInitialized(false), bTimeInitialized(false), name(SI_UNKNOWN_THREAD_NAME) {};

        std::string name;

        bool bThreadInitialized; // are the thread values initialized (affinity etc.)

        bool bTimeInitialized; // are the time values initialized?
        DWORD dwLastUserTime; // ms
        DWORD dwLastKernelTime; // ms
    };

    struct SIThreadInit {
        // structure used to initialize a thread
    public:
        DWORD dwAffinity;
    };

    std::map<DWORD, SIThreadInfo> threadsInfo; // stats
    
    std::map<std::string, SIThreadInit> threadsInit; // initialization values

    DECLARE_INPUT(ThreadCreated, MessageSIThreadCreated);
};

}


#endif