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

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


#ifndef WIN32

#ifdef Darwin
#include <mach/thread_act.h>
#include <mach/thread_info.h>
#include <mach/mach_init.h>
#include <mach/task.h>
#include <mach/semaphore.h>
#endif

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Global information
//////////////////////////////////////////////////////////////////////

int NumberOfCPUs = 0;
double OSMemory = 0;
double CPUSpeed = 0;
char* CPUArch = NULL;
char* OSVersion = NULL;
char* OSName = NULL;

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

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

        procLastStat = procStartStat = getCPUUsage(NULL);

        if (shouldStart) start();
}

JThread::~JThread() {
        linuxThreadHasFinished = true;
        terminate();
}



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

// void JThread::run() {}


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

HANDLE JThread::getCallingThreadID() {
        pthread_t* p = new pthread_t;
        *p = pthread_self();
        return p;
}


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


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

    pthread_attr_t attr;
        pthread_attr_init(&attr); /* initialize attr with default attributes */
        // pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
        pthread_attr_setschedpolicy(&attr, SCHED_RR);
        pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
        // pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);


        int res;
        hThread = new pthread_t;
        if ((res=pthread_create(hThread, &attr, staticRunThread, (void*) this)) != 0) {
                if (res == EAGAIN) {
                        if (DEBUGLEVEL(DEBUG))
                                printf("******* Thread could not be created, too many exist!!! *******\n");
                }
                else if (res == EFAULT) {
                        if (DEBUGLEVEL(DEBUG))
                                printf("******* Thread could not be created, thread or attr is an invalid pointer.!!! *******\n");
                }
                else if (res == EINVAL) {
                        if (DEBUGLEVEL(DEBUG))
                                printf("******* Thread could not be created, attr is not an initialized thread attribute object!!! *******\n");
                }
                else {
                        if (DEBUGLEVEL(DEBUG))
                                printf("******* Thread could not be created, error code given: %d!!! *******\n", res);
                }
                return false;
        }
        int oldstate;
//      pthread_detach(*hThread);
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
//      pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldstate);
//      printf("Thread create   %d   %d\n", *hThread, hThread);
        setPriority(priority);
        addToAllThreadsStats(hThread);
        this->waitThread(0);
        return true;
}

bool JThread::join()
{
        int res = 0;
        res = pthread_join(*hThread, 0);
        //assert(res == 0);
        if (res!=0)
                return false;
        return true;
}


bool JThread::terminate() {
        if (!hThread) {
        //      printf("Destructing empty thread...\n");
                return true;
        }
//      printf("[Terminating Thread %d]\n", (int)hThread);

        //      try {
                pthread_cancel(*hThread);
                //      } catch(...) {
          //            printf("[FAILED: Terminating Thread %d]\n", (int)hThread);
                //      }
//      printf("[Terminated Thread %d]\n", (int)hThread);

        // pthread_cancel() not completely implemented in Darwin yet,
        // meaning that the thread might not cancel if it is stuck.
        // Therefore, we do not join, until Darwin is better...
//      #ifndef Darwin
          if (pthread_join(*hThread, NULL) != 0)
                return false;
//      #endif
        delete(hThread);
        removeFromAllThreadsStats(hThread);
        //      printf("hThread deleted...\n");
        hThread = NULL;
        return true;
}

bool JThread::suspend() {

        #ifdef Darwin
                return false;
        #else
                return (pthread_kill(*hThread, SIGSTOP) == 0);
        #endif
}

bool JThread::resume() {

        #ifdef Darwin
                return false;
        #else
                return (pthread_kill(*hThread, SIGCONT) == 0);
        #endif
}

void JThread::yield() {
        pthread_testcancel();
}



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

bool JThread::isRunning() {

        return (!linuxThreadHasFinished);

//      return (hThread != 0) ? true : false;
}


