posix/JackPosixThread.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19 */
  20
  21 #include "JackPosixThread.h"
  22 #include "JackError.h"
  23 #include "JackTime.h"
  24 #include "JackGlobals.h"
  25 #include <string.h> // for memset
  26 #include <unistd.h> // for _POSIX_PRIORITY_SCHEDULING check
  27
  28 //#define JACK_SCHED_POLICY SCHED_RR
  29 #define JACK_SCHED_POLICY SCHED_FIFO
  30
  31 namespace Jack
  32 {
  33
  34 void* JackPosixThread::ThreadHandler(void* arg)
  35 {
  36     JackPosixThread* obj = (JackPosixThread*)arg;
  37     JackRunnableInterface* runnable = obj->fRunnable;
  38     int err;
  39
  40     if ((err = pthread_setcanceltype(obj->fCancellation, NULL)) != 0) {
  41         jack_error("pthread_setcanceltype err = %s", strerror(err));
  42     }
  43
  44     // Signal creation thread when started with StartSync
  45     jack_log("ThreadHandler: start");
  46     obj->fStatus = kIniting;
  47
  48     // Call Init method
  49     if (!runnable->Init()) {
  50         jack_error("Thread init fails: thread quits");
  51         return 0;
  52     }
  53
  54     obj->fStatus = kRunning;
  55
  56     // If Init succeed, start the thread loop
  57     bool res = true;
  58     while (obj->fStatus == kRunning && res) {
  59         res = runnable->Execute();
  60     }
  61
  62     jack_log("ThreadHandler: exit");
  63     pthread_exit(0);
  64     return 0; // never reached
  65 }
  66
  67 int JackPosixThread::Start()
  68 {
  69     fStatus = kStarting;
  70
  71     // Check if the thread was correctly started
  72     if (StartImp(&fThread, fPriority, fRealTime, ThreadHandler, this) < 0) {
  73         fStatus = kIdle;
  74         return -1;
  75     } else {
  76         return 0;
  77     }
  78 }
  79
  80 int JackPosixThread::StartSync()
  81 {
  82     fStatus = kStarting;
  83
  84     if (StartImp(&fThread, fPriority, fRealTime, ThreadHandler, this) < 0) {
  85         fStatus = kIdle;
  86         return -1;
  87     } else {
  88         int count = 0;
  89         while (fStatus == kStarting && ++count < 1000) {
  90             JackSleep(1000);
  91         }
  92         return (count == 1000) ? -1 : 0;
  93     }
  94 }
  95
  96 int JackPosixThread::StartImp(pthread_t* thread, int priority, int realtime, void*(*start_routine)(void*), void* arg)
  97 {
  98     pthread_attr_t attributes;
  99     struct sched_param rt_param;
 100     pthread_attr_init(&attributes);
 101     int res;
 102
 103     if ((res = pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_JOINABLE))) {
 104         jack_error("Cannot request joinable thread creation for RT thread res = %d err = %s", res, strerror(errno));
 105         return -1;
 106     }
 107
 108     if ((res = pthread_attr_setscope(&attributes, PTHREAD_SCOPE_SYSTEM))) {
 109         jack_error("Cannot set scheduling scope for RT thread res = %d err = %s", res, strerror(errno));
 110         return -1;
 111     }
 112
 113     if (realtime) {
 114
 115         jack_log("Create RT thread");
 116
 117         if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
 118             jack_error("Cannot request explicit scheduling for RT thread res = %d err = %s", res, strerror(errno));
 119             return -1;
 120         }
 121
 122         if ((res = pthread_attr_setschedpolicy(&attributes, JACK_SCHED_POLICY))) {
 123             jack_error("Cannot set RR scheduling class for RT thread res = %d err = %s", res, strerror(errno));
 124             return -1;
 125         }
 126     } else {
 127         jack_log("Create non RT thread");
 128     }
 129
 130     memset(&rt_param, 0, sizeof(rt_param));
 131     rt_param.sched_priority = priority;
 132
 133     if ((res = pthread_attr_setschedparam(&attributes, &rt_param))) {
 134         jack_error("Cannot set scheduling priority for RT thread res = %d err = %s", res, strerror(errno));
 135         return -1;
 136     }
 137
 138     if ((res = pthread_attr_setstacksize(&attributes, THREAD_STACK))) {
 139         jack_error("Cannot set thread stack size res = %d err = %s", res, strerror(errno));
 140         return -1;
 141     }
 142
 143     if ((res = JackGlobals::fJackThreadCreator(thread, &attributes, start_routine, arg))) {
 144         jack_error("Cannot create thread res = %d err = %s", res, strerror(errno));
 145         return -1;
 146     }
 147
 148     pthread_attr_destroy(&attributes);
 149     return 0;
 150 }
 151
 152 int JackPosixThread::Kill()
 153 {
 154     if (fThread != (pthread_t)NULL) { // If thread has been started
 155         jack_log("JackPosixThread::Kill");
 156         void* status;
 157         pthread_cancel(fThread);
 158         pthread_join(fThread, &status);
 159         fStatus = kIdle;
 160         fThread = (pthread_t)NULL;
 161         return 0;
 162     } else {
 163         return -1;
 164     }
 165 }
 166
 167 int JackPosixThread::Stop()
 168 {
 169     if (fThread != (pthread_t)NULL) { // If thread has been started
 170         jack_log("JackPosixThread::Stop");
 171         void* status;
 172         fStatus = kIdle; // Request for the thread to stop
 173         pthread_join(fThread, &status);
 174         fThread = (pthread_t)NULL;
 175         return 0;
 176     } else {
 177         return -1;
 178     }
 179 }
 180
 181 int JackPosixThread::KillImp(pthread_t thread)
 182 {
 183     if (thread != (pthread_t)NULL) { // If thread has been started
 184         jack_log("JackPosixThread::Kill");
 185         void* status;
 186         pthread_cancel(thread);
 187         pthread_join(thread, &status);
 188         return 0;
 189     } else {
 190         return -1;
 191     }
 192 }
 193
 194 int JackPosixThread::StopImp(pthread_t thread)
 195 {
 196     if (thread != (pthread_t)NULL) { // If thread has been started
 197         jack_log("JackPosixThread::Stop");
 198         void* status;
 199         pthread_join(thread, &status);
 200         return 0;
 201     } else {
 202         return -1;
 203     }
 204 }
 205
 206 int JackPosixThread::AcquireRealTime()
 207 {
 208     return (fThread != (pthread_t)NULL) ? AcquireRealTimeImp(fThread, fPriority) : -1;
 209 }
 210
 211 int JackPosixThread::AcquireRealTime(int priority)
 212 {
 213     fPriority = priority;
 214     return AcquireRealTime();
 215 }
 216
 217 int JackPosixThread::AcquireRealTimeImp(pthread_t thread, int priority)
 218 {
 219     struct sched_param rtparam;
 220     int res;
 221     memset(&rtparam, 0, sizeof(rtparam));
 222     rtparam.sched_priority = priority;
 223
 224     if ((res = pthread_setschedparam(thread, JACK_SCHED_POLICY, &rtparam)) != 0) {
 225         jack_error("Cannot use real-time scheduling (RR/%d)"
 226                    "(%d: %s)", rtparam.sched_priority, res,
 227                    strerror(res));
 228         return -1;
 229     }
 230     return 0;
 231 }
 232
 233 int JackPosixThread::DropRealTime()
 234 {
 235     return (fThread != (pthread_t)NULL) ? DropRealTimeImp(fThread) : -1;
 236 }
 237
 238 int JackPosixThread::DropRealTimeImp(pthread_t thread)
 239 {
 240     struct sched_param rtparam;
 241     int res;
 242     memset(&rtparam, 0, sizeof(rtparam));
 243     rtparam.sched_priority = 0;
 244
 245     if ((res = pthread_setschedparam(thread, SCHED_OTHER, &rtparam)) != 0) {
 246         jack_error("Cannot switch to normal scheduling priority(%s)", strerror(errno));
 247         return -1;
 248     }
 249     return 0;
 250 }
 251
 252 pthread_t JackPosixThread::GetThreadID()
 253 {
 254     return fThread;
 255 }
 256
 257 void JackPosixThread::Terminate()
 258 {
 259     jack_log("JackPosixThread::Terminate");
 260     pthread_exit(0);
 261 }
 262
 263 SERVER_EXPORT void ThreadExit()
 264 {
 265     jack_log("ThreadExit");
 266     pthread_exit(0);
 267 }
 268
 269 } // end of namespace
 270
 271 bool jack_get_thread_realtime_priority_range(int * min_ptr, int * max_ptr)
 272 {
 273 #if defined(_POSIX_PRIORITY_SCHEDULING) && !defined(__APPLE__)
 274     int min, max;
 275
 276     min = sched_get_priority_min(JACK_SCHED_POLICY);
 277     if (min == -1)
 278     {
 279         jack_error("sched_get_priority_min() failed.");
 280         return false;
 281     }
 282
 283     max = sched_get_priority_max(JACK_SCHED_POLICY);
 284     if (max == -1)
 285     {
 286         jack_error("sched_get_priority_max() failed.");
 287         return false;
 288     }
 289
 290     *min_ptr = min;
 291     *max_ptr = max;
 292
 293     return true;
 294 #else
 295     return false;
 296 #endif
 297 }
 298
 299 bool jack_tls_allocate_key(jack_tls_key *key_ptr)
 300 {
 301     int ret;
 302
 303     ret = pthread_key_create(key_ptr, NULL);
 304     if (ret != 0)
 305     {
 306         jack_error("pthread_key_create() failed with error %d errno %s", ret, strerror(errno));
 307         return false;
 308     }
 309
 310     return true;
 311 }
 312
 313 bool jack_tls_free_key(jack_tls_key key)
 314 {
 315     int ret;
 316
 317     ret = pthread_key_delete(key);
 318     if (ret != 0)
 319     {
 320         jack_error("pthread_key_delete() failed with error %d errno %s", ret, strerror(errno));
 321         return false;
 322     }
 323
 324     return true;
 325 }
 326
 327 bool jack_tls_set(jack_tls_key key, void *data_ptr)
 328 {
 329     int ret;
 330
 331     ret = pthread_setspecific(key, (const void *)data_ptr);
 332     if (ret != 0)
 333     {
 334         jack_error("pthread_setspecific() failed with error %d errno %s", ret, strerror(errno));
 335         return false;
 336     }
 337
 338     return true;
 339 }
 340
 341 void *jack_tls_get(jack_tls_key key)
 342 {
 343     return pthread_getspecific(key);
 344 }