plugins/common/thread.cpp

   1 /*
   2 Copyright (C) 2012 Intel Corporation
   3
   4 This library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Lesser General Public
   6 License as published by the Free Software Foundation; either
   7 version 2.1 of the License, or (at your option) any later version.
   8
   9 This library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Lesser General Public License for more details.
  13
  14 You should have received a copy of the GNU Lesser General Public
  15 License along with this library; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 /******************************************************************
  20 *
  21 *       CUtil for C++
  22 *
  23 *       File: Thread.cpp
  24 *
  25 *       Revision;
  26 *
  27 *       07/07/13
  28 *               - first revision
  29 ******************************************************************/
  30
  31 #include <errno.h>
  32 #include <stdio.h>
  33
  34 #include "mutex.h"
  35 #include "thread.h"
  36 #include <stdlib.h>
  37
  38 ////////////////////////////////////////////////
  39 // Thread Func
  40 ////////////////////////////////////////////////
  41
  42 static CUtil::Mutex gMutex;
  43 static int gActiveThreadCount(0);
  44
  45 static void *PosixThreadProc(void *param)
  46 {
  47     gMutex.lock();
  48     ++gActiveThreadCount;
  49     gMutex.unlock();
  50
  51     CUtil::Thread *thread = (CUtil::Thread *)param;
  52     thread->run();
  53
  54     gMutex.lock();
  55     --gActiveThreadCount;
  56     LOG_INFO("PosixThreadProc() - active threads: " << gActiveThreadCount);
  57     gMutex.unlock();
  58     return 0;
  59 }
  60
  61 namespace CUtil{
  62 ////////////////////////////////////////////////
  63 // Thread
  64 ////////////////////////////////////////////////
  65
  66 Thread::Thread() :
  67     thread(0),
  68     runnableFlag(false)
  69 {
  70     pthread_cond_init( &cond, NULL );
  71     pthread_mutex_init( &mutex, NULL );
  72 }
  73
  74 bool Thread::start()
  75 {
  76     pthread_mutex_lock(&mutex);
  77     if (runnableFlag) {// already running
  78         pthread_mutex_unlock(&mutex);
  79         return false;
  80     }
  81     // try to run
  82     if (pthread_create(&thread, NULL/*&thread_attr*/, PosixThreadProc, this) != 0) {
  83         //pthread_attr_destroy(&thread_attr);
  84         pthread_mutex_unlock(&mutex);
  85         return false;
  86     }
  87     //pthread_attr_destroy(&thread_attr);
  88     runnableFlag = true;
  89     pthread_mutex_unlock(&mutex);
  90     return true;
  91 }
  92
  93
  94 bool Thread::setPriority(int priority)
  95 {
  96     pthread_mutex_lock(&mutex);
  97     if (!runnableFlag) {// not running yet or terminated already
  98         pthread_mutex_unlock(&mutex);
  99         return false;
 100     }
 101
 102     priority = priority < 1  ? 1  : priority;
 103     priority = priority < 99 ? priority : 99;
 104
 105     // set priority
 106     struct sched_param pr;
 107     pr.__sched_priority = priority;
 108     if (pthread_setschedparam(thread, SCHED_FIFO, &pr) < 0)
 109     {
 110         pthread_mutex_unlock(&mutex);
 111         return false;
 112     }
 113
 114     pthread_mutex_unlock(&mutex);
 115     return true;
 116 }
 117
 118 Thread::~Thread()
 119 {
 120     stop();
 121     pthread_cond_destroy( &cond );
 122     pthread_mutex_destroy( &mutex );
 123     thread = 0;
 124 }
 125
 126 void Thread::stop()
 127 {
 128     if (setRunnableFlag(false) == true) {
 129         if( thread != 0 ){
 130             if (thread == pthread_self()){
 131                 int s = pthread_detach(thread);
 132                 ((void)s);// prevent compiler warning in RELEASE build
 133                 LOG_MESSAGE("Thread::stop() - thread " << std::hex << int(thread) << std::dec << " detached, returned value was " << s);
 134             }
 135             else{
 136                 int s = pthread_join(thread, NULL);
 137                 if (s != 0){
 138                     LOG_ERROR("Thread::stop() - Joined with thread " << std::hex << int(thread) << std::dec << ", returned value was " << s);
 139                 }
 140                 else{
 141                     LOG_MESSAGE("Thread::stop() - Joined with thread " << std::hex << int(thread) << std::dec << ", returned value was " << s);
 142                 }
 143             }
 144             thread = 0;
 145         }
 146     }
 147     return;
 148 }
 149
 150 bool Thread::setRunnableFlag(bool flag)
 151 {
 152     pthread_mutex_lock(&mutex);
 153     bool retval(runnableFlag);
 154     runnableFlag = flag;
 155
 156     if(!runnableFlag)
 157         pthread_cond_signal(&cond);
 158     pthread_mutex_unlock(&mutex);
 159     return retval;
 160 }
 161
 162 bool Thread::isRunnable(long miliseconds)
 163 {
 164     bool runnable(false);
 165
 166     pthread_mutex_lock(&mutex);
 167     if (miliseconds != 0){
 168         wait(miliseconds);
 169     }
 170     runnable = runnableFlag;
 171
 172     pthread_mutex_unlock(&mutex);
 173     return runnable;
 174 }
 175
 176 bool Thread::wait( long miliseconds )
 177 {
 178     struct timespec abstime;
 179     clock_gettime(CLOCK_REALTIME, &abstime);
 180     abstime.tv_sec += ( miliseconds / 1000 );
 181     miliseconds %= 1000;
 182     abstime.tv_nsec += ( miliseconds * 1000000L ); // in nanoseconds
 183     if ( abstime.tv_nsec > 1000000000L /* > 1s */ ){
 184         abstime.tv_sec += 1; // +1s
 185         abstime.tv_nsec -= 1000000000L; // -1s
 186     }
 187
 188     int status = pthread_cond_timedwait( &cond, &mutex, &abstime );
 189     return ( status == ETIMEDOUT );
 190 }
 191
 192 }