thread_pthread.c

   1 /* -*-c-*- */
   2 /**********************************************************************
   3
   4   thread_pthread.c -
   5
   6   $Author$
   7
   8   Copyright (C) 2004-2007 Koichi Sasada
   9
  10 **********************************************************************/
  11
  12 #ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
  13
  14 #include "gc.h"
  15
  16 #ifdef HAVE_SYS_RESOURCE_H
  17 #include <sys/resource.h>
  18 #endif
  19
  20 static void native_mutex_lock(pthread_mutex_t *lock);
  21 static void native_mutex_unlock(pthread_mutex_t *lock);
  22 static int native_mutex_trylock(pthread_mutex_t *lock);
  23 static void native_mutex_initialize(pthread_mutex_t *lock);
  24 static void native_mutex_destroy(pthread_mutex_t *lock);
  25
  26 static void native_cond_signal(pthread_cond_t *cond);
  27 static void native_cond_broadcast(pthread_cond_t *cond);
  28 static void native_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
  29 static void native_cond_initialize(pthread_cond_t *cond);
  30 static void native_cond_destroy(pthread_cond_t *cond);
  31
  32 static void
  33 native_mutex_lock(pthread_mutex_t *lock)
  34 {
  35     int r;
  36     if ((r = pthread_mutex_lock(lock)) != 0) {
  37         rb_bug("pthread_mutex_lock: %d", r);
  38     }
  39 }
  40
  41 static void
  42 native_mutex_unlock(pthread_mutex_t *lock)
  43 {
  44     int r;
  45     if ((r = pthread_mutex_unlock(lock)) != 0) {
  46         rb_bug("native_mutex_unlock return non-zero: %d", r);
  47     }
  48 }
  49
  50 static inline int
  51 native_mutex_trylock(pthread_mutex_t *lock)
  52 {
  53     int r;
  54     if ((r = pthread_mutex_trylock(lock)) != 0) {
  55         if (r == EBUSY) {
  56             return EBUSY;
  57         }
  58         else {
  59             rb_bug("native_mutex_trylock return non-zero: %d", r);
  60         }
  61     }
  62     return 0;
  63 }
  64
  65 static void
  66 native_mutex_initialize(pthread_mutex_t *lock)
  67 {
  68     int r = pthread_mutex_init(lock, 0);
  69     if (r != 0) {
  70         rb_bug("native_mutex_initialize return non-zero: %d", r);
  71     }
  72 }
  73
  74 static void
  75 native_mutex_destroy(pthread_mutex_t *lock)
  76 {
  77     int r = pthread_mutex_destroy(lock);
  78     if (r != 0) {
  79         rb_bug("native_mutex_destroy return non-zero: %d", r);
  80     }
  81 }
  82
  83 static void
  84 native_cond_initialize(pthread_cond_t *cond)
  85 {
  86     int r = pthread_cond_init(cond, 0);
  87     if (r != 0) {
  88         rb_bug("native_cond_initialize return non-zero: %d", r);
  89     }
  90 }
  91
  92 static void
  93 native_cond_destroy(pthread_cond_t *cond)
  94 {
  95     int r = pthread_cond_destroy(cond);
  96     if (r != 0) {
  97         rb_bug("native_cond_destroy return non-zero: %d", r);
  98     }
  99 }
 100
 101 static void
 102 native_cond_signal(pthread_cond_t *cond)
 103 {
 104     pthread_cond_signal(cond);
 105 }
 106
 107 static void
 108 native_cond_broadcast(pthread_cond_t *cond)
 109 {
 110     pthread_cond_broadcast(cond);
 111 }
 112
 113 static void
 114 native_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 115 {
 116     pthread_cond_wait(cond, mutex);
 117 }
 118
 119
 120 #define native_cleanup_push pthread_cleanup_push
 121 #define native_cleanup_pop  pthread_cleanup_pop
 122 #ifdef HAVE_SCHED_YIELD
 123 #define native_thread_yield() (void)sched_yield()
 124 #else
 125 #define native_thread_yield() ((void)0)
 126 #endif
 127
 128 #ifndef __CYGWIN__
 129 static void add_signal_thread_list(rb_thread_t *th);
 130 #endif
 131 static void remove_signal_thread_list(rb_thread_t *th);
 132
 133 static rb_thread_lock_t signal_thread_list_lock;
 134
 135 static pthread_key_t ruby_native_thread_key;
 136
 137 static void
 138 null_func(int i)
 139 {
 140     /* null */
 141 }
 142
 143 static rb_thread_t *
 144 ruby_thread_from_native(void)
 145 {
 146     return pthread_getspecific(ruby_native_thread_key);
 147 }
 148
 149 static int
 150 ruby_thread_set_native(rb_thread_t *th)
 151 {
 152     return pthread_setspecific(ruby_native_thread_key, th) == 0;
 153 }
 154
 155 static void
 156 Init_native_thread(void)
 157 {
 158     rb_thread_t *th = GET_THREAD();
 159
 160     pthread_key_create(&ruby_native_thread_key, NULL);
 161     th->thread_id = pthread_self();
 162     native_cond_initialize(&th->native_thread_data.sleep_cond);
 163     ruby_thread_set_native(th);
 164     native_mutex_initialize(&signal_thread_list_lock);
 165     posix_signal(SIGVTALRM, null_func);
 166 }
 167
 168 static void
 169 native_thread_destroy(rb_thread_t *th)
 170 {
 171     pthread_mutex_destroy(&th->interrupt_lock);
 172     pthread_cond_destroy(&th->native_thread_data.sleep_cond);
 173 }
 174
 175 #define USE_THREAD_CACHE 0
 176
 177 static struct {
 178     rb_thread_id_t id;
 179     size_t stack_maxsize;
 180     VALUE *stack_start;
 181 #ifdef __ia64
 182     VALUE *register_stack_start;
 183 #endif
 184 } native_main_thread;
 185
 186 #ifdef STACK_END_ADDRESS
 187 extern void *STACK_END_ADDRESS;
 188 #endif
 189
 190 #undef ruby_init_stack
 191 void
 192 ruby_init_stack(VALUE *addr
 193 #ifdef __ia64
 194     , void *bsp
 195 #endif
 196     )
 197 {
 198     native_main_thread.id = pthread_self();
 199 #ifdef STACK_END_ADDRESS
 200     native_main_thread.stack_start = STACK_END_ADDRESS;
 201 #else
 202     if (!native_main_thread.stack_start ||
 203         STACK_UPPER(&addr,
 204                     native_main_thread.stack_start > addr,
 205                     native_main_thread.stack_start < addr)) {
 206         native_main_thread.stack_start = addr;
 207     }
 208 #endif
 209 #ifdef __ia64
 210     if (!native_main_thread.register_stack_start ||
 211         (VALUE*)bsp < native_main_thread.register_stack_start) {
 212         native_main_thread.register_stack_start = (VALUE*)bsp;
 213     }
 214 #endif
 215 #ifdef HAVE_GETRLIMIT
 216     {
 217         struct rlimit rlim;
 218
 219         if (getrlimit(RLIMIT_STACK, &rlim) == 0) {
 220             unsigned int space = rlim.rlim_cur/5;
 221
 222             if (space > 1024*1024) space = 1024*1024;
 223             native_main_thread.stack_maxsize = rlim.rlim_cur - space;
 224         }
 225     }
 226 #endif
 227 }
 228
 229 #define CHECK_ERR(expr) \
 230     {int err = (expr); if (err) {rb_bug("err: %d - %s", err, #expr);}}
 231
 232 static int
 233 native_thread_init_stack(rb_thread_t *th)
 234 {
 235     rb_thread_id_t curr = pthread_self();
 236
 237     if (pthread_equal(curr, native_main_thread.id)) {
 238         th->machine_stack_start = native_main_thread.stack_start;
 239         th->machine_stack_maxsize = native_main_thread.stack_maxsize;
 240     }
 241     else {
 242 #ifdef HAVE_PTHREAD_GETATTR_NP
 243         pthread_attr_t attr;
 244         void *start;
 245         CHECK_ERR(pthread_getattr_np(curr, &attr));
 246 # if defined HAVE_PTHREAD_ATTR_GETSTACK
 247         CHECK_ERR(pthread_attr_getstack(&attr, &start, &th->machine_stack_maxsize));
 248 # elif defined HAVE_PTHREAD_ATTR_GETSTACKSIZE && defined HAVE_PTHREAD_ATTR_GETSTACKADDR
 249         CHECK_ERR(pthread_attr_getstackaddr(&attr, &start));
 250         CHECK_ERR(pthread_attr_getstacksize(&attr, &th->machine_stack_maxsize));
 251 # endif
 252         th->machine_stack_start = start;
 253 #else
 254         rb_raise(rb_eNotImpError, "ruby engine can initialize only in the main thread");
 255 #endif
 256     }
 257 #ifdef __ia64
 258     th->machine_register_stack_start = native_main_thread.register_stack_start;
 259     th->machine_stack_maxsize /= 2;
 260     th->machine_register_stack_maxsize = th->machine_stack_maxsize;
 261 #endif
 262     return 0;
 263 }
 264
 265 static void *
 266 thread_start_func_1(void *th_ptr)
 267 {
 268 #if USE_THREAD_CACHE
 269   thread_start:
 270 #endif
 271     {
 272         rb_thread_t *th = th_ptr;
 273         VALUE stack_start;
 274
 275         /* run */
 276         thread_start_func_2(th, &stack_start, rb_ia64_bsp());
 277     }
 278 #if USE_THREAD_CACHE
 279     if (1) {
 280         /* cache thread */
 281         rb_thread_t *th;
 282         static rb_thread_t *register_cached_thread_and_wait(void);
 283         if ((th = register_cached_thread_and_wait()) != 0) {
 284             th_ptr = (void *)th;
 285             th->thread_id = pthread_self();
 286             goto thread_start;
 287         }
 288     }
 289 #endif
 290     return 0;
 291 }
 292
 293 void rb_thread_create_control_thread(void);
 294
 295 struct cached_thread_entry {
 296     volatile rb_thread_t **th_area;
 297     pthread_cond_t *cond;
 298     struct cached_thread_entry *next;
 299 };
 300
 301
 302 #if USE_THREAD_CACHE
 303 static pthread_mutex_t thread_cache_lock = PTHREAD_MUTEX_INITIALIZER;
 304 struct cached_thread_entry *cached_thread_root;
 305
 306 static rb_thread_t *
 307 register_cached_thread_and_wait(void)
 308 {
 309     pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 310     volatile rb_thread_t *th_area = 0;
 311     struct cached_thread_entry *entry =
 312       (struct cached_thread_entry *)malloc(sizeof(struct cached_thread_entry));
 313
 314     struct timeval tv;
 315     struct timespec ts;
 316     gettimeofday(&tv, 0);
 317     ts.tv_sec = tv.tv_sec + 60;
 318     ts.tv_nsec = tv.tv_usec * 1000;
 319
 320     pthread_mutex_lock(&thread_cache_lock);
 321     {
 322         entry->th_area = &th_area;
 323         entry->cond = &cond;
 324         entry->next = cached_thread_root;
 325         cached_thread_root = entry;
 326
 327         pthread_cond_timedwait(&cond, &thread_cache_lock, &ts);
 328
 329         {
 330             struct cached_thread_entry *e = cached_thread_root;
 331             struct cached_thread_entry *prev = cached_thread_root;
 332
 333             while (e) {
 334                 if (e == entry) {
 335                     if (prev == cached_thread_root) {
 336                         cached_thread_root = e->next;
 337                     }
 338                     else {
 339                         prev->next = e->next;
 340                     }
 341                     break;
 342                 }
 343                 prev = e;
 344                 e = e->next;
 345             }
 346         }
 347
 348         free(entry); /* ok */
 349         pthread_cond_destroy(&cond);
 350     }
 351     pthread_mutex_unlock(&thread_cache_lock);
 352
 353     return (rb_thread_t *)th_area;
 354 }
 355 #endif
 356
 357 static int
 358 use_cached_thread(rb_thread_t *th)
 359 {
 360     int result = 0;
 361 #if USE_THREAD_CACHE
 362     struct cached_thread_entry *entry;
 363
 364     if (cached_thread_root) {
 365         pthread_mutex_lock(&thread_cache_lock);
 366         entry = cached_thread_root;
 367         {
 368             if (cached_thread_root) {
 369                 cached_thread_root = entry->next;
 370                 *entry->th_area = th;
 371                 result = 1;
 372             }
 373         }
 374         if (result) {
 375             pthread_cond_signal(entry->cond);
 376         }
 377         pthread_mutex_unlock(&thread_cache_lock);
 378     }
 379 #endif
 380     return result;
 381 }
 382
 383 static int
 384 native_thread_create(rb_thread_t *th)
 385 {
 386     int err = 0;
 387
 388     if (use_cached_thread(th)) {
 389         thread_debug("create (use cached thread): %p\n", th);
 390     }
 391     else {
 392         pthread_attr_t attr;
 393         size_t stack_size = 512 * 1024; /* 512KB */
 394         size_t space;
 395
 396 #ifdef PTHREAD_STACK_MIN
 397         if (stack_size < PTHREAD_STACK_MIN) {
 398             stack_size = PTHREAD_STACK_MIN * 2;
 399         }
 400 #endif
 401         space = stack_size/5;
 402         if (space > 1024*1024) space = 1024*1024;
 403         th->machine_stack_maxsize = stack_size - space;
 404 #ifdef __ia64
 405         th->machine_stack_maxsize /= 2;
 406         th->machine_register_stack_maxsize = th->machine_stack_maxsize;
 407 #endif
 408
 409         CHECK_ERR(pthread_attr_init(&attr));
 410
 411 #ifdef PTHREAD_STACK_MIN
 412         thread_debug("create - stack size: %lu\n", (unsigned long)stack_size);
 413         CHECK_ERR(pthread_attr_setstacksize(&attr, stack_size));
 414 #endif
 415
 416 #ifdef HAVE_PTHREAD_ATTR_SETINHERITSCHED
 417         CHECK_ERR(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED));
 418 #endif
 419         CHECK_ERR(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
 420
 421         err = pthread_create(&th->thread_id, &attr, thread_start_func_1, th);
 422         thread_debug("create: %p (%d)", th, err);
 423         CHECK_ERR(pthread_attr_destroy(&attr));
 424
 425         if (!err) {
 426             pthread_cond_init(&th->native_thread_data.sleep_cond, 0);
 427         }
 428         else {
 429             st_delete_wrap(th->vm->living_threads, th->self);
 430             th->status = THREAD_KILLED;
 431             rb_raise(rb_eThreadError, "can't create Thread (%d)", err);
 432         }
 433     }
 434     return err;
 435 }
 436
 437 static void
 438 native_thread_join(pthread_t th)
 439 {
 440     int err = pthread_join(th, 0);
 441     if (err) {
 442         rb_raise(rb_eThreadError, "native_thread_join() failed (%d)", err);
 443     }
 444 }
 445
 446 static void
 447 native_thread_apply_priority(rb_thread_t *th)
 448 {
 449 #if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING > 0)
 450     struct sched_param sp;
 451     int policy;
 452     int priority = 0 - th->priority;
 453     int max, min;
 454     pthread_getschedparam(th->thread_id, &policy, &sp);
 455     max = sched_get_priority_max(policy);
 456     min = sched_get_priority_min(policy);
 457
 458     if (min > priority) {
 459         priority = min;
 460     }
 461     else if (max < priority) {
 462         priority = max;
 463     }
 464
 465     sp.sched_priority = priority;
 466     pthread_setschedparam(th->thread_id, policy, &sp);
 467 #else
 468     /* not touched */
 469 #endif
 470 }
 471
 472 static void
 473 ubf_pthread_cond_signal(void *ptr)
 474 {
 475     rb_thread_t *th = (rb_thread_t *)ptr;
 476     thread_debug("ubf_pthread_cond_signal (%p)\n", th);
 477     pthread_cond_signal(&th->native_thread_data.sleep_cond);
 478 }
 479
 480 #ifndef __CYGWIN__
 481 static void
 482 ubf_select_each(rb_thread_t *th)
 483 {
 484     thread_debug("ubf_select_each (%p)\n", (void *)th->thread_id);
 485     if (th) {
 486         pthread_kill(th->thread_id, SIGVTALRM);
 487     }
 488 }
 489
 490 static void
 491 ubf_select(void *ptr)
 492 {
 493     rb_thread_t *th = (rb_thread_t *)ptr;
 494     add_signal_thread_list(th);
 495     ubf_select_each(th);
 496 }
 497 #else
 498 #define ubf_select 0
 499 #endif
 500
 501 static void
 502 native_sleep(rb_thread_t *th, struct timeval *tv)
 503 {
 504     struct timespec ts;
 505     struct timeval tvn;
 506
 507     if (tv) {
 508         gettimeofday(&tvn, NULL);
 509         ts.tv_sec = tvn.tv_sec + tv->tv_sec;
 510         ts.tv_nsec = (tvn.tv_usec + tv->tv_usec) * 1000;
 511         if (ts.tv_nsec >= 1000000000){
 512             ts.tv_sec += 1;
 513             ts.tv_nsec -= 1000000000;
 514         }
 515     }
 516
 517     thread_debug("native_sleep %ld\n", tv ? tv->tv_sec : -1);
 518     GVL_UNLOCK_BEGIN();
 519     {
 520         pthread_mutex_lock(&th->interrupt_lock);
 521         th->unblock.func = ubf_pthread_cond_signal;
 522         th->unblock.arg = th;
 523
 524         if (RUBY_VM_INTERRUPTED(th)) {
 525             /* interrupted.  return immediate */
 526             thread_debug("native_sleep: interrupted before sleep\n");
 527         }
 528         else {
 529             if (tv == 0 || ts.tv_sec < tvn.tv_sec /* overflow */ ) {
 530                 int r;
 531                 thread_debug("native_sleep: pthread_cond_wait start\n");
 532                 r = pthread_cond_wait(&th->native_thread_data.sleep_cond,
 533                                   &th->interrupt_lock);
 534                 if (r) rb_bug("pthread_cond_wait: %d", r);
 535                 thread_debug("native_sleep: pthread_cond_wait end\n");
 536             }
 537             else {
 538                 int r;
 539                 thread_debug("native_sleep: pthread_cond_timedwait start (%ld, %ld)\n",
 540                              (unsigned long)ts.tv_sec, ts.tv_nsec);
 541                 r = pthread_cond_timedwait(&th->native_thread_data.sleep_cond,
 542                                            &th->interrupt_lock, &ts);
 543                 if (r && r != ETIMEDOUT) rb_bug("pthread_cond_timedwait: %d", r);
 544
 545                 thread_debug("native_sleep: pthread_cond_timedwait end (%d)\n", r);
 546             }
 547         }
 548         th->unblock.func = 0;
 549         th->unblock.arg = 0;
 550
 551         pthread_mutex_unlock(&th->interrupt_lock);
 552     }
 553     GVL_UNLOCK_END();
 554
 555     thread_debug("native_sleep done\n");
 556 }
 557
 558 struct signal_thread_list {
 559     rb_thread_t *th;
 560     struct signal_thread_list *prev;
 561     struct signal_thread_list *next;
 562 };
 563
 564 #ifndef __CYGWIN__
 565 static struct signal_thread_list signal_thread_list_anchor = {
 566     0, 0, 0,
 567 };
 568 #endif
 569
 570 #define FGLOCK(lock, body) do { \
 571     native_mutex_lock(lock); \
 572     { \
 573         body; \
 574     } \
 575     native_mutex_unlock(lock); \
 576 } while (0)
 577
 578 #if 0 /* for debug */
 579 static void
 580 print_signal_list(char *str)
 581 {
 582     struct signal_thread_list *list =
 583       signal_thread_list_anchor.next;
 584     thread_debug("list (%s)> ", str);
 585     while(list){
 586         thread_debug("%p (%p), ", list->th, list->th->thread_id);
 587         list = list->next;
 588     }
 589     thread_debug("\n");
 590 }
 591 #endif
 592
 593 #ifndef __CYGWIN__
 594 static void
 595 add_signal_thread_list(rb_thread_t *th)
 596 {
 597     if (!th->native_thread_data.signal_thread_list) {
 598         FGLOCK(&signal_thread_list_lock, {
 599             struct signal_thread_list *list =
 600               malloc(sizeof(struct signal_thread_list));
 601
 602             if (list == 0) {
 603                 fprintf(stderr, "[FATAL] failed to allocate memory\n");
 604                 exit(1);
 605             }
 606
 607             list->th = th;
 608
 609             list->prev = &signal_thread_list_anchor;
 610             list->next = signal_thread_list_anchor.next;
 611             if (list->next) {
 612                 list->next->prev = list;
 613             }
 614             signal_thread_list_anchor.next = list;
 615             th->native_thread_data.signal_thread_list = list;
 616         });
 617     }
 618 }
 619 #endif
 620
 621 static void
 622 remove_signal_thread_list(rb_thread_t *th)
 623 {
 624     if (th->native_thread_data.signal_thread_list) {
 625         FGLOCK(&signal_thread_list_lock, {
 626             struct signal_thread_list *list =
 627               (struct signal_thread_list *)
 628                 th->native_thread_data.signal_thread_list;
 629
 630             list->prev->next = list->next;
 631             if (list->next) {
 632                 list->next->prev = list->prev;
 633             }
 634             th->native_thread_data.signal_thread_list = 0;
 635             list->th = 0;
 636             free(list); /* ok */
 637         });
 638     }
 639     else {
 640         /* */
 641     }
 642 }
 643
 644 static pthread_t timer_thread_id;
 645
 646 static void *
 647 thread_timer(void *dummy)
 648 {
 649     while (system_working) {
 650 #ifdef HAVE_NANOSLEEP
 651         struct timespec req, rem;
 652         req.tv_sec = 0;
 653         req.tv_nsec = 10 * 1000 * 1000; /* 10 ms */
 654         nanosleep(&req, &rem);
 655 #else
 656         struct timeval tv;
 657         tv.tv_sec = 0;
 658         tv.tv_usec = 10000;             /* 10 ms */
 659         select(0, NULL, NULL, NULL, &tv);
 660 #endif
 661 #ifndef __CYGWIN__
 662         if (signal_thread_list_anchor.next) {
 663             FGLOCK(&signal_thread_list_lock, {
 664                 struct signal_thread_list *list;
 665                 list = signal_thread_list_anchor.next;
 666                 while (list) {
 667                     ubf_select_each(list->th);
 668                     list = list->next;
 669                 }
 670             });
 671         }
 672 #endif
 673         timer_thread_function(dummy);
 674     }
 675     return NULL;
 676 }
 677
 678 static void
 679 rb_thread_create_timer_thread(void)
 680 {
 681     rb_enable_interrupt();
 682
 683     if (!timer_thread_id) {
 684         pthread_attr_t attr;
 685         int err;
 686
 687         pthread_attr_init(&attr);
 688 #ifdef PTHREAD_STACK_MIN
 689         pthread_attr_setstacksize(&attr,
 690                                   PTHREAD_STACK_MIN + (THREAD_DEBUG ? BUFSIZ : 0));
 691 #endif
 692         err = pthread_create(&timer_thread_id, &attr, thread_timer, GET_VM());
 693         if (err != 0) {
 694             rb_bug("rb_thread_create_timer_thread: return non-zero (%d)", err);
 695         }
 696     }
 697     rb_disable_interrupt(); /* only timer thread recieve signal */
 698 }
 699
 700 #endif /* THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION */