JThread_Win32.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 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

************************************************************************/

namespace cmlabs {

#ifdef WIN32

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

JThread::JThread(bool shouldStart, int pri) {
        threadStartTime.setInvalid();
        threadEndTime.setInvalid();
        hThread = NULL;
        publicSemaphore = NULL;
        testSemaphore = NULL;
        priority = pri;

        LARGE_INTEGER PerfFreq;
        QueryPerformanceFrequency(&PerfFreq);
        // usecFreq.QuadPart = PerfFreq.QuadPart / 1000000;
        usecFreq = (double) PerfFreq.QuadPart / 1000000.0;
        
        procLastStat = procStartStat = getCPUUsage(NULL);

        if (shouldStart) start();
}

JThread::~JThread() {
        terminate();
        CloseHandle(hThread);
}



// *****************************************************************
// Thread Main Run
// *****************************************************************

// void JThread::run() {}


// *****************************************************************
// Other Thread
// *****************************************************************

HANDLE JThread::getCallingThreadID() {
//      return hThread;
        HANDLE h = GetCurrentThread();
        return h;
}

// *****************************************************************
// Thread Control
// *****************************************************************

bool JThread::start() {
        if (hThread != NULL) {
                // printf("******* Thread could not be created it already exist!!! *******\n");
                return true;
        }

        DWORD dwThreadId;

        hThread = CreateThread( 
                NULL,                                                                           // no security attributes 
                0,                                                                                      // use default stack size  
                (LPTHREAD_START_ROUTINE) &staticRunThread,      // thread function 
                (void*) this,                                                           // argument to thread function 
                0,                                                                                      // use default creation flags 
                &dwThreadId);                                                           // returns the thread identifier 

        if (hThread == NULL) {
                printf("******* Thread could not be created!!! *******\n");
                return false;
        }

        setPriority(priority);
        addToAllThreadsStats(hThread);
        this->waitThread(0);

        return true;
}

bool JThread::join()
{
        // Sadly, the Linux implementation of join doesn't allow a timeout, so to be compatible
        // we cannot allow the Windows to have this either, although it could (and should) have
        int res = 0;
//      if (ms < 0)
                res = WaitForSingleObject(hThread, INFINITE);
//      else
//              res = WaitForSingleObject(hThread, ms);
        //assert(res == WAIT_OBJECT_0);
        if(res != WAIT_OBJECT_0)
                return false;
        res = CloseHandle(hThread);
        //assert(res);
        if (res==0)
                return false;
        hThread=NULL;
        return true;
}


bool JThread::terminate() {
        bool res = (TerminateThread(hThread, 0) != 0);
        removeFromAllThreadsStats(hThread);
        return res;
}

bool JThread::suspend() {
        return (SuspendThread(hThread) >= 0);
}

bool JThread::resume() {
        DWORD count = 2;

        while (count > 1) {
                count = ResumeThread(hThread);
        }

        if (count == 1) return true;
        else return false;
}

void JThread::yield() {
        Sleep(0);
}



// *****************************************************************
// Thread Questions
// *****************************************************************

bool JThread::isRunning() {
        DWORD code;

        if (!GetExitCodeThread(hThread, &code))
                return false;
        
        return (code == STILL_ACTIVE);
}

ThreadStat JThread::getCPUUsage(HANDLE aThread) {
        ThreadStat newStat;
        JTime t;
        LARGE_INTEGER tStart;

//      return newStat;

//      double tics_per_microsecond = ((double) CLOCKS_PER_SEC /1000000);
//      double tics_per_microsecond = CLOCKS_PER_SEC;

//      newStat.timeLast.tv_sec = 0;
//      newStat.timeLast.tv_usec = (long) ((double) clock() / tics_per_microsecond);

//      newStat.timeLast.tv_sec = t.seconds();
//      newStat.timeLast.tv_usec = t.milliseconds() * 1000;

        FILETIME creationTime;
        FILETIME exitTime;
        FILETIME kernelTime;
        FILETIME userTime;

        if (aThread == NULL) {
                newStat = getAllThreadsStats();

                //if (aThread == NULL) {
                //      HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, true, GetCurrentProcessId());
                //      int ret = GetProcessTimes(hProc, &creationTime, &exitTime, &kernelTime, &userTime);
                //      CloseHandle(hProc);
                //      return newStat;
                //}
        }
        else {
                if (!GetThreadTimes(aThread, &creationTime, &exitTime, &kernelTime, &userTime)) {
                        printf("\n*** ERROR getCPUUsage!!! ***\n");
        //              return newStat;
                }
                else {
                        newStat.userLast = (userTime.dwLowDateTime) / 10;
                        newStat.kernelLast = (kernelTime.dwLowDateTime) / 10;
                //      addToAllThreadsStats(JString((int)aThread), (ThreadStat*)newStat.clone());
                }
        }

        QueryPerformanceCounter(&tStart);
        newStat.timeLast.tv_sec = t.seconds();
//      newStat.timeLast.tv_usec = (long) (tStart.QuadPart / usecFreq.QuadPart);
        newStat.timeLast.tv_usec = (long) (tStart.QuadPart / usecFreq);
//      newStat.timeLast.tv_usec = (long) 0;

        return newStat;
}

bool JThread::isThread() {
        return (hThread == GetCurrentThread);
}

// *****************************************************************
// Thread Priority
// *****************************************************************

int JThread::getPriority() {
        return(priority = convPriorityToInternal(GetThreadPriority(hThread)));
}

bool JThread::setPriority(int pri) {
        priority = pri;
        return (SetThreadPriority(hThread, convPriorityToOS(priority)) != 0);
}

int JThread::convPriorityToOS(int pri) {
        int val;

        if (pri == 0)
                val = THREAD_PRIORITY_NORMAL;
        else if (pri >= 90)
                val = THREAD_PRIORITY_TIME_CRITICAL;
        else if (pri >= 80)
                val = THREAD_PRIORITY_HIGHEST;
        else if (pri >= 70)
                val = THREAD_PRIORITY_ABOVE_NORMAL;
        else if (pri >= 60)
                val = THREAD_PRIORITY_NORMAL;
        else if (pri >= 50)
                val = THREAD_PRIORITY_BELOW_NORMAL;
        else if (pri >= 40)
                val = THREAD_PRIORITY_LOWEST;
        else
                val = THREAD_PRIORITY_IDLE;
        return val;
}

int JThread::convPriorityToInternal(int pri) {
        switch (pri) {
                case THREAD_PRIORITY_TIME_CRITICAL:
                        return 80;
                case THREAD_PRIORITY_HIGHEST:
                        return 60;
                case THREAD_PRIORITY_ABOVE_NORMAL:
                        return 55;
                case THREAD_PRIORITY_NORMAL:
                        return 50;
                case THREAD_PRIORITY_BELOW_NORMAL:
                        return 40;
                case THREAD_PRIORITY_LOWEST:
                        return 30;
                default:
                        return 20;
        }
}


// *****************************************************************
// Signals
// *****************************************************************

bool JThread::signalThread(int signo) {
        return true;
}

bool JThread::waitSignal(int signo) {
        return true;
}


bool JThread::waitThread(long ms) {
        Sleep(ms);
        return true;
}

// *****************************************************************
// OS Info
// *****************************************************************

JString JThread::osGetNameVersion() {
        JString ver = osGetVersion();
        if (ver.length() == 0)
                return osGetName();
        else
                return JString::format("%s, %s", (char*) osGetName(), (char*) ver);
}

JString JThread::osGetName() {
        

        #ifdef _WIN32_WCE

                OSVERSIONINFO osvi;
                BOOL bOsVersionInfoEx;

                // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
                // If that fails, try using the OSVERSIONINFO structure.

                ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
                osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

                if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
                {
                        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
                        if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
                                return "";
                }

                JString osName;

                switch (osvi.dwPlatformId)
                {
                        // Test for the Windows NT product family.
                        case VER_PLATFORM_WIN32_CE:
                                return "Windows CE";
                        default:
                                return "Microsoft Win32";
                }

                return "";
        #else
                OSVERSIONINFOEX osvi;
                BOOL bOsVersionInfoEx;

                // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
                // If that fails, try using the OSVERSIONINFO structure.

                ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
                osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

                if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
                {
                        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
                        if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
                                return "";
                }

                JString osName;

                switch (osvi.dwPlatformId)
                {
                        // Test for the Windows NT product family.
                        case VER_PLATFORM_WIN32_NT:

                                // Test for the specific product family.
                                if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
                                osName += JString("Microsoft Windows Server 2003");

                                if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
                                osName += JString("Microsoft Windows XP");

                                if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
                                osName += JString("Microsoft Windows 2000");

                                if ( osvi.dwMajorVersion <= 4 )
                                osName += JString("Microsoft Windows NT");

                                break;

                        // Test for the Windows 95 product family.
                        case VER_PLATFORM_WIN32_WINDOWS:

                                if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
                                {
                                        osName += JString("Microsoft Windows 95");
                                        if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
                                        osName += JString(" OSR2" );
                                } 

                                if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
                                {
                                        osName += JString("Microsoft Windows 98");
                                        if ( osvi.szCSDVersion[1] == 'A' )
                                                osName += JString(" SE" );
                                } 

                                if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
                                {
                                        osName += JString("Microsoft Windows Millennium Edition");
                                } 
                                break;

                        case VER_PLATFORM_WIN32s:

                                osName += JString("Microsoft Win32s");
                                break;
                }

                return osName;
        #endif
}

JString JThread::osGetVersion() {

        int major = 0;
        int minor = 0;
        int sp = 0;
        int build = 0;
        JString text;

        #ifdef _WIN32_WCE

                OSVERSIONINFO osvi;
                BOOL bOsVersionInfoEx;

                // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
                // If that fails, try using the OSVERSIONINFO structure.

                ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
                osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

                if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
                {
                        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
                        if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
                                return "";
                }

                major = osvi.dwMajorVersion;
                minor = osvi.dwMinorVersion;
                text = (char*)osvi.szCSDVersion;
                // JString osVersion = JString::format("%d.%d %s", osvi.dwMajorVersion, osvi.dwMinorVersion, (char*)osvi.szCSDVersion);
                // return osVersion;
        #else

                OSVERSIONINFOEX osvi;
                BOOL bOsVersionInfoEx;

                // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
                // If that fails, try using the OSVERSIONINFO structure.

                ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
                osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

                if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
                {
                        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
                        if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) 
                                return "";
                }

