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 <string>
#include <utility>
#include "../common/LoadSample.h"
#include "../common/HardwareDescription.h"

/* 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

#include <string>
#include <vector>
#include "../common/LoadSample.h"
#include "../common/HardwareDescription.h"

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; }
        LoadMonitor(const LoadMonitor &) { }

        class StatsProvider
        {
        public:
            StatsProvider(void);
            
            virtual ~StatsProvider(void);
            
            virtual bool QueryData(LoadSample &target) = 0;
            
            virtual bool QueryData(HardwareDescription &target) = 0;
            
        protected:
            bool ReadLines(const char *file_name, std::vector< std::string > &target) const;
            
            template< typename T >
            bool GetFieldValue(const std::string &line, const size_t index, 
                    T &result, const size_t start_at = 0, const char *delim = " \t") const;
            
            std::pair< std::string, size_t > GetFieldName(const std::string &line, 
                    const std::string &end = ":", const size_t start_at = 0) const;
                    
            bool BeginsWith(const std::string &str, const std::string &what) const;
            
            static int GetKernelVersionCode(void);
            
        private:
            StatsProvider(const StatsProvider &) { }
        };
        
        class MemoryStats : public StatsProvider
        {
        public:
            MemoryStats(void);
            
            virtual ~MemoryStats(void);
            
            virtual bool QueryData(LoadSample &target);
            
            virtual bool QueryData(HardwareDescription &target);
        };
        
        class ProcessorStats : public StatsProvider
        {
        public:
            ProcessorStats(void);
            
            virtual ~ProcessorStats(void);
        
            virtual bool QueryData(LoadSample &target);
            
            virtual bool QueryData(HardwareDescription &target);
            
        private:
            
            class OneCpuStats // well, 3rd level nested type, soo coooool ;) and there's more...
            {                 // this should probably be redesigned, but I don't care anymore
            public:
                OneCpuStats(void) { }
                
                OneCpuStats(const std::string &line);
                
                OneCpuStats operator -(const OneCpuStats &b) const;
                
                long long Sum(void) const;
                
                static const size_t CPU_IDLE_COLUMN = 3;
                
                std::vector< long long > stat_cache;
            };
            
            std::vector< OneCpuStats > cpus;
        };
        
        class NetworkStats : public StatsProvider
        {
        public:
            NetworkStats(void);
            
            virtual ~NetworkStats(void);
            
            virtual bool QueryData(LoadSample &target);
            
            virtual bool QueryData(HardwareDescription &target);
            
        private:
            class OneInterfaceStats
            {
            public:
                OneInterfaceStats(const std::string &line);
                
                static const size_t RECV_FIELDS = 8;
                
                static const size_t SEND_FIELDS = 8;
                
                static const size_t INTERFACE_NAME_LENGTH = 16;
                
                char      name[INTERFACE_NAME_LENGTH];
                
                long long recv[RECV_FIELDS];
                
                long long send[SEND_FIELDS];
                
                static const size_t RECV_BYTES = 0;
                
                static const size_t RECV_PACKETS = 1;
                
                static const size_t RECV_ERRORS = 2;
                
                static const size_t RECV_DROPS = 3;
                
                static const size_t RECV_FIFO = 4;
                
                static const size_t RECV_FRAME = 5;
                
                static const size_t RECV_COMPRESSED = 6;
                
                static const size_t RECV_MULTICAST = 7;
            
                static const size_t SEND_BYTES = 0;
                
                static const size_t SEND_PACKETS = 1;
                
                static const size_t SEND_ERRORS = 2;
                
                static const size_t SEND_DROPS = 3;
                
                static const size_t SEND_FIFO = 4;
                
                static const size_t SEND_COLLISION = 5;
                
                static const size_t SEND_CARRIER = 6;
                
                static const size_t SEND_COMPRESSED = 7;
            };
            
            unsigned long long last_time;
            
            std::vector< std::pair< long long, long long > > data;
        };
        
        class DriveStats : public StatsProvider
        {
        public:
            DriveStats(void);
            
            virtual ~DriveStats(void);
            
            virtual bool QueryData(LoadSample &target);
            
            virtual bool QueryData(HardwareDescription &target);
            
        private:
            class OneDriveStats
            {
            public:
                OneDriveStats(const std::string &line);
                
                bool IsDriveDevice(void) const;
                
                bool IsIDE(void) const;
                
                bool IsSCSI(void) const;
                
                int             major;
                
                int             minor;
                
                static const size_t DRIVE_NAME_LENGTH = 16;
                
                char            name[DRIVE_NAME_LENGTH];
                
                static const size_t COLUMN_COUNT = 11;
                
                unsigned long   stat_fields[COLUMN_COUNT];
                
                static const long SECTOR_SIZE = 512;
                
                static const size_t READS_ISSUED_COUNT = 0;
                
                static const size_t READS_MERGED = 1;
                
                static const size_t READ_SECTORS = 2;
                
                static const size_t READ_MILLISECONDS = 3;
                
                static const size_t WRITES_COMPLETED = 4;
                
                static const size_t WRITES_MERGED = 5;
                
                static const size_t WRITE_SECTORS = 6;
                
                static const size_t WRITE_MILLISECONDS = 7;
                
                static const size_t IOS_IN_PROGRESS = 8;
                
                static const size_t IO_MILLISECONDS = 9;
                
                static const size_t IO_WEIGHTED_MILLISECONDS = 10;
            };
            
            int kernel_version;
            
            std::vector< std::pair< long, long > > data;
            
            unsigned long long                     last_time;
        };
        
        class SystemStats : public StatsProvider
        {
        public:
            SystemStats(void);
            
            virtual ~SystemStats(void);
            
            virtual bool QueryData(LoadSample &target);
            
            virtual bool QueryData(HardwareDescription &);
        };
        
        MemoryStats     memory;
        
        ProcessorStats  processor;
        
        NetworkStats    network;
        
        SystemStats     system;
        
        DriveStats      drive;
        
        void LogInfo(const char *message) const;

        void LogError(const char *message) const;

        static unsigned long long GetSampleTime();
        
        unsigned long long GetTSC(void) const
        {
            unsigned long long result = 0;
            
            asm volatile
            (
                "rdtsc"
                : "=A"(result)
            );
            
            return result;
        }
    }; // class LoadMonitor
    
} // namespace lm

#endif

---