ThreadStat JThread::getCPUUsage(HANDLE aThread) {

  ThreadStat newStat;

  /*
#ifdef Darwin

  kern_return_t res;
  thread_basic_info info;
  mach_msg_type_number_t len = THREAD_BASIC_INFO_COUNT;
  thread_act_t th = mach_thread_self();

  res = thread_info(th, THREAD_BASIC_INFO, (integer_t*)&info, &len);

  if (res != KERN_SUCCESS)
    printf("thread_info returned error... %d\n", res);
  else {
    printf("[%d] user: %d  kernel: %d  cpu: %d  \n", (int) this, info.user_time, info.system_time, info.cpu_usage);
  }

#endif
  */

  // #else
        struct tms tm;
        struct rusage us;

        struct timezone tz;

        if (aThread == NULL) {
                newStat = getAllThreadsStats();
        }
        else {
                getrusage(RUSAGE_SELF, &us);
                newStat.userLast = (us.ru_utime.tv_sec * 1000000) + us.ru_utime.tv_usec;
                newStat.kernelLast = (us.ru_stime.tv_sec * 1000000) + us.ru_stime.tv_usec;
                // addToAllThreadsStats(JString((int)aThread), (ThreadStat*)newStat.clone());
        }

        gettimeofday(&newStat.timeLast, &tz);

/*      double clicksPerMic = ((double)sysconf(_SC_CLK_TCK)) / 1000000;
//      printf("Clock: %ld   %f\n", sysconf(_SC_CLK_TCK), clicksPerMic);
        struct tms buf;
        times(&buf);

        newStat.userLast = (__int64)((double)buf.tms_utime / clicksPerMic);
        newStat.kernelLast = (__int64)((double)buf.tms_stime / clicksPerMic);
*/

//      printf("Linux Stat: %d.%d  %d.%d\n",
//              (int) us.ru_utime.tv_sec, (int) us.ru_utime.tv_usec,
//              (int) us.ru_stime.tv_sec, (int) us.ru_stime.tv_usec);

        return newStat;
        // #endif
}

bool JThread::isThread() {
        return (*hThread == pthread_self()) ? true : false;
}



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

int JThread::getPriority() {

        if (hThread == NULL)
                return 0;
        
        #ifdef Darwin
                return 0;
        #else
                struct sched_param sched;
                int policy;

                policy = sched_getscheduler(0);
                if(policy < 0)
                        return false;
                
                if (pthread_getschedparam(*hThread, &policy, &sched) != 0)
                        return false;

                priority = sched.sched_priority;

                return priority;
        #endif
        
}

bool JThread::setPriority(int pri) {

        if (hThread == NULL) {
                printf("SetPriority: No thread\n");
                return false;
        }

        //#ifdef Darwin
        //      return false;
                //#else

        //      if (pthread_getschedparam(*hThread, &policy, &sched) != 0) {
        //              printf("SetPriority: Couldn't get thread parameters\n");
        //              return false;
        //      }

        //      printf("SetPriority: [%d] Thread parameters: %d\n", policy, sched.sched_priority);

        //      policy = sched_getscheduler(0);
        //      if(policy < 0) {
        //              printf("SetPriority: No policy\n");
        //              return false;
        //      }

        int policy;
        struct sched_param sched;
        memset(&sched, 0, sizeof(struct sched_param));

        policy = SCHED_FIFO;
        // policy = SCHED_RR;
        sched.sched_priority = convPriorityToOS(pri);

        int res = pthread_setschedparam(*hThread, policy, &sched);
        if (res != 0) {
                if (res == EINVAL) {
                        // printf("SetPriority: Invalid scheduling policy %d\n", policy);
                }
                else if (res == ENOTSUP) {
                        // printf("SetPriority: Invalid value for scheduling parameters %d\n", sched.sched_priority);
                }
                else if (res == EPERM) {
                        // printf("SetPriority: User no permission %d,%d\n", policy, sched.sched_priority);
                }
                else if (res == ESRCH) {
                        // printf("SetPriority: Non-existent thread %d (%x)\n", hThread, hThread);
                }
                return false;
        }

        return true;
        //#endif
        
}

int JThread::convPriorityToOS(int pri) {
        int val;
        if (pri == 0)
                val = 40;
        else if (pri >= 90)
                val = 60;
        else if (pri >= 80)
                val = 55;
        else if (pri >= 70)
                val = 40;
        else if (pri >= 60)
                val = 35;
        else if (pri >= 50)
                val = 30;
        else if (pri >= 40)
                val = 25;
        else if (pri >= 30)
                val = 20;
        else if (pri >= 20)
                val = 15;
        else if (pri >= 10)
                val = 10;
        else
                val = 5;
        return val;
}

int JThread::convPriorityToInternal(int pri) {
        return pri;
}


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

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