                switch (osvi.dwPlatformId)
                {
                        // Test for the Windows NT product family.
                        case VER_PLATFORM_WIN32_NT:

                        // Display service pack (if any) and build number.

                                if( osvi.dwMajorVersion == 4 && 
                                        lstrcmpi( osvi.szCSDVersion, "Service Pack 6" ) == 0 )
                                {
                                        HKEY hKey;
                                        LONG lRet;

                                        // Test for SP6 versus SP6a.
                                        lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                                                "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009",
                                                0, KEY_QUERY_VALUE, &hKey );
                                        if( lRet == ERROR_SUCCESS ) {
                                                text = "Service Pack 6a";
                                                build = osvi.dwBuildNumber & 0xFFFF;
                                        }
                                        else // Windows NT 4.0 prior to SP6a
                                        {
                                                major = osvi.dwMajorVersion;
                                                minor = osvi.dwMinorVersion;
                                                build = osvi.dwBuildNumber & 0xFFFF;
                                                text = (char*)osvi.szCSDVersion;
                                                // test += JString::format( "%s (Build %d)",
                                                //      osvi.szCSDVersion,
                                                //      osvi.dwBuildNumber & 0xFFFF);
                                        }

                                        RegCloseKey( hKey );
                                }
                                else // Windows NT 3.51 and earlier or Windows 2000 and later
                                {
                                        major = osvi.dwMajorVersion;
                                        minor = osvi.dwMinorVersion;
                                        build = osvi.dwBuildNumber & 0xFFFF;
                                        text = (char*)osvi.szCSDVersion;
                                        // osVersion += JString::format( "%s (Build %d)",
                                        //      osvi.szCSDVersion,
                                        //      osvi.dwBuildNumber & 0xFFFF);
                                }
                                break;
                }

                if (text.length() > 0)
                        sp = text.splitOnWhiteSpaces().getLast().toInt();

        #endif

        return JString::format("%d.%d.%d.%d %s", major, minor, sp, build, (char*) text);
}

