src/Thread_CPUObserver.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2014 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Thread_CPUObserver.h"
  24 #include "Global.h"
  25
  26 #include <QDir>
  27 #include <QLibrary>
  28
  29 //Windows includes
  30 #define NOMINMAX
  31 #define WIN32_LEAN_AND_MEAN
  32 #include <Windows.h>
  33
  34 ////////////////////////////////////////////////////////////
  35
  36 typedef enum { SystemProcInfo = 8 } SYSTEM_INFO_CLASS;
  37
  38 typedef struct
  39 {
  40         LARGE_INTEGER IdleTime;
  41         LARGE_INTEGER KrnlTime;
  42         LARGE_INTEGER UserTime;
  43         LARGE_INTEGER Reserved[2];
  44         ULONG Reserved2;
  45 }
  46 SYSTEM_PROC_INFO;
  47
  48 typedef BOOL (WINAPI *GetSystemTimesPtr)(LPFILETIME lpIdleTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
  49 typedef LONG (WINAPI *NtQuerySystemInformationPtr)(SYSTEM_INFO_CLASS SystemInformationClass, PVOID SystemInformation, ULONG SystemInformationLength, PULONG ReturnLength);
  50
  51 #define IS_OK(X) (((LONG)(X)) == ((LONG)0x00000000L))
  52
  53 ////////////////////////////////////////////////////////////
  54 // Constructor & Destructor
  55 ////////////////////////////////////////////////////////////
  56
  57 CPUObserverThread::CPUObserverThread(void)
  58 {
  59 }
  60
  61 CPUObserverThread::~CPUObserverThread(void)
  62 {
  63 }
  64
  65 ////////////////////////////////////////////////////////////
  66 // Protected functions
  67 ////////////////////////////////////////////////////////////
  68
  69 void CPUObserverThread::run(void)
  70 {
  71         qDebug("CPU observer started!");
  72
  73         try
  74         {
  75                 observe();
  76         }
  77         catch(const std::exception &error)
  78         {
  79                 fflush(stdout); fflush(stderr);
  80                 fprintf(stderr, "\nGURU MEDITATION !!!\n\nException error:\n%s\n", error.what());
  81                 lamexp_fatal_exit(L"Unhandeled C++ exception error, application will exit!");
  82         }
  83         catch(...)
  84         {
  85                 fflush(stdout); fflush(stderr);
  86                 fprintf(stderr, "\nGURU MEDITATION !!!\n\nUnknown exception error!\n");
  87                 lamexp_fatal_exit(L"Unhandeled C++ exception error, application will exit!");
  88         }
  89
  90         while(m_semaphore.available()) m_semaphore.tryAcquire();
  91 }
  92
  93 ULONGLONG CPUObserverThread::filetime2ulonglong(const void *ftime)
  94 {
  95         ULARGE_INTEGER tmp; tmp.QuadPart = 0UI64;
  96         const FILETIME* fileTime = reinterpret_cast<const FILETIME*>(ftime);
  97         tmp.LowPart = fileTime->dwLowDateTime;
  98         tmp.HighPart = fileTime->dwHighDateTime;
  99         return tmp.QuadPart;
 100 }
 101
 102 void CPUObserverThread::observe(void)
 103 {
 104         QLibrary kernel32("kernel32.dll"), ntdll("ntdll.dll");
 105
 106         ULONG performanceInfoSize = 0;
 107         BYTE *performanceInfoBuffer = NULL;
 108         NtQuerySystemInformationPtr querySysInfo = NULL;
 109         GetSystemTimesPtr getSystemTimes = NULL;
 110
 111         if(kernel32.load())
 112         {
 113                 getSystemTimes = reinterpret_cast<GetSystemTimesPtr>(kernel32.resolve("GetSystemTimes"));
 114         }
 115
 116         if(!getSystemTimes)
 117         {
 118                 qWarning("GetSystemTimes() not found, falling back to NtQueryInformationProcess().");
 119                 if(ntdll.load())
 120                 {
 121                         querySysInfo = reinterpret_cast<NtQuerySystemInformationPtr>(ntdll.resolve("NtQuerySystemInformation"));
 122                         if(querySysInfo)
 123                         {
 124                                 querySysInfo(SystemProcInfo, &performanceInfoBuffer, 0, &performanceInfoSize);
 125                                 if(performanceInfoSize < sizeof(SYSTEM_PROC_INFO)) performanceInfoSize = sizeof(SYSTEM_PROC_INFO);
 126                                 performanceInfoBuffer = new BYTE[performanceInfoSize];
 127                         }
 128                 }
 129         }
 130
 131         if(getSystemTimes || (querySysInfo && performanceInfoBuffer))
 132         {
 133                 bool first = true;
 134                 double previous = -1.0;
 135                 FILETIME sysTime, usrTime, idlTime;
 136                 ULONGLONG sys[2], usr[2], idl[2];
 137
 138                 for(size_t i = 0; i < 2; i++)
 139                 {
 140                         sys[i] = 0; usr[i] = 0; idl[i] = 0;
 141                 }
 142
 143                 forever
 144                 {
 145                         bool ok = false;
 146
 147                         if(getSystemTimes)
 148                         {
 149                                 if(ok = getSystemTimes(&idlTime, &sysTime, &usrTime))
 150                                 {
 151                                         sys[1] = sys[0]; sys[0] = filetime2ulonglong(&sysTime);
 152                                         usr[1] = usr[0]; usr[0] = filetime2ulonglong(&usrTime);
 153                                         idl[1] = idl[0]; idl[0] = filetime2ulonglong(&idlTime);
 154                                 }
 155                         }
 156                         else
 157                         {
 158                                 if(ok = IS_OK(querySysInfo(SystemProcInfo, performanceInfoBuffer, performanceInfoSize, NULL)))
 159                                 {
 160                                         sys[1] = sys[0]; sys[0] = reinterpret_cast<SYSTEM_PROC_INFO*>(performanceInfoBuffer)[0].KrnlTime.QuadPart;
 161                                         usr[1] = usr[0]; usr[0] = reinterpret_cast<SYSTEM_PROC_INFO*>(performanceInfoBuffer)[0].UserTime.QuadPart;
 162                                         idl[1] = idl[0]; idl[0] = reinterpret_cast<SYSTEM_PROC_INFO*>(performanceInfoBuffer)[0].IdleTime.QuadPart;
 163                                 }
 164                         }
 165
 166                         if(ok)
 167                         {
 168                                 if(first)
 169                                 {
 170                                         first = false;
 171                                         emit currentUsageChanged(1.0);
 172                                         msleep(250);
 173                                         continue;
 174                                 }
 175
 176                                 ULONGLONG timeIdl = (idl[0] - idl[1]); //Idle time only
 177                                 ULONGLONG timeSys = (sys[0] - sys[1]); //Kernel mode time (incl. Idle time!)
 178                                 ULONGLONG timeUsr = (usr[0] - usr[1]); //User mode time only
 179
 180                                 ULONGLONG timeSum = timeUsr + timeSys; //Overall CPU time that has elapsed
 181                                 ULONGLONG timeWrk = timeSum - timeIdl; //Time the CPU spent working
 182
 183                                 if(timeSum > 0)
 184                                 {
 185                                         double current = static_cast<double>(timeWrk) / static_cast<double>(timeSum);
 186                                         if(current != previous)
 187                                         {
 188                                                 emit currentUsageChanged(current);
 189                                                 previous = current;
 190                                         }
 191                                 }
 192                         }
 193                         if(m_semaphore.tryAcquire(1, 2000)) break;
 194                 }
 195         }
 196         else
 197         {
 198                 qWarning("NtQueryInformationProcess() not available, giving up!");
 199         }
 200
 201         LAMEXP_DELETE_ARRAY(performanceInfoBuffer);
 202 }
 203
 204 ////////////////////////////////////////////////////////////
 205 // SLOTS
 206 ////////////////////////////////////////////////////////////
 207
 208 /*NONE*/
 209
 210 ////////////////////////////////////////////////////////////
 211 // EVENTS
 212 ////////////////////////////////////////////////////////////
 213
 214 /*NONE*/