bool JThread::waitThread(long ms) {
        usleep(ms * 1000);
        return true;
}




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

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

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




// *****************************************************************
// Unit Testing
// *****************************************************************
/*
bool JThread::unitTest() {
        return true;
}
*/



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

/*

Linux uname:
        -a, --all
                        print all information, in the following order:

        -s, --kernel-name
                        print the kernel name

        -n, --nodename
                        print the network node hostname

        -r, --kernel-release
                        print the kernel release

        -v, --kernel-version
                        print the kernel version

        -m, --machine
                        print the machine hardware name

        -p, --processor
                        print the processor type

        -i, --hardware-platform
                        print the hardware platform

        -o, --operating-system
                        print the operating system

Darwin uname:
        -a      Behave as though all of the options -mnrsv were specified.

        -m      print the machine hardware name.

        -n      print the nodename (the nodename may be a name that the system is
                        known by to a communications network).

        -p      print the generic processor type.

        -s      print the operating system name.

        -r      print the operating system release.

        -v      print the operating system version.
*/

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() {

        if (OSName != NULL)
                return OSName;

        #ifdef Darwin
                JString osName = runOSTextCommand("uname -s");
        #else
                JString osName = runOSTextCommand("uname -s");
        #endif // Darwin

        if (osName.length() == 0)
                osName = "Unknown";

        int len;
        OSName = osName.getCharCopy(len);
        return OSName;
}

JString JThread::osGetVersion() {

        if (OSVersion != NULL)
                return OSVersion;

        #ifdef Darwin
                JString osVersion = runOSTextCommand("uname -r");
        #else
                JString osVersion = runOSTextCommand("uname -r");
        #endif // Darwin

        if (osVersion.length() == 0)
                osVersion = "0";

        int len;
        OSVersion = osVersion.getCharCopy(len);
        return OSVersion;
}

JString JThread::osGetMachineArch() {

        if (CPUArch != NULL)
                return CPUArch;

        #ifdef Darwin
                JString cpuArch = runOSTextCommand("uname -p");
        #else
                JString cpuArch = runOSTextCommand("uname -p");
        #endif // Darwin

        if (cpuArch.length() == 0)
                cpuArch = "Unknown";
        
        int len;
        CPUArch = cpuArch.getCharCopy(len);
        return CPUArch;
}


double JThread::osGetTotalMemory() {

        if (OSMemory > 0)
                return OSMemory;

        #ifdef Darwin
                JString str = runOSTextCommand("sysctl hw.memsize");
                str = str.split(":").getLast();
                OSMemory = str.toDouble()/(1024*1024);
        #else
                JString str = runOSTextCommand("free | grep Mem | awk '{printf (\"%d\", $2/1000)}'");
                OSMemory = str.toDouble();
        #endif // Darwin
        return OSMemory;
}

double JThread::osGetCPUSpeed() {

        if (CPUSpeed > 0)
                return CPUSpeed;

        #ifdef Darwin
                JString str = runOSTextCommand("sysctl hw.cpufrequency");
                str = str.split(":").getLast();
                CPUSpeed = str.toDouble()/1000000;
        #else
                JString str = runOSTextCommand("cat /proc/cpuinfo | grep 'cpu MHz' | head -1 | sed -e 's/^.*: //'");
                CPUSpeed = str.toDouble();
        #endif // Darwin
        return CPUSpeed;
}

int JThread::osGetCPUCount() {

        if (NumberOfCPUs > 0)
                return NumberOfCPUs;

        #ifdef Darwin
                JString str = runOSTextCommand("sysctl hw.ncpu");
                str = str.split(":").getLast();
        #else
                JString str = runOSTextCommand("cat /proc/cpuinfo | grep processor | wc -l");
        #endif // Darwin

        NumberOfCPUs = str.toInt();
        if (NumberOfCPUs <= 0)
                NumberOfCPUs = 1;
        return NumberOfCPUs;
}

JString JThread::runOSTextCommand(JString cmd) {

        fflush(stdin);
        fflush(stdout);
        FILE* runfile = popen(cmd, "r");
        if (runfile == NULL) return "";

        char *buffer = new char[10000];
        int res = fread(buffer, 1, 10000, runfile);
        if (res <= 0) {
                delete [] buffer;
                pclose(runfile);
                return "";
        }
        for (int n=0; n<res; n++)
                if (buffer[n] < 32)
                        buffer[n] = 0;
        buffer[res] = 0;

        JString str = buffer;
        delete [] buffer;
        pclose(runfile);
        return str;
}

