JThread_WinCE.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

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


#ifdef WIN32

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

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

        LARGE_INTEGER PerfFreq;
        QueryPerformanceFrequency(&PerfFreq);
        usecFreq = (double) PerfFreq.LowPart / 1000000;
        
        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;
        }

        this->waitThread(0);

        return true;
}


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

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;

//      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) {
        //      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;
                }
        }

        newStat.userLast = (userTime.dwLowDateTime) / 10;
        newStat.kernelLast = (kernelTime.dwLowDateTime) / 10;

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

        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 >= 80)
                val = THREAD_PRIORITY_TIME_CRITICAL;
        else if (pri >= 60)
                val = THREAD_PRIORITY_HIGHEST;
        else if (pri >= 55)
                val = THREAD_PRIORITY_ABOVE_NORMAL;
        else if (pri >= 50)
                val = THREAD_PRIORITY_NORMAL;
        else if (pri >= 40) 
                val = THREAD_PRIORITY_BELOW_NORMAL;
        else if (pri >= 30) 
                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() {
        
        
        
        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 "";
}

JString JThread::osGetVersion() {
        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 osVersion = JString::format("%d.%d %s", osvi.dwMajorVersion, osvi.dwMinorVersion, (char*)osvi.szCSDVersion);

        return osVersion;
}

JString JThread::osGetMachineArch() {
        return "";
}

JString JThread::osGetMachineName() {
        return "";
}

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

int JThread::osGetCPUSpeed() {
        return 800;
}

int JThread::osGetCPUCount() {
        return 2;
}

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 = 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() {
        return "PocketPC";
}

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


// *****************************************************************
// 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->run();
        return 0;
}


#endif

---