JString JThread::osGetMachineArch() {

        SYSTEM_INFO siSysInfo;
        GetSystemInfo(&siSysInfo); 

        switch(siSysInfo.wProcessorArchitecture) {
                case PROCESSOR_ARCHITECTURE_UNKNOWN:
                        return "i386";
                case PROCESSOR_ARCHITECTURE_INTEL:
                        switch(siSysInfo.wProcessorLevel) {
                                case 3:
                                        return "i386";
                                case 4:
                                        return "i486";
                                case 5:
                                        return "i586";
                                case 6:
                                        return "i686";
                                case 7:
                                        return "i786";
                                case 8:
                                        return "i886";
                                case 9:
                                        return "i986";
                                default:
                                        return "i686";
                        }
                case PROCESSOR_ARCHITECTURE_MIPS:
                        return "mips";
                case PROCESSOR_ARCHITECTURE_ALPHA:
                        return "alpha";
                case PROCESSOR_ARCHITECTURE_PPC:
                        return "ppc";
                case PROCESSOR_ARCHITECTURE_IA64:
                        return "ia64";
                case PROCESSOR_ARCHITECTURE_AMD64:
                        return "amd64";
                default:
                        return "";
        }

        return "";
}

double JThread::osGetTotalMemory() {
        MEMORYSTATUS memstat;
        GlobalMemoryStatus(&memstat);
        return ((double)memstat.dwTotalPhys) / (1024*1024);
}

