DeviceCpu Class Reference

#include <devicecpu.h>

Collaboration diagram for DeviceCpu:

Public Member Functions
	DeviceCpu ()
void	stress ()
double	getLoad ()
uint16_t	getCpuCount ()
uint32_t	getUptime ()
uint16_t	getBootCount ()
double	getVirtualMemoryTotal ()
double	getVirtualMemoryUsed ()
double	getVirtualMemoryFree ()
double	getVirtualMemoryUsedPercent ()
double	getPercentUseForCurrentProcess ()
string	getHostName ()
double	BytesToKiB (double bytes)
double	BytesToMiB (double bytes)
double	BytesToMB (double bytes)
double	getVirtualMemoryUsedKiB ()
double	getVirtualMemoryUsedMiB ()
double	getVirtualMemoryUsedMB ()
double	getMemoryUsed ()
double	getMemoryTotal ()
double	getMemoryUsedKiB ()
double	getMemoryUsedMiB ()
double	getMemoryTotalKiB ()
double	getMemoryTotalMiB ()
double	getMemoryUsedMB ()
double	getMemoryTotalMB ()
pid_t	getPidOf (string processName)
pid_t	getMemoryUsedOf (string processName)
float	getPercentCpuOf (string processName)
float	getPercentMemoryOf (string processName)

Public Attributes
double	percentUseForCurrentProcess
int	numProcessors
string	processName
string	hostName
double	memoryUsed
double	memoryTotal
double	memoryFree
double	memoryBuffers
double	virtualMemoryUsed
double	virtualMemoryTotal
double	virtualMemoryFree
double	load

Constructor & Destructor Documentation

DeviceCpu::DeviceCpu

(

)

{

}

Member Function Documentation

void DeviceCpu::stress

(

)

                      {
    for (int i = 0; i< 40000; i++) {
        double temp = sqrt(i)*i/log(i);
        temp = sqrt(temp);
    }
}

double DeviceCpu::getLoad

(

)

{

#if defined(COSMOS_LINUX_OS)
    load = cpuLinux.getLoad1minAverage();
#endif

#if defined(COSMOS_MAC_OS)
    load = cpuMac.getLoad1minAverage();
#endif

#if defined(COSMOS_WIN_OS)
    load = cpuWin.getLoad() * numProcessors;
#endif

    return load;
}

uint16_t DeviceCpu::getCpuCount

(

)

{
    uint16_t count = 1;
#if defined(COSMOS_LINUX_OS)
    count = cpuLinux.getCpuCount();
#endif
    return count;
}

uint32_t DeviceCpu::getUptime

(

)

{
    uint32_t count = 1;
#if defined(COSMOS_LINUX_OS)
    count = cpuLinux.getUptime();
#endif
    return count;
}

uint16_t DeviceCpu::getBootCount

(

)

{
    uint16_t count = 1;
#if defined(COSMOS_LINUX_OS)
    count = cpuLinux.getBootCount();
#endif
    return count;
}

double DeviceCpu::getVirtualMemoryTotal

(

)

                                       {

#if defined(COSMOS_LINUX_OS)
    virtualMemoryTotal = cpuLinux.getVirtualMemoryTotal();
#endif

#if defined(COSMOS_WIN_OS)
    ;
    virtualMemoryTotal = cpuWin.getVirtualMemoryTotal();
#endif

    return virtualMemoryTotal;
}

double DeviceCpu::getVirtualMemoryUsed

(

)

                                      {

#if defined(COSMOS_LINUX_OS)
    virtualMemoryUsed = cpuLinux.getVirtualMemoryUsed();
#endif

#if defined(COSMOS_WIN_OS)
    virtualMemoryUsed = cpuWin.getVirtualMemoryUsed();
#endif
    return virtualMemoryUsed;

}

double DeviceCpu::getVirtualMemoryFree

(

)

double DeviceCpu::getVirtualMemoryUsedPercent

(

)

                                             {

    double virtualMemoryUsedPercent = getVirtualMemoryUsed() / getVirtualMemoryTotal();

    return virtualMemoryUsedPercent;
}

double DeviceCpu::getPercentUseForCurrentProcess

(

)

                                                {

#if defined(COSMOS_LINUX_OS)
    percentUseForCurrentProcess = cpuLinux.getPercentUseForCurrentProcess();
#endif

#if defined(COSMOS_WIN_OS)
    // TODO
    percentUseForCurrentProcess = 0;
#endif
    return percentUseForCurrentProcess;

}

string DeviceCpu::getHostName

(

)

{
#if defined(COSMOS_LINUX_OS)
    hostName = cpuLinux.getHostName();
#endif

#if defined(COSMOS_MAC_OS)
    hostName = cpuMac.getHostName();
#endif

#if defined(COSMOS_WIN_OS)
    hostName = cpuWin.getHostName();
#endif

    return hostName;
}

double DeviceCpu::BytesToKiB

(

double

bytes

)

{
    return bytes/1024.;
}

double DeviceCpu::BytesToMiB

(

double

bytes

)

{
    return bytes/1024./1024.;
}

double DeviceCpu::BytesToMB

(

double

bytes

)

{
    return bytes/1000./1000.;
}

double DeviceCpu::getVirtualMemoryUsedKiB

(

)

{
    return BytesToKiB(getVirtualMemoryUsed());
}

double DeviceCpu::getVirtualMemoryUsedMiB

(

)

{
    return BytesToMiB(getVirtualMemoryUsed());
}

double DeviceCpu::getVirtualMemoryUsedMB

(

)

{
    return BytesToMB(getVirtualMemoryUsed());
}

double DeviceCpu::getMemoryUsed

(

)

                               {

#if defined(COSMOS_LINUX_OS)
    memoryUsed = cpuLinux.getMemoryUsed();
#endif

#if defined(COSMOS_WIN_OS)
    memoryUsed = cpuWin.getVirtualMemoryUsed();
#endif
    return memoryUsed;
}

double DeviceCpu::getMemoryTotal

(

)

                                {

#if defined(COSMOS_LINUX_OS)
    memoryTotal = cpuLinux.getMemoryTotal();
#endif

#if defined(COSMOS_WIN_OS)
    memoryTotal = cpuWin.getVirtualMemoryTotal();
#endif
    return memoryTotal;
}

double DeviceCpu::getMemoryUsedKiB

(

)

{
    return BytesToKiB(getMemoryUsed());
}

double DeviceCpu::getMemoryUsedMiB

(

)

{
    return BytesToMiB(getMemoryUsed());
}

double DeviceCpu::getMemoryTotalKiB

(

)

{
    return BytesToKiB(getMemoryTotal());
}

double DeviceCpu::getMemoryTotalMiB

(

)

{
    return BytesToMiB(getMemoryTotal());
}

double DeviceCpu::getMemoryUsedMB

(

)

{
    return BytesToMB(getMemoryUsed());
}

double DeviceCpu::getMemoryTotalMB

(

)

{
    return BytesToMB(getMemoryTotal());
}

pid_t DeviceCpu::getPidOf

(

string

processName

)

{
#if defined(COSMOS_LINUX_OS)
    return cpuLinux.getPidOf(processName);
#endif

#if defined(COSMOS_WIN_OS)
    return cpuWin.getPidOf(processName);
#endif

}

pid_t DeviceCpu::getMemoryUsedOf

(

string

processName

)

{
#if defined(COSMOS_LINUX_OS)
    return cpuLinux.getMemoryUsedOf(processName);
#endif

#if defined(COSMOS_WIN_OS)
    //    return cpuWin.getMemoryUsedOf(processName);
#endif

    return -1;
}

float DeviceCpu::getPercentCpuOf

(

string

processName

)

{
#if defined(COSMOS_LINUX_OS)
    return cpuLinux.getPercentCpuOf(processName);
#endif

#if defined(COSMOS_WIN_OS)
    //    return cpuWin.getPercentCpuOf(processName);
#endif
    return 0.;
}

float DeviceCpu::getPercentMemoryOf

(

string

processName

)

{
#if defined(COSMOS_LINUX_OS)
    return cpuLinux.getPercentMemoryOf(processName);
#endif

#if defined(COSMOS_WIN_OS)
    //    return cpuWin.getPercentMemoryOf(processName);
#endif

    return 0.;
}

Member Data Documentation

double DeviceCpu::percentUseForCurrentProcess

int DeviceCpu::numProcessors

string DeviceCpu::processName

string DeviceCpu::hostName

double DeviceCpu::memoryUsed

double DeviceCpu::memoryTotal

double DeviceCpu::memoryFree

double DeviceCpu::memoryBuffers

double DeviceCpu::virtualMemoryUsed

double DeviceCpu::virtualMemoryTotal

double DeviceCpu::virtualMemoryFree

double DeviceCpu::load

---

The documentation for this class was generated from the following files:

• devicecpu.h
• devicecpu.cpp