guicast/thread.C

   1 #include "bcsignals.h"
   2 #include <sys/wait.h>
   3 #include <sched.h>
   4 #include <signal.h>
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include "thread.h"
   8
   9
  10 Thread::Thread(int synchronous, int realtime, int autodelete)
  11 {
  12         this->synchronous = synchronous;
  13         this->realtime = realtime;
  14         this->autodelete = autodelete;
  15         tid = (pthread_t)-1;
  16         tid_valid = 0;
  17         thread_running = 0;
  18         cancel_enabled = 0;
  19 }
  20
  21 Thread::~Thread()
  22 {
  23 }
  24
  25 void* Thread::entrypoint(void *parameters)
  26 {
  27         Thread *thread = (Thread*)parameters;
  28
  29 // allow thread to be cancelled at any point during a region where it is enabled.
  30         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
  31 // Disable cancellation by default.
  32         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
  33         thread->cancel_enabled = 0;
  34
  35 // Set realtime here seince it doesn't work in start
  36         if(thread->realtime && getuid() == 0)
  37         {
  38                 struct sched_param param =
  39                 {
  40                         sched_priority : 1
  41                 };
  42                 if(pthread_setschedparam(thread->tid, SCHED_RR, &param) < 0)
  43                         perror("Thread::entrypoint pthread_attr_setschedpolicy");
  44         }
  45
  46         thread->run();
  47
  48         thread->thread_running = 0;
  49
  50         if(thread->autodelete && !thread->synchronous) delete thread;
  51         return NULL;
  52 }
  53
  54 void Thread::start()
  55 {
  56         pthread_attr_t  attr;
  57         struct sched_param param;
  58
  59         pthread_attr_init(&attr);
  60
  61         thread_running = 1;
  62
  63 // Inherit realtime from current thread the easy way.
  64         if(!realtime) realtime = calculate_realtime();
  65
  66
  67         if(!synchronous) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  68
  69         if(realtime && getuid() == 0)
  70         {
  71                 if(pthread_attr_setschedpolicy(&attr, SCHED_RR) < 0)
  72                         perror("Thread::start pthread_attr_setschedpolicy");
  73                 param.sched_priority = 50;
  74                 if(pthread_attr_setschedparam(&attr, &param) < 0)
  75                         perror("Thread::start pthread_attr_setschedparam");
  76         }
  77         else
  78         {
  79                 if(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED) < 0)
  80                         perror("Thread::start pthread_attr_setinheritsched");
  81         }
  82
  83         pthread_create(&tid, &attr, Thread::entrypoint, this);
  84         tid_valid = 1;
  85 }
  86
  87 int Thread::end(pthread_t tid)           // need to join after this if synchronous
  88 {
  89         if(tid_valid)
  90         {
  91                 pthread_cancel(tid);
  92         }
  93         return 0;
  94 }
  95
  96 int Thread::end()           // need to join after this if synchronous
  97 {
  98         cancel();
  99         return 0;
 100 }
 101
 102 int Thread::cancel()
 103 {
 104         if(tid_valid) pthread_cancel(tid);
 105         if(!synchronous)
 106         {
 107                 tid = (pthread_t)-1;
 108                 tid_valid = 0;
 109         }
 110         return 0;
 111 }
 112
 113 int Thread::join()   // join this thread
 114 {
 115         int result = 0;
 116         if(tid_valid)
 117         {
 118                 result = pthread_join(tid, 0);
 119         }
 120
 121         tid = (pthread_t)-1;
 122         tid_valid = 0;
 123
 124 // Don't execute anything after this.
 125         if(autodelete && synchronous) delete this;
 126         return 0;
 127 }
 128
 129 int Thread::enable_cancel()
 130 {
 131         cancel_enabled = 1;
 132         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 133         return 0;
 134 }
 135
 136 int Thread::disable_cancel()
 137 {
 138         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
 139         cancel_enabled = 0;
 140         return 0;
 141 }
 142
 143 int Thread::get_cancel_enabled()
 144 {
 145         return cancel_enabled;
 146 }
 147
 148 int Thread::exit_thread()
 149 {
 150         pthread_exit(0);
 151         if(!synchronous)
 152         {
 153                 tid = (pthread_t)-1;
 154                 tid_valid = 0;
 155         }
 156         return 0;
 157 }
 158
 159
 160 int Thread::suspend_thread()
 161 {
 162         if(tid_valid) pthread_kill(tid, SIGSTOP);
 163         return 0;
 164 }
 165
 166 int Thread::continue_thread()
 167 {
 168         if(tid_valid) pthread_kill(tid, SIGCONT);
 169         return 0;
 170 }
 171
 172 int Thread::running()
 173 {
 174         return thread_running;
 175 }
 176
 177 int Thread::set_synchronous(int value)
 178 {
 179         this->synchronous = value;
 180         return 0;
 181 }
 182
 183 int Thread::set_realtime(int value)
 184 {
 185         this->realtime = value;
 186         return 0;
 187 }
 188
 189 int Thread::set_autodelete(int value)
 190 {
 191         this->autodelete = value;
 192         return 0;
 193 }
 194
 195 int Thread::get_autodelete()
 196 {
 197         return autodelete;
 198 }
 199
 200 int Thread::get_synchronous()
 201 {
 202         return synchronous;
 203 }
 204
 205 int Thread::calculate_realtime()
 206 {
 207 //printf("Thread::calculate_realtime %d %d\n", getpid(), sched_getscheduler(0));
 208         return (sched_getscheduler(0) == SCHED_RR ||
 209                 sched_getscheduler(0) == SCHED_FIFO);
 210 }
 211
 212 int Thread::get_realtime()
 213 {
 214         return realtime;
 215 }
 216
 217 int Thread::get_tid()
 218 {
 219         return tid;
 220 }
 221