double JThread::osGetCPUSpeed() {

        HKEY hKey;
        LONG lRet;

        // Test for SP6 versus SP6a.
        JString key = "HARDWARE\\DESCRIPTION\\SYSTEM\\CentralProcessor\\0";
        lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE, key, 0, KEY_QUERY_VALUE, &hKey );
        if( lRet == ERROR_SUCCESS ) {
                DWORD len = sizeof(int);
                BYTE data[sizeof(int)];
                key = "~MHz";
                lRet = RegQueryValueEx(hKey, key, NULL, NULL, data, &len);
                if (lRet == ERROR_SUCCESS) {
                        RegCloseKey(hKey);
                        int speed = (data[3] << 24) + (data[2] << 16) + (data[1] << 8) + (data[0] << 0);
                        return speed;
                }
                else {
                        RegCloseKey(hKey);
                }
        }

        #ifdef WIN32_VSNET_xxx

                LARGE_INTEGER ulFreq, ulTicks, ulValue, ulStartCounter, ulEAX_EDX;

                // Query for high-resolution counter frequency (this is not the CPU frequency):
                if (QueryPerformanceFrequency(&ulFreq)) {
                        // Query current value:
                        QueryPerformanceCounter(&ulTicks);
                        // Calculate end value (one second interval); this is (current + frequency)
                        ulValue.QuadPart = ulTicks.QuadPart + (ulFreq.QuadPart/100);
                        // Read CPU time-stamp counter:
                        __asm RDTSC
                        // And save in ulEAX_EDX:
                        __asm mov ulEAX_EDX.LowPart, EAX
                        __asm mov ulEAX_EDX.HighPart, EDX
                        // Store starting counter value:
                        ulStartCounter.QuadPart = ulEAX_EDX.QuadPart;
                        // Loop for one second (measured with the high-resolution counter):
                        do {
                                QueryPerformanceCounter(&ulTicks);
                        } while (ulTicks.QuadPart <= ulValue.QuadPart);
                        // Now again read CPU time-stamp counter:
                        __asm RDTSC
                        // And save:
                        __asm mov ulEAX_EDX.LowPart, EAX
                        __asm mov ulEAX_EDX.HighPart, EDX
                        // Calculate number of cycles done in interval; 1000000 Hz = 1 MHz
                        return (DWORD) ((ulEAX_EDX.QuadPart - ulStartCounter.QuadPart) / 10000);
                } else {
                        // No high-resolution counter present:
                        LARGE_INTEGER pf;
                        QueryPerformanceFrequency(&pf);
                        double usecFre = (double) pf.QuadPart / 1000000.0;
                        if (usecFre <= 0)
                                return 0;
                        else
                                return usecFre;
                }
        #else
                // No high-resolution counter present:
                LARGE_INTEGER pf;
                QueryPerformanceFrequency(&pf);
                double usecFre = (double) pf.QuadPart / 1000000.0;
                if (usecFre <= 0)
                        return 0;
                else
                        return usecFre;
        #endif
}

