DRCEResourceExtractor.hpp

Go to the documentation of this file.

#ifndef DRCE_RESOURCE_EXTRACTOR_HPP
#define DRCE_RESOURCE_EXTRACTOR_HPP

#include <iostream>
#include <utility>
#include <Poco/Exception.h>
#include <Poco/Mutex.h>
#include <Poco/ScopedLock.h>

#include "DRCEResourceUsage.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
class DiskSpaceExtractor
{
public:
  DiskSpaceExtractor(void);
  ~DiskSpaceExtractor(void) {}

  void update(void) throw (Poco::Exception);

  void setDiskSize(size_t diskSize_);

  size_t getDiskSize(void) const {return diskSize;}
  size_t getDiskUsed(void) const {return diskUsed;}
  size_t getDiskFree(void) const {return diskFree;}
  double getDiskUsedPercent(void) const {return diskUsedPercent;}
  double getDiskFreePercent(void) const {return diskFreePercent;}

  static size_t getDiskUsage(const std::vector<pid_t>& ids);
private:
  static size_t getDiskUsageBytes(pid_t pid);
  static size_t getFileSize(const std::string& filename);
private:
  size_t diskSize;
  size_t diskUsed;
  size_t diskFree;
  double diskUsedPercent;
  double diskFreePercent;

  size_t externalDiskSize;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class CpuUsageExtractor
{
  struct cpu_info {
    unsigned long long user;
    unsigned long long system;
    unsigned long long idle;
    unsigned long long iowait;
  } newCpu, oldCpu;
  const unsigned int SLPTIME = 1000000; //200000;
public:
  CpuUsageExtractor(void);
  ~CpuUsageExtractor(void) {}

  void update(void);

  double getCpuUsage(void) const {return cpuUsage;}
  double getIOWait(void) const {return iowait;}

  static double getCpuUsage(const std::vector<pid_t>& ids);
private:
  void updateUsage(void);

  double cpuUsage;
//  unsigned long long lastBusy;
//  unsigned long long lastWork;

  double iowait;
//  unsigned long long lastIOWait;
//  unsigned long long lastSum;

  static void getCpuData(pid_t pid, std::pair<unsigned long int, unsigned long int>& p);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class LoadAverageExtractor
{
  enum {SZ=3};
public:
  LoadAverageExtractor(void);
  ~LoadAverageExtractor(void) {}

  void update(void);

  double getLoadAverage(unsigned int index);
private:
  double loadAverage[SZ]={0.0};
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class MemoryExtractor
{
public:
  struct MemInfo
  {
    MemInfo(void);
    MemInfo(MemInfo&& rhs);
    MemInfo& operator=(MemInfo&& rhs);

    size_t memTotal;
    size_t memFree;
    size_t buffers;
    size_t cached;
    size_t swapTotal;
    size_t swapFree;
    size_t vmallocTotal;
    size_t vmallocUsed;
  };

  MemoryExtractor(void);
  ~MemoryExtractor(void) {}

  void update(void);

  size_t getVramUsed(void) const {return vramUsed;}
  size_t getRramUsed(void) const {return rramUsed;}
  size_t getVramFree(void) const {return vramFree;}
  size_t getRramFree(void) const {return rramFree;}

  double getVramUsedPercent(void) const {return vramUsedPercent;}
  double getRramUsedPercent(void) const {return rramUsedPercent;}
  double getVramFreePercent(void) const {return vramFreePercent;}
  double getRramFreePercent(void) const {return rramFreePercent;}

  size_t getVramTotal(void) const {return vramTotal;}
  size_t getRramTotal(void) const {return rramTotal;}

  void setVramTotal(size_t vramTotal_);
  void setRramTotal(size_t rramTotal_);
private:
  static MemInfo getMemoryInfo(void);
private:
  size_t vramUsed;
  size_t rramUsed;
  size_t vramFree;
  size_t rramFree;
  double vramUsedPercent;
  double rramUsedPercent;
  double vramFreePercent;
  double rramFreePercent;

  size_t vramTotal;
  size_t rramTotal;

  size_t externalVramTotal;
  size_t externalRramTotal;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class AsyncTasks;
class ProcessInfoExtractor
{
public:
  struct FieldsArray
  {
    FieldsArray(void);
    FieldsArray(const FieldsArray& rhs);
    FieldsArray(FieldsArray&& rhs);

    FieldsArray& operator=(const FieldsArray& rhs);
    FieldsArray& operator=(FieldsArray&& rhs);

    void clear(void);

    double cpu;
    size_t vram;
    size_t rram;
    size_t threads;
    size_t disk;
  };

  ProcessInfoExtractor(void) {};
  ~ProcessInfoExtractor(void) {};

  static FieldsArray extract(const AsyncTasks& asyncTask);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class ResourceUsageExtractor
{
public:
  static ResourceUsageExtractor& getInstance(void);
  static void shutdown(void);

  void update(void);
  ResourceUsage extract(void) throw (Poco::Exception);

  CpuUsageExtractor& getCpuUsageExtractor(void);
  DiskSpaceExtractor& getDiskSpaceExtractor(void);
  MemoryExtractor& getMemoryExtractor(void);
  LoadAverageExtractor& getLoadAverageExtractor(void);

  void setMaxThreadsCount(size_t maxThreadsCount_);
  size_t getMaxThreadsCount(void);

  void setMaxProcessesCount(size_t maxProcessesCount_);
  size_t getMaxProcessesCount(void);

  void setMaxDiskSize(size_t maxDiskSize_);
  size_t getMaxDiskSize(void);

  void setMaxVramSize(size_t maxVramSize_);
  size_t getMaxVramSize(void);

  void setMaxRramSize(size_t maxRramSize_);
  size_t getMaxRramSize(void);

protected:
  static ResourceUsageExtractor* pHandler;
  static Poco::Mutex mutex;

  CpuUsageExtractor cpuUsageExtractor;
  DiskSpaceExtractor diskSpaceExtractor;
  MemoryExtractor memoryExtractor;
  LoadAverageExtractor loadAverageExtractor;

  size_t maxThreadsCount;
  size_t maxProcessesCount;
private:
  ResourceUsageExtractor(void);
  ~ResourceUsageExtractor(void) {};
  ResourceUsageExtractor(const ResourceUsageExtractor&);
  ResourceUsageExtractor& operator=(const ResourceUsageExtractor&);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE 

#endif // DRCE_RESOURCE_EXTRACTOR_HPP