LoadMonitor.h

Go to the documentation of this file.

/*
 *  BEEN: Benchmarking Environment
 *  ==============================
 *
 *  File author: Branislav Repcek
 *
 *  GNU Lesser General Public License Version 2.1
 *  ---------------------------------------------
 *  Copyright (C) 2004-2006 Distributed Systems Research Group,
 *  Faculty of Mathematics and Physics, Charles University in Prague
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser 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 LOAD_MONITOR_INCLUDED
#define LOAD_MONITOR_INCLUDED

#include <fstream>
#include <iostream>
#include <windows.h>
#include <wbemidl.h>
#include <comdef.h>
#include "../common/String.h"
#include "../common/LoadSample.h"
#include "../common/HardwareDescription.h"

/*  Define this if you want RDTSC in GetTSC method to be always preceded with the serializing instuctions.
 *  If RDTSC is not preceded by serializing instruction, it may be executed out-of-order and therefore may
 *  not return exact TSC. This is especially important if you use TSC to measure speed of some very short
 *  (typicaly hand-coded assebly) routines where in rare cases TSC may be read after all code from method
 *  has been executed. In Load Monitor this is not that important since TSC is used only as a simple 
 *  timestamp and it is not required to be exact. CPUID is used as a serializing instruction.
 */
#define SERIALIZE_TSC

/*  Change this to modify how logging behaves. If this is set to 0, logging is disabled. Value of 1 means, that logs are written to
 *  the standard output. Default value is 1.
 */
#define LOG_ENABLED 1


namespace lm
{

    class LoadMonitor
    {
    public:

        LoadMonitor(void);

        ~LoadMonitor(void);

        bool Initialize(void);

        bool Terminate(void);

        LoadSample TakeSample(void);

        HardwareDescription GetHardwareDescription(void);

    private:
    
        LoadMonitor& operator =(LoadMonitor &) { return *this; }

        IWbemServices         *services;

        IWbemRefresher        *refresher;

        class PerformanceCounterEnumCache
        {
        public:
            PerformanceCounterEnumCache(void) :
            is_cached(false)
            {
            }

            virtual ~PerformanceCounterEnumCache(void)
            {
            }

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services) = 0;

            virtual void Release(void) = 0;

            virtual bool QueryData(LoadSample &target) = 0;

            HRESULT GetEnumObjects(IWbemHiPerfEnum *wbem_enum, size_t *object_count, IWbemObjectAccess ***access_objects);

            void ClearEnumObjects(IWbemObjectAccess **access_objects, size_t object_count);

        protected:

            bool is_cached;

            bool Cache(IWbemObjectAccess *access_object)
            {
                if (!access_object)
                {
                    return false;
                }

                if (!is_cached)
                {
                    is_cached = CacheImpl(access_object);
                }

                return is_cached;
            }

            virtual bool CacheImpl(IWbemObjectAccess *access_object) = 0;
        };

        class ProcessorEnumCache : public PerformanceCounterEnumCache
        {
        public:
            ProcessorEnumCache(void);

            virtual ~ProcessorEnumCache(void);

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services);

            virtual void Release(void);

            virtual bool QueryData(LoadSample &target);

            size_t GetCount();

        private:
            IWbemHiPerfEnum   *enum_processor_usage;
            
            long              enum_processor_usage_id;

            long              id_processor_time;

            long              id_processor_name;

        protected:
            virtual bool CacheImpl(IWbemObjectAccess *access_object);
        };

        class NetworkEnumCache : public PerformanceCounterEnumCache
        {
        public:
            NetworkEnumCache(void);

            virtual ~NetworkEnumCache(void);

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services);

            virtual void Release(void);

            virtual bool QueryData(LoadSample &target);

            bool QueryNames(HardwareDescription &target);

        private:
            IWbemHiPerfEnum   *enum_network;

            long              enum_network_id;

            long              id_bytes_received;

            long              id_bytes_sent;

            long              id_name;

        protected:
            virtual bool CacheImpl(IWbemObjectAccess *access_object);
        };

        class MemoryEnumCache : public PerformanceCounterEnumCache
        {
        public:
            MemoryEnumCache(void);

            virtual ~MemoryEnumCache(void);

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services);

            virtual void Release(void);

            virtual bool QueryData(LoadSample &target);

            unsigned long long GetSize();

        private:
            IWbemHiPerfEnum   *enum_memory_usage;

            long              enum_memory_usage_id;

            long              id_available;

        protected:
            virtual bool CacheImpl(IWbemObjectAccess *access_object);
        };

        class SystemEnumCache : public PerformanceCounterEnumCache
        {
        public:
            SystemEnumCache(void);

            virtual ~SystemEnumCache(void);

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services);

            virtual void Release(void);

            virtual bool QueryData(LoadSample &target);

        private:
            IWbemHiPerfEnum   *enum_system;

            long              enum_system_id;

            long              id_processes;

            long              id_processor_queue;

        protected:
            virtual bool CacheImpl(IWbemObjectAccess *access_object);
        };

        class DriveEnumCache : public PerformanceCounterEnumCache
        {
        public:
            DriveEnumCache(void);

            virtual ~DriveEnumCache(void);

            virtual bool AddToRefresher(IWbemConfigureRefresher *configure, IWbemServices *services);

            virtual void Release(void);

            virtual bool QueryData(LoadSample &target);

            bool QueryNames(HardwareDescription &target);

        private:
            IWbemHiPerfEnum   *enum_drives;

            long              enum_drives_id;

            long              id_disk_write_bytes;

            long              id_disk_read_bytes;

            long              id_disk_name;

        protected:
            virtual bool CacheImpl(IWbemObjectAccess *access_object);
        };

        ProcessorEnumCache    processor;

        MemoryEnumCache       memory;

        NetworkEnumCache      network;

        DriveEnumCache        drive;

        SystemEnumCache       system;

        LoadMonitor(const LoadMonitor &) { }

        void LogInfo(const char *message) const;

        void LogError(const char *message) const;

        unsigned long long GetSampleTime() const;
        
        unsigned long long GetTSC(void) const
        {
            __asm
            {
#ifdef SERIALIZE_TSC
                mov     eax, 0
                cpuid
#endif
                rdtsc
            }
        }
    };
}

#endif

---