int JThread::osGetCPUCount() {
        SYSTEM_INFO siSysInfo;
        GetSystemInfo(&siSysInfo); 
        return siSysInfo.dwNumberOfProcessors;
}

int JThread::procMemUsage() {

        int ret = -1;

        #ifdef _WIN32_WCE
        #else

                HANDLE hProcess = GetCurrentProcess();
                PROCESS_MEMORY_COUNTERS pmc;

                if (hProcess == NULL)
                        return -1;

        /*    hProcess = OpenProcess(  PROCESS_QUERY_INFORMATION |
                                                                                PROCESS_VM_READ,
                                                                                FALSE, processID );
                if (NULL == hProcess)
                        return;
        */
                if ( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) )
                {
                        ret = (int)pmc.WorkingSetSize;
        /*        printf( "\tPageFaultCount: 0x%08X\n", pmc.PageFaultCount );
                        printf( "\tPeakWorkingSetSize: 0x%08X\n", 
                                          pmc.PeakWorkingSetSize );
                        printf( "\tWorkingSetSize: 0x%08X\n", pmc.WorkingSetSize );
                        printf( "\tQuotaPeakPagedPoolUsage: 0x%08X\n", 
                                          pmc.QuotaPeakPagedPoolUsage );
                        printf( "\tQuotaPagedPoolUsage: 0x%08X\n", 
                                          pmc.QuotaPagedPoolUsage );
                        printf( "\tQuotaPeakNonPagedPoolUsage: 0x%08X\n", 
                                          pmc.QuotaPeakNonPagedPoolUsage );
                        printf( "\tQuotaNonPagedPoolUsage: 0x%08X\n", 
                                          pmc.QuotaNonPagedPoolUsage );
                        printf( "\tPagefileUsage: 0x%08X\n", pmc.PagefileUsage ); 
                        printf( "\tPeakPagefileUsage: 0x%08X\n", 
                                          pmc.PeakPagefileUsage );*/
                }
        //    CloseHandle( hProcess );

        #endif

        return ret;
}

JString JThread::getComputerName() {
        #ifdef _WIN32_WCE
                return "PocketPC";
        #else
                DWORD len = MAX_COMPUTERNAME_LENGTH + 1;
                char buffer[MAX_COMPUTERNAME_LENGTH + 1];
                if (GetComputerName(buffer, &len) == 0)
                        return "";
                else
                        return buffer;
        #endif
}

JString JThread::runOSTextCommand(JString cmd) {
        return "";
}


/* Obtain a backtrace and print it to stdout. */
Collection JThread::getProgramTrace() {
        Collection col;
/*      void *array[10];
        size_t size;
        char **strings;
        size_t i;

        size = backtrace(array, 10);
        strings = backtrace_symbols(array, size);

        for (i = 0; i < size; i++)
                col.add(strings[i]);

        free (strings);*/
        return col;
}


// *****************************************************************
// Timers
// *****************************************************************
/*
bool JThread::setTimer(unsigned long ms) {
        return true;
}

unsigned long JThread::getTimer() {
        return 0;
}

bool JThread::endTimer() {
        return true;
}
*/













// *****************************************************************
// Events
// *****************************************************************
/*
void JThread::OnTimer() {
}

void JThread::OnException() {
}

void JThread::OnSignal(int signo) {
}
*/











// The main thread running function
static DWORD WINAPI staticRunThread(LPVOID lpParam) {
        JThread* thr = (JThread*) lpParam;
        thr->threadStartTime = JTime();
        thr->threadEndTime.setInvalid();
        thr->run();
        thr->threadEndTime = JTime();
        return 0;
}


#endif

} // namespace cmlabs

---