int JThread::procMemUsage() {

        #ifdef Darwin
                JString str = runOSTextCommand(JString::format("ps h -o rsz -p %d | tail -n 1", (int) getpid()));
        #else
                JString str = runOSTextCommand(JString::format("ps h -o rsz %d | tail -n 1", (int) getpid()));
        //      JString str = runOSTextCommand(JString::format("ps h -o sz %d | tail -n 1", (int) getpid()));
        #endif // Darwin

        int c = str.toInt() * 1024;
        if (c <= 0)
                return 1;
        return c;

/*      fflush(stdin);
        fflush(stdout);
        #ifdef Darwin
                JString str = JString::format("top -l1 2> /dev/null | grep \" %d \"| tail -n 1", (int) getpid());
        #else
                JString str = JString::format("top -b -n 1 -p %d -c -C 2> /dev/null | tail -n 1", (int) getpid());
        #endif // Darwin

        FILE* runfile = popen(str, "r");

        if (runfile == NULL)
                return -1;

        char *buffer = new char[10000];
        int res = fread(buffer, 1, 10000, runfile);

        if (res <= 0) {
                delete [] buffer;
                pclose(runfile);
                return -2;
        }

        str = buffer;
        delete [] buffer;
        pclose(runfile);

        Collection oc = str.splitOnWhiteSpaces();

        int memuse = 0;

        #ifdef Darwin
                //  PID COMMAND      %CPU   TIME   #TH #PRTS #MREGS RPRVT  RSHRD  RSIZE  VSIZE
                // 2295 top          0.0%  0:00.23   1    15    17   212K   312K   492K  13.6M 
                JString val = oc.get(9);
                if (val.endsWith("K"))
                        memuse = (int)(val.substring(0, (val.length()-2)).toDouble() * 1024);
                else if (val.endsWith("K+"))
                        memuse = (int)(val.substring(0, (val.length()-3)).toDouble() * 1024);
                else if (val.endsWith("M"))
                        memuse = (int)(val.substring(0, (val.length()-2)).toDouble() * 1024 * 1024);
                else if (val.endsWith("M+"))
                        memuse = (int)(val.substring(0, (val.length()-3)).toDouble() * 1024 * 1024);
                else
                        memuse = val.toInt();
        #else
                // Linux: 11233 root      15   0   524  524   440 S     0.0  0.1   0:00   0 tail -n 1
                memuse = (int)(oc.get(4).toDouble() * 1024);
        #endif // Darwin

        if (memuse < 1)
                memuse = 0;

        struct rusage us;
        getrusage(RUSAGE_SELF, &us);
        printf("MemUse:  %d  -  %d  %d  %d  %d\n", memuse, ru_maxrss, us.ru_ixrss, us.ru_idrss, us.ru_isrss);

        return memuse;*/
}

JString JThread::getComputerName() {
        int len = 1000;
        char buffer[1000];
        if (gethostname(buffer, len) == -1)
                return "";
        else
                return buffer;
}


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

        size = backtrace(array, 200);
        strings = backtrace_symbols(array, size);
        for (i = 0; i < size; i++)
                col.add(strings[i]);
        free (strings);
#endif // _DEBUG
#endif // Darwin
        return col;
}



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

void JThread::OnException() {
}

void JThread::OnSignal(int signo) {
}

*/






// The main thread running function
void* staticRunThread(void* arg) {

        #ifndef Darwin
                sigset_t cancel;
                sigemptyset(&cancel);
                sigaddset(&cancel, SIGQUIT);
                pthread_sigmask(SIG_UNBLOCK, &cancel, NULL);
        #endif

        JThread* thr = (JThread*) arg;
        thr->linuxThreadHasFinished = false;
//      printf("[Thread %d started]\n", (int)thr->hThread);
        thr->threadStartTime = JTime();
        thr->threadEndTime.setInvalid();
        thr->run();
        thr->threadEndTime = JTime();
//      printf("[Thread %d ended]\n", (int)thr->hThread);
        thr->linuxThreadHasFinished = true;
        return NULL;
}

} // namespace cmlabs

#endif

---