KSG-Framework/Prozess.cpp

#include "Prozess.h"
#ifdef WIN32
#include <Psapi.h>
#include <tlHelp32.h>
#else
#include <sys/time.h>
#include <fstream>
#include <string>
#endif

using namespace Framework;

// Inhalt der Prozess Klasse aus Prozess.h
// Konstruktor 
Prozess::Prozess()
{
#ifdef WIN32
	pHandle = GetCurrentProcess();
	SYSTEM_INFO sysInfo;
	FILETIME ftime, fsys, fuser;

	GetSystemInfo( &sysInfo );
	numProcessors = sysInfo.dwNumberOfProcessors;

	GetSystemTimeAsFileTime( &ftime );
	memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );

	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
	memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
	memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
#endif
	ref = 1;
}

// nicht constant 
#ifdef WIN32
void Prozess::setProcess( void *pHandle )
{
	this->pHandle = pHandle;
	SYSTEM_INFO sysInfo;
	FILETIME ftime, fsys, fuser;

	GetSystemInfo( &sysInfo );
	numProcessors = sysInfo.dwNumberOfProcessors;

	GetSystemTimeAsFileTime( &ftime );
	memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );

	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
	memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
	memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
}
#endif
// constant
double Prozess::getCPU() const
{
#ifdef WIN32
	FILETIME ftime, fsys, fuser;
	ULARGE_INTEGER now, sys, user;
	double percent;

	GetSystemTimeAsFileTime( &ftime );
	memcpy( &now, &ftime, sizeof( FILETIME ) );

	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
	memcpy( &sys, &fsys, sizeof( FILETIME ) );
	memcpy( &user, &fuser, sizeof( FILETIME ) );
	percent = (double)( ( sys.QuadPart - lastSysCPU.QuadPart ) +
						( user.QuadPart - lastUserCPU.QuadPart ) );
	percent /= ( now.QuadPart - lastCPU.QuadPart );
	percent /= numProcessors;
	memcpy( (void*)&lastCPU, (void*)&now, sizeof( now ) );
	memcpy( (void*)&lastUserCPU, (void*)&user, sizeof( now ) );
	memcpy( (void*)&lastSysCPU, (void*)&sys, sizeof( now ) );

	return percent * 100;
#else
	return 0; //usage.ru_stime usage.ru_utime;
#endif
}

__int64 Prozess::getMem() const
{
#ifdef WIN32
	PROCESS_MEMORY_COUNTERS pMemCountr;
	pMemCountr = PROCESS_MEMORY_COUNTERS();
	if( GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) ) )
		return pMemCountr.WorkingSetSize;
	return 0;
#else
   using std::ios_base;
   using std::ifstream;
   using std::string;

   // 'file' stat seems to give the most reliable results
   //
   ifstream stat_stream("/proc/self/stat",ios_base::in);

   // dummy vars for leading entries in stat that we don't care about
   //
   string pid, comm, state, ppid, pgrp, session, tty_nr;
   string tpgid, flags, minflt, cminflt, majflt, cmajflt;
   string utime, stime, cutime, cstime, priority, nice;
   string O, itrealvalue, starttime;

   // the two fields we want
   //
   unsigned long vsize;
   long rss;

   stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
               >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
               >> utime >> stime >> cutime >> cstime >> priority >> nice
               >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest

   stat_stream.close();

   long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
   return rss * page_size_kb;
#endif
}
#ifdef WIN32
MemoryInfo Prozess::getMemInfo() const
{
	PROCESS_MEMORY_COUNTERS pMemCountr;
	pMemCountr = PROCESS_MEMORY_COUNTERS();
	int result = GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) );
	MemoryInfo ret;
	ZeroMemory( &ret, sizeof( ret ) );
	if( result )
	{
		ret.ausgelagerteFehler = pMemCountr.PageFaultCount;
		ret.ausgelagerterPool = pMemCountr.QuotaPagedPoolUsage;
		ret.ausgelagerterSpeicher = pMemCountr.WorkingSetSize;
		ret.höchsteAusgelagerterSpeicher = pMemCountr.PeakWorkingSetSize;
		ret.höchsterAusgelagerterPool = pMemCountr.QuotaPeakPagedPoolUsage;
		ret.höchsterNichtAusgelagerterPool = pMemCountr.QuotaPeakNonPagedPoolUsage;
		ret.höchsterVorreservierterSpeicher = pMemCountr.PeakPagefileUsage;
		ret.nichtAusgelagerterPool = pMemCountr.QuotaNonPagedPoolUsage;
		ret.vorreservierterSpeicher = pMemCountr.PagefileUsage;
		return ret;
	}
	return ret;
}

int Prozess::getThreadAnzahl() const
{
	int ret = 0;
	DWORD processID = GetCurrentProcessId();
	HANDLE snap = CreateToolhelp32Snapshot( TH32CS_SNAPALL, processID );
	if( snap != INVALID_HANDLE_VALUE )
	{
		PROCESSENTRY32 entry = { 0 };
		entry.dwSize = sizeof( PROCESSENTRY32 );
		if( Process32First( snap, &entry ) )
		{
			do
			{
				if( entry.th32ProcessID == processID )
				{
					ret = entry.cntThreads;
					break;
				}
			}
			while( Process32Next( snap, &entry ) );
		}
		CloseHandle( snap );
	}
	return ret;
}
#endif
Prozess *Prozess::getThis()
{
	++ref;
	return this;
}

Prozess *Prozess::release( )
{
	--ref;
	if( !ref )
		delete this;
	return 0;
}