ruby-106/ruby/thread_pthread.c

105 gvl_acquire(rb_vm_t *vm, rb_thread_t *th)
129 gvl_yield(rb_vm_t *vm, rb_thread_t *th)
438 static void add_signal_thread_list(rb_thread_t *th);
439 static void remove_signal_thread_list(rb_thread_t *th);
458 ruby_thread_set_native(rb_thread_t *th)
460     return pthread_setspecific(ruby_native_thread_key, th) == 0;
463 static void native_thread_init(rb_thread_t *th);
468     rb_thread_t *th = GET_THREAD();
471     th->thread_id = pthread_self();
472     native_thread_init(th);
482 native_thread_init(rb_thread_t *th)
484     native_cond_initialize(&th->native_thread_data.sleep_cond, RB_CONDATTR_CLOCK_MONOTONIC);
485     ruby_thread_set_native(th);
489 native_thread_destroy(rb_thread_t *th)
491     native_cond_destroy(&th->native_thread_data.sleep_cond);
562     pthread_t th = pthread_self();
563     *addr = pthread_get_stackaddr_np(th);
564     *size = pthread_get_stacksize_np(th);
575     pthread_t th = pthread_self();
579     CHECK_ERR(pthread_getthrds_np(&th, PTHRDSINFO_QUERY_ALL,
714 native_thread_init_stack(rb_thread_t *th)
719 	th->machine_stack_start = native_main_thread.stack_start;
720 	th->machine_stack_maxsize = native_main_thread.stack_maxsize;
728 	    th->machine_stack_start = start;
729 	    th->machine_stack_maxsize = size;
736     th->machine_register_stack_start = native_main_thread.register_stack_start;
737     th->machine_stack_maxsize /= 2;
738     th->machine_register_stack_maxsize = th->machine_stack_maxsize;
754 	rb_thread_t *th = th_ptr;
760 	native_thread_init_stack(th);
762 	native_thread_init(th);
765 	thread_start_func_2(th, th->machine_stack_start, rb_ia64_bsp());
767 	thread_start_func_2(th, &stack_start, rb_ia64_bsp());
773 	rb_thread_t *th;
774 	if ((th = register_cached_thread_and_wait()) != 0) {
775 	    th_ptr = (void *)th;
776 	    th->thread_id = pthread_self();
851 use_cached_thread(rb_thread_t *th)
863 		*entry->th_area = th;
877 native_thread_create(rb_thread_t *th)
881     if (use_cached_thread(th)) {
882 	thread_debug("create (use cached thread): %p\n", (void *)th);
886 	const size_t stack_size = th->vm->default_params.thread_machine_stack_size;
889         th->machine_stack_maxsize = stack_size - space;
891         th->machine_stack_maxsize /= 2;
892         th->machine_register_stack_maxsize = th->machine_stack_maxsize;
908 	err = pthread_create(&th->thread_id, &attr, thread_start_func_1, th);
910 	err = pthread_create(&th->thread_id, NULL, thread_start_func_1, th);
912 	thread_debug("create: %p (%d)\n", (void *)th, err);
921 native_thread_join(pthread_t th)
923     int err = pthread_join(th, 0);
933 native_thread_apply_priority(rb_thread_t *th)
938     int priority = 0 - th->priority;
940     pthread_getschedparam(th->thread_id, &policy, &sp);
952     pthread_setschedparam(th->thread_id, policy, &sp);
961 native_fd_select(int n, rb_fdset_t *readfds, rb_fdset_t *writefds, rb_fdset_t *exceptfds, struct timeval *timeout, rb_thread_t *th)
969     rb_thread_t *th = (rb_thread_t *)ptr;
970     thread_debug("ubf_pthread_cond_signal (%p)\n", (void *)th);
971     native_cond_signal(&th->native_thread_data.sleep_cond);
975 native_sleep(rb_thread_t *th, struct timeval *timeout_tv)
978     pthread_mutex_t *lock = &th->interrupt_lock;
979     rb_thread_cond_t *cond = &th->native_thread_data.sleep_cond;
1006 	th->unblock.func = ubf_pthread_cond_signal;
1007 	th->unblock.arg = th;
1009 	if (RUBY_VM_INTERRUPTED(th)) {
1019 	th->unblock.func = 0;
1020 	th->unblock.arg = 0;
1031     rb_thread_t *th;
1056 	thread_debug("%p (%p), ", list->th, list->th->thread_id);
1064 add_signal_thread_list(rb_thread_t *th)
1066     if (!th->native_thread_data.signal_thread_list) {
1076 	    list->th = th;
1084 	    th->native_thread_data.signal_thread_list = list;
1090 remove_signal_thread_list(rb_thread_t *th)
1092     if (th->native_thread_data.signal_thread_list) {
1096 		th->native_thread_data.signal_thread_list;
1102 	    th->native_thread_data.signal_thread_list = 0;
1103 	    list->th = 0;
1110 ubf_select_each(rb_thread_t *th)
1112     thread_debug("ubf_select_each (%p)\n", (void *)th->thread_id);
1113     if (th) {
1114 	pthread_kill(th->thread_id, SIGVTALRM);
1121     rb_thread_t *th = (rb_thread_t *)ptr;
1122     add_signal_thread_list(th);
1125     ubf_select_each(th);
1137 		ubf_select_each(list->th);
1153 #define add_signal_thread_list(th) (void)(th)
1154 #define remove_signal_thread_list(th) (void)(th)
1497 ruby_stack_overflowed_p(const rb_thread_t *th, const void *addr)
1504     if (th) {
1505 	size = th->machine_stack_maxsize;
1506 	base = (char *)th->machine_stack_start - STACK_DIR_UPPER(0, size);