lib/base/thread.cpp

   1 #include <lib/base/thread.h>
   2
   3 #include <stdio.h>
   4 #include <unistd.h>
   5 #include <lib/base/eerror.h>
   6
   7 void eThread::thread_completed(void *ptr)
   8 {
   9         eThread *p = (eThread*) ptr;
  10         p->m_alive = 0;
  11
  12                 /* recover state */
  13         if (!p->m_state.value())
  14         {
  15                 p->m_state.up();
  16                 ASSERT(p->m_state.value() == 1);
  17         }
  18
  19         p->thread_finished();
  20 }
  21
  22 void *eThread::wrapper(void *ptr)
  23 {
  24         eThread *p = (eThread*)ptr;
  25         pthread_cleanup_push(thread_completed, (void*)p);
  26         p->thread();
  27         pthread_exit(0);
  28         pthread_cleanup_pop(1);
  29         return 0;
  30 }
  31
  32 eThread::eThread()
  33         : the_thread(0), m_alive(0)
  34 {
  35 }
  36
  37 int eThread::runAsync(int prio, int policy)
  38 {
  39         eDebug("before: %d", m_state.value());
  40                 /* the thread might already run. */
  41         if (sync())
  42                 return -1;
  43
  44         eDebug("after: %d", m_state.value());
  45         ASSERT(m_state.value() == 1); /* sync postconditions */
  46         ASSERT(!m_alive);
  47         m_state.down();
  48         ASSERT(m_state.value() == 0);
  49
  50         m_alive = 1;
  51
  52                 /* start thread. */
  53         pthread_attr_t attr;
  54         pthread_attr_init(&attr);
  55
  56         if (prio || policy)
  57         {
  58                 struct sched_param p;
  59                 p.__sched_priority=prio;
  60                 pthread_attr_setschedpolicy(&attr, policy);
  61                 pthread_attr_setschedparam(&attr, &p);
  62         }
  63
  64         if (pthread_create(&the_thread, &attr, wrapper, this))
  65         {
  66                 pthread_attr_destroy(&attr);
  67                 m_alive = 0;
  68                 eDebug("couldn't create new thread");
  69                 return -1;
  70         }
  71
  72         pthread_attr_destroy(&attr);
  73         return 0;
  74 }
  75
  76 int eThread::run(int prio, int policy)
  77 {
  78         if (runAsync(prio, policy))
  79                 return -1;
  80         sync();
  81         return 0;
  82 }
  83
  84 eThread::~eThread()
  85 {
  86         kill();
  87 }
  88
  89 int eThread::sync(void)
  90 {
  91         int res;
  92         int debug_val_before = m_state.value();
  93         m_state.down(); /* this might block */
  94         res = m_alive;
  95         if (m_state.value() != 0)
  96                 eFatal("eThread::sync: m_state.value() == %d - was %d before", m_state.value(), debug_val_before);
  97         ASSERT(m_state.value() == 0);
  98         m_state.up();
  99         return res; /* 0: thread is guaranteed not to run. 1: state unknown. */
 100 }
 101
 102 int eThread::sendSignal(int sig)
 103 {
 104         if (m_alive)
 105                 return pthread_kill(the_thread, sig);
 106         else
 107                 eDebug("send signal to non running thread");
 108         return -1;
 109 }
 110
 111 void eThread::kill(bool sendcancel)
 112 {
 113         if (!the_thread) /* already joined */
 114                 return;
 115
 116         if (sync() && sendcancel)
 117         {
 118                 eDebug("send cancel to thread");
 119                 pthread_cancel(the_thread);
 120         }
 121         eDebug("thread joined %d", pthread_join(the_thread, 0));
 122         the_thread = 0;
 123 }
 124
 125 void eThread::hasStarted()
 126 {
 127         ASSERT(!m_state.value());
 128         m_state.up();
 129 }