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 #if defined(__linux__) && !defined(SCHED_RESET_ON_FORK)
  32 # define SCHED_RESET_ON_FORK 0x40000000
  33 #endif
  34
  35 namespace Jack
  36 {
  37
  38 void* JackPosixThread::ThreadHandler(void* arg)
  39 {
  40     JackPosixThread* obj = (JackPosixThread*)arg;
  41     JackRunnableInterface* runnable = obj->fRunnable;
  42     int err;
  43
  44     if ((err = pthread_setcanceltype(obj->fCancellation, NULL)) != 0) {
  45         jack_error("pthread_setcanceltype err = %s", strerror(err));
  46     }
  47
  48     // Signal creation thread when started with StartSync
  49     jack_log("JackPosixThread::ThreadHandler : start");
  50     obj->fStatus = kIniting;
  51
  52     // Call Init method
  53     if (!runnable->Init()) {
  54         jack_error("Thread init fails: thread quits");
  55         return 0;
  56     }
  57
  58     obj->fStatus = kRunning;
  59
  60     // If Init succeed, start the thread loop
  61     bool res = true;
  62     while (obj->fStatus == kRunning && res) {
  63         res = runnable->Execute();
  64     }
  65
  66     jack_log("JackPosixThread::ThreadHandler : exit");
  67     pthread_exit(0);
  68     return 0; // never reached
  69 }
  70
  71 int JackPosixThread::Start()
  72 {
  73     fStatus = kStarting;
  74
  75     // Check if the thread was correctly started
  76     if (StartImp(&fThread, fPriority, fRealTime, ThreadHandler, this) < 0) {
  77         fStatus = kIdle;
  78         return -1;
  79     } else {
  80         return 0;
  81     }
  82 }
  83
  84 int JackPosixThread::StartSync()
  85 {
  86     fStatus = kStarting;
  87
  88     if (StartImp(&fThread, fPriority, fRealTime, ThreadHandler, this) < 0) {
  89         fStatus = kIdle;
  90         return -1;
  91     } else {
  92         int count = 0;
  93         while (fStatus == kStarting && ++count < 1000) {
  94             JackSleep(1000);
  95         }
  96         return (count == 1000) ? -1 : 0;
  97     }
  98 }
  99
 100 int JackPosixThread::StartImp(jack_native_thread_t* thread, int priority, int realtime, void*(*start_routine)(void*), void* arg)
 101 {
 102     pthread_attr_t attributes;
 103     struct sched_param rt_param;
 104     pthread_attr_init(&attributes);
 105     int res;
 106
 107     if ((res = pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_JOINABLE))) {
 108         jack_error("Cannot request joinable thread creation for thread res = %d", res);
 109         return -1;
 110     }
 111
 112     if ((res = pthread_attr_setscope(&attributes, PTHREAD_SCOPE_SYSTEM))) {
 113         jack_error("Cannot set scheduling scope for thread res = %d", res);
 114         return -1;
 115     }
 116
 117     if (realtime) {
 118
 119         jack_log("JackPosixThread::StartImp : create RT thread");
 120
 121         if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
 122             jack_error("Cannot request explicit scheduling for RT thread res = %d", res);
 123             return -1;
 124         }
 125
 126         if ((res = pthread_attr_setschedpolicy(&attributes, JACK_SCHED_POLICY))) {
 127             jack_error("Cannot set RR scheduling class for RT thread res = %d", res);
 128             return -1;
 129         }
 130
 131         memset(&rt_param, 0, sizeof(rt_param));
 132         rt_param.sched_priority = priority;
 133
 134         if ((res = pthread_attr_setschedparam(&attributes, &rt_param))) {
 135             jack_error("Cannot set scheduling priority for RT thread res = %d", res);
 136             return -1;
 137         }
 138
 139     } else {
 140         jack_log("JackPosixThread::StartImp : create non RT thread");
 141         if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
 142             jack_log("Cannot request explicit scheduling for non RT thread res = %d", res);
 143         }
 144     }
 145
 146     if ((res = pthread_attr_setstacksize(&attributes, THREAD_STACK))) {
 147         jack_error("Cannot set thread stack size res = %d", res);
 148         return -1;
 149     }
 150
 151     if ((res = JackGlobals::fJackThreadCreator(thread, &attributes, start_routine, arg))) {
 152         jack_error("Cannot create thread res = %d", res);
 153         return -1;
 154     }
 155
 156     pthread_attr_destroy(&attributes);
 157     return 0;
 158 }
 159
 160 int JackPosixThread::Kill()
 161 {
 162     if (fThread != (jack_native_thread_t)NULL) { // If thread has been started
 163         jack_log("JackPosixThread::Kill");
 164         void* status;
 165         pthread_cancel(fThread);
 166         pthread_join(fThread, &status);
 167         fStatus = kIdle;
 168         fThread = (jack_native_thread_t)NULL;
 169         return 0;
 170     } else {
 171         return -1;
 172     }
 173 }
 174
 175 int JackPosixThread::Stop()
 176 {
 177     if (fThread != (jack_native_thread_t)NULL) { // If thread has been started
 178         jack_log("JackPosixThread::Stop");
 179         void* status;
 180         fStatus = kIdle; // Request for the thread to stop
 181         pthread_join(fThread, &status);
 182         fThread = (jack_native_thread_t)NULL;
 183         return 0;
 184     } else {
 185         return -1;
 186     }
 187 }
 188
 189 int JackPosixThread::KillImp(jack_native_thread_t thread)
 190 {
 191     if (thread != (jack_native_thread_t)NULL) { // If thread has been started
 192         jack_log("JackPosixThread::Kill");
 193         void* status;
 194         pthread_cancel(thread);
 195         pthread_join(thread, &status);
 196         return 0;
 197     } else {
 198         return -1;
 199     }
 200 }
 201
 202 int JackPosixThread::StopImp(jack_native_thread_t thread)
 203 {
 204     if (thread != (jack_native_thread_t)NULL) { // If thread has been started
 205         jack_log("JackPosixThread::Stop");
 206         void* status;
 207         pthread_join(thread, &status);
 208         return 0;
 209     } else {
 210         return -1;
 211     }
 212 }
 213
 214 int JackPosixThread::AcquireRealTime()
 215 {
 216     return (fThread != (jack_native_thread_t)NULL) ? AcquireRealTimeImp(fThread, fPriority) : -1;
 217 }
 218
 219 int JackPosixThread::AcquireSelfRealTime()
 220 {
 221     return AcquireRealTimeImp(pthread_self(), fPriority);
 222 }
 223
 224 int JackPosixThread::AcquireRealTime(int priority)
 225 {
 226     fPriority = priority;
 227     return AcquireRealTime();
 228 }
 229
 230 int JackPosixThread::AcquireSelfRealTime(int priority)
 231 {
 232     fPriority = priority;
 233     return AcquireSelfRealTime();
 234 }
 235 int JackPosixThread::AcquireRealTimeImp(jack_native_thread_t thread, int priority)
 236 {
 237     struct sched_param rtparam;
 238     int res;
 239     memset(&rtparam, 0, sizeof(rtparam));
 240     rtparam.sched_priority = priority;
 241
 242     jack_log("JackPosixThread::AcquireRealTimeImp priority = %d", priority);
 243
 244     if ((res = pthread_setschedparam(thread, JACK_SCHED_POLICY, &rtparam)) == 0)
 245         return 0;
 246
 247 #ifdef SCHED_RESET_ON_FORK
 248     jack_log("pthread_setschedparam() failed (%d), trying with SCHED_RESET_ON_FORK.", res);
 249     if ((res = pthread_setschedparam(thread, JACK_SCHED_POLICY|SCHED_RESET_ON_FORK, &rtparam)) == 0)
 250         return 0;
 251 #endif
 252
 253     jack_error("Cannot use real-time scheduling (RR/%d)"
 254                " (%d: %s)", rtparam.sched_priority, res,
 255                strerror(res));
 256     return -1;
 257 }
 258
 259 int JackPosixThread::DropRealTime()
 260 {
 261     return (fThread != (jack_native_thread_t)NULL) ? DropRealTimeImp(fThread) : -1;
 262 }
 263
 264 int JackPosixThread::DropSelfRealTime()
 265 {
 266     return DropRealTimeImp(pthread_self());
 267 }
 268
 269 int JackPosixThread::DropRealTimeImp(jack_native_thread_t thread)
 270 {
 271     struct sched_param rtparam;
 272     int res;
 273     memset(&rtparam, 0, sizeof(rtparam));
 274     rtparam.sched_priority = 0;
 275
 276     if ((res = pthread_setschedparam(thread, SCHED_OTHER, &rtparam)) != 0) {
 277         jack_error("Cannot switch to normal scheduling priority(%s)", strerror(errno));
 278         return -1;
 279     }
 280     return 0;
 281 }
 282
 283 jack_native_thread_t JackPosixThread::GetThreadID()
 284 {
 285     return fThread;
 286 }
 287
 288 bool JackPosixThread::IsThread()
 289 {
 290     return pthread_self() == fThread;
 291 }
 292
 293 void JackPosixThread::Terminate()
 294 {
 295     jack_log("JackPosixThread::Terminate");
 296     pthread_exit(0);
 297 }
 298
 299 SERVER_EXPORT void ThreadExit()
 300 {
 301     jack_log("ThreadExit");
 302     pthread_exit(0);
 303 }
 304
 305 } // end of namespace
 306
 307 bool jack_get_thread_realtime_priority_range(int * min_ptr, int * max_ptr)
 308 {
 309 #if defined(_POSIX_PRIORITY_SCHEDULING) && !defined(__APPLE__)
 310     int min, max;
 311
 312     min = sched_get_priority_min(JACK_SCHED_POLICY);
 313     if (min == -1)
 314     {
 315         jack_error("sched_get_priority_min() failed.");
 316         return false;
 317     }
 318
 319     max = sched_get_priority_max(JACK_SCHED_POLICY);
 320     if (max == -1)
 321     {
 322         jack_error("sched_get_priority_max() failed.");
 323         return false;
 324     }
 325
 326     *min_ptr = min;
 327     *max_ptr = max;
 328
 329     return true;
 330 #else
 331     return false;
 332 #endif
 333 }
 334
 335 bool jack_tls_allocate_key(jack_tls_key *key_ptr)
 336 {
 337     int ret;
 338
 339     ret = pthread_key_create(key_ptr, NULL);
 340     if (ret != 0)
 341     {
 342         jack_error("pthread_key_create() failed with error %d", ret);
 343         return false;
 344     }
 345
 346     return true;
 347 }
 348
 349 bool jack_tls_free_key(jack_tls_key key)
 350 {
 351     int ret;
 352
 353     ret = pthread_key_delete(key);
 354     if (ret != 0)
 355     {
 356         jack_error("pthread_key_delete() failed with error %d", ret);
 357         return false;
 358     }
 359
 360     return true;
 361 }
 362
 363 bool jack_tls_set(jack_tls_key key, void *data_ptr)
 364 {
 365     int ret;
 366
 367     ret = pthread_setspecific(key, (const void *)data_ptr);
 368     if (ret != 0)
 369     {
 370         jack_error("pthread_setspecific() failed with error %d", ret);
 371         return false;
 372     }
 373
 374     return true;
 375 }
 376
 377 void *jack_tls_get(jack_tls_key key)
 378 {
 379     return pthread_getspecific(key);
 380 }