diff options
author | yugui <yugui@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2008-08-25 15:13:14 +0000 |
---|---|---|
committer | yugui <yugui@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2008-08-25 15:13:14 +0000 |
commit | d0233291bc8a5068e52c69c210e5979e5324b5bc (patch) | |
tree | 7d9459449c33792c63eeb7baa071e76352e0baab /trunk/thread_pthread.c | |
parent | 0dc342de848a642ecce8db697b8fecd83a63e117 (diff) | |
parent | 72eaacaa15256ab95c3b52ea386f88586fb9da40 (diff) |
re-adding tag v1_9_0_4 as an alias of trunk@18848v1_9_0_4
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_9_0_4@18849 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'trunk/thread_pthread.c')
-rw-r--r-- | trunk/thread_pthread.c | 705 |
1 files changed, 0 insertions, 705 deletions
diff --git a/trunk/thread_pthread.c b/trunk/thread_pthread.c deleted file mode 100644 index 0f8214416a..0000000000 --- a/trunk/thread_pthread.c +++ /dev/null @@ -1,705 +0,0 @@ -/* -*-c-*- */ -/********************************************************************** - - thread_pthread.c - - - $Author$ - - Copyright (C) 2004-2007 Koichi Sasada - -**********************************************************************/ - -#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION - -#include "gc.h" - -#ifdef HAVE_SYS_RESOURCE_H -#include <sys/resource.h> -#endif - -static void native_mutex_lock(pthread_mutex_t *lock); -static void native_mutex_unlock(pthread_mutex_t *lock); -static int native_mutex_trylock(pthread_mutex_t *lock); -static void native_mutex_initialize(pthread_mutex_t *lock); -static void native_mutex_destroy(pthread_mutex_t *lock); - -static void native_cond_signal(pthread_cond_t *cond); -static void native_cond_broadcast(pthread_cond_t *cond); -static void native_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); -static void native_cond_initialize(pthread_cond_t *cond); -static void native_cond_destroy(pthread_cond_t *cond); - -static void -native_mutex_lock(pthread_mutex_t *lock) -{ - int r; - if ((r = pthread_mutex_lock(lock)) != 0) { - rb_bug("pthread_mutex_lock: %d", r); - } -} - -static void -native_mutex_unlock(pthread_mutex_t *lock) -{ - int r; - if ((r = pthread_mutex_unlock(lock)) != 0) { - rb_bug("native_mutex_unlock return non-zero: %d", r); - } -} - -static inline int -native_mutex_trylock(pthread_mutex_t *lock) -{ - int r; - if ((r = pthread_mutex_trylock(lock)) != 0) { - if (r == EBUSY) { - return EBUSY; - } - else { - rb_bug("native_mutex_trylock return non-zero: %d", r); - } - } - return 0; -} - -static void -native_mutex_initialize(pthread_mutex_t *lock) -{ - int r = pthread_mutex_init(lock, 0); - if (r != 0) { - rb_bug("native_mutex_initialize return non-zero: %d", r); - } -} - -static void -native_mutex_destroy(pthread_mutex_t *lock) -{ - int r = pthread_mutex_destroy(lock); - if (r != 0) { - rb_bug("native_mutex_destroy return non-zero: %d", r); - } -} - -static void -native_cond_initialize(pthread_cond_t *cond) -{ - int r = pthread_cond_init(cond, 0); - if (r != 0) { - rb_bug("native_cond_initialize return non-zero: %d", r); - } -} - -static void -native_cond_destroy(pthread_cond_t *cond) -{ - int r = pthread_cond_destroy(cond); - if (r != 0) { - rb_bug("native_cond_destroy return non-zero: %d", r); - } -} - -static void -native_cond_signal(pthread_cond_t *cond) -{ - pthread_cond_signal(cond); -} - -static void -native_cond_broadcast(pthread_cond_t *cond) -{ - pthread_cond_broadcast(cond); -} - -static void -native_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) -{ - pthread_cond_wait(cond, mutex); -} - - -#define native_cleanup_push pthread_cleanup_push -#define native_cleanup_pop pthread_cleanup_pop -#ifdef HAVE_SCHED_YIELD -#define native_thread_yield() (void)sched_yield() -#else -#define native_thread_yield() ((void)0) -#endif - -#ifndef __CYGWIN__ -static void add_signal_thread_list(rb_thread_t *th); -#endif -static void remove_signal_thread_list(rb_thread_t *th); - -static rb_thread_lock_t signal_thread_list_lock; - -static pthread_key_t ruby_native_thread_key; - -static void -null_func(int i) -{ - /* null */ -} - -static rb_thread_t * -ruby_thread_from_native(void) -{ - return pthread_getspecific(ruby_native_thread_key); -} - -static int -ruby_thread_set_native(rb_thread_t *th) -{ - return pthread_setspecific(ruby_native_thread_key, th) == 0; -} - -static void -Init_native_thread(void) -{ - rb_thread_t *th = GET_THREAD(); - - pthread_key_create(&ruby_native_thread_key, NULL); - th->thread_id = pthread_self(); - native_cond_initialize(&th->native_thread_data.sleep_cond); - ruby_thread_set_native(th); - native_mutex_initialize(&signal_thread_list_lock); - posix_signal(SIGVTALRM, null_func); -} - -static void -native_thread_destroy(rb_thread_t *th) -{ - pthread_mutex_destroy(&th->interrupt_lock); - pthread_cond_destroy(&th->native_thread_data.sleep_cond); -} - -#define USE_THREAD_CACHE 0 - -static struct { - rb_thread_id_t id; - size_t stack_maxsize; - VALUE *stack_start; -#ifdef __ia64 - VALUE *register_stack_start; -#endif -} native_main_thread; - -#ifdef STACK_END_ADDRESS -extern void *STACK_END_ADDRESS; -#endif - -#undef ruby_init_stack -void -ruby_init_stack(VALUE *addr -#ifdef __ia64 - , void *bsp -#endif - ) -{ - native_main_thread.id = pthread_self(); -#ifdef STACK_END_ADDRESS - native_main_thread.stack_start = STACK_END_ADDRESS; -#else - if (!native_main_thread.stack_start || - STACK_UPPER(&addr, - native_main_thread.stack_start > addr, - native_main_thread.stack_start < addr)) { - native_main_thread.stack_start = addr; - } -#endif -#ifdef __ia64 - if (!native_main_thread.register_stack_start || - (VALUE*)bsp < native_main_thread.register_stack_start) { - native_main_thread.register_stack_start = (VALUE*)bsp; - } -#endif -#ifdef HAVE_GETRLIMIT - { - struct rlimit rlim; - - if (getrlimit(RLIMIT_STACK, &rlim) == 0) { - unsigned int space = rlim.rlim_cur/5; - - if (space > 1024*1024) space = 1024*1024; - native_main_thread.stack_maxsize = rlim.rlim_cur - space; - } - } -#endif -} - -#define CHECK_ERR(expr) \ - {int err = (expr); if (err) {rb_bug("err: %d - %s", err, #expr);}} - -static int -native_thread_init_stack(rb_thread_t *th) -{ - rb_thread_id_t curr = pthread_self(); - - if (pthread_equal(curr, native_main_thread.id)) { - th->machine_stack_start = native_main_thread.stack_start; - th->machine_stack_maxsize = native_main_thread.stack_maxsize; - } - else { -#ifdef HAVE_PTHREAD_GETATTR_NP - pthread_attr_t attr; - void *start; - CHECK_ERR(pthread_getattr_np(curr, &attr)); -# if defined HAVE_PTHREAD_ATTR_GETSTACK - CHECK_ERR(pthread_attr_getstack(&attr, &start, &th->machine_stack_maxsize)); -# elif defined HAVE_PTHREAD_ATTR_GETSTACKSIZE && defined HAVE_PTHREAD_ATTR_GETSTACKADDR - CHECK_ERR(pthread_attr_getstackaddr(&attr, &start)); - CHECK_ERR(pthread_attr_getstacksize(&attr, &th->machine_stack_maxsize)); -# endif - th->machine_stack_start = start; -#else - rb_raise(rb_eNotImpError, "ruby engine can initialize only in the main thread"); -#endif - } -#ifdef __ia64 - th->machine_register_stack_start = native_main_thread.register_stack_start; - th->machine_stack_maxsize /= 2; - th->machine_register_stack_maxsize = th->machine_stack_maxsize; -#endif - return 0; -} - -static void * -thread_start_func_1(void *th_ptr) -{ -#if USE_THREAD_CACHE - thread_start: -#endif - { - rb_thread_t *th = th_ptr; - VALUE stack_start; - - /* run */ - thread_start_func_2(th, &stack_start, rb_ia64_bsp()); - } -#if USE_THREAD_CACHE - if (1) { - /* cache thread */ - rb_thread_t *th; - static rb_thread_t *register_cached_thread_and_wait(void); - if ((th = register_cached_thread_and_wait()) != 0) { - th_ptr = (void *)th; - th->thread_id = pthread_self(); - goto thread_start; - } - } -#endif - return 0; -} - -void rb_thread_create_control_thread(void); - -struct cached_thread_entry { - volatile rb_thread_t **th_area; - pthread_cond_t *cond; - struct cached_thread_entry *next; -}; - - -#if USE_THREAD_CACHE -static pthread_mutex_t thread_cache_lock = PTHREAD_MUTEX_INITIALIZER; -struct cached_thread_entry *cached_thread_root; - -static rb_thread_t * -register_cached_thread_and_wait(void) -{ - pthread_cond_t cond = PTHREAD_COND_INITIALIZER; - volatile rb_thread_t *th_area = 0; - struct cached_thread_entry *entry = - (struct cached_thread_entry *)malloc(sizeof(struct cached_thread_entry)); - - struct timeval tv; - struct timespec ts; - gettimeofday(&tv, 0); - ts.tv_sec = tv.tv_sec + 60; - ts.tv_nsec = tv.tv_usec * 1000; - - pthread_mutex_lock(&thread_cache_lock); - { - entry->th_area = &th_area; - entry->cond = &cond; - entry->next = cached_thread_root; - cached_thread_root = entry; - - pthread_cond_timedwait(&cond, &thread_cache_lock, &ts); - - { - struct cached_thread_entry *e = cached_thread_root; - struct cached_thread_entry *prev = cached_thread_root; - - while (e) { - if (e == entry) { - if (prev == cached_thread_root) { - cached_thread_root = e->next; - } - else { - prev->next = e->next; - } - break; - } - prev = e; - e = e->next; - } - } - - free(entry); /* ok */ - pthread_cond_destroy(&cond); - } - pthread_mutex_unlock(&thread_cache_lock); - - return (rb_thread_t *)th_area; -} -#endif - -static int -use_cached_thread(rb_thread_t *th) -{ - int result = 0; -#if USE_THREAD_CACHE - struct cached_thread_entry *entry; - - if (cached_thread_root) { - pthread_mutex_lock(&thread_cache_lock); - entry = cached_thread_root; - { - if (cached_thread_root) { - cached_thread_root = entry->next; - *entry->th_area = th; - result = 1; - } - } - if (result) { - pthread_cond_signal(entry->cond); - } - pthread_mutex_unlock(&thread_cache_lock); - } -#endif - return result; -} - -static int -native_thread_create(rb_thread_t *th) -{ - int err = 0; - - if (use_cached_thread(th)) { - thread_debug("create (use cached thread): %p\n", th); - } - else { - pthread_attr_t attr; - size_t stack_size = 512 * 1024; /* 512KB */ - size_t space; - -#ifdef PTHREAD_STACK_MIN - if (stack_size < PTHREAD_STACK_MIN) { - stack_size = PTHREAD_STACK_MIN * 2; - } -#endif - space = stack_size/5; - if (space > 1024*1024) space = 1024*1024; - th->machine_stack_maxsize = stack_size - space; -#ifdef __ia64 - th->machine_stack_maxsize /= 2; - th->machine_register_stack_maxsize = th->machine_stack_maxsize; -#endif - - CHECK_ERR(pthread_attr_init(&attr)); - -#ifdef PTHREAD_STACK_MIN - thread_debug("create - stack size: %lu\n", (unsigned long)stack_size); - CHECK_ERR(pthread_attr_setstacksize(&attr, stack_size)); -#endif - -#ifdef HAVE_PTHREAD_ATTR_SETINHERITSCHED - CHECK_ERR(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED)); -#endif - CHECK_ERR(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)); - - err = pthread_create(&th->thread_id, &attr, thread_start_func_1, th); - thread_debug("create: %p (%d)", th, err); - CHECK_ERR(pthread_attr_destroy(&attr)); - - if (!err) { - pthread_cond_init(&th->native_thread_data.sleep_cond, 0); - } - else { - st_delete_wrap(th->vm->living_threads, th->self); - th->status = THREAD_KILLED; - rb_raise(rb_eThreadError, "can't create Thread (%d)", err); - } - } - return err; -} - -static void -native_thread_join(pthread_t th) -{ - int err = pthread_join(th, 0); - if (err) { - rb_raise(rb_eThreadError, "native_thread_join() failed (%d)", err); - } -} - - -#if USE_NATIVE_THREAD_PRIORITY - -static void -native_thread_apply_priority(rb_thread_t *th) -{ -#if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING > 0) - struct sched_param sp; - int policy; - int priority = 0 - th->priority; - int max, min; - pthread_getschedparam(th->thread_id, &policy, &sp); - max = sched_get_priority_max(policy); - min = sched_get_priority_min(policy); - - if (min > priority) { - priority = min; - } - else if (max < priority) { - priority = max; - } - - sp.sched_priority = priority; - pthread_setschedparam(th->thread_id, policy, &sp); -#else - /* not touched */ -#endif -} - -#endif /* USE_NATIVE_THREAD_PRIORITY */ - -static void -ubf_pthread_cond_signal(void *ptr) -{ - rb_thread_t *th = (rb_thread_t *)ptr; - thread_debug("ubf_pthread_cond_signal (%p)\n", th); - pthread_cond_signal(&th->native_thread_data.sleep_cond); -} - -#ifndef __CYGWIN__ -static void -ubf_select_each(rb_thread_t *th) -{ - thread_debug("ubf_select_each (%p)\n", (void *)th->thread_id); - if (th) { - pthread_kill(th->thread_id, SIGVTALRM); - } -} - -static void -ubf_select(void *ptr) -{ - rb_thread_t *th = (rb_thread_t *)ptr; - add_signal_thread_list(th); - ubf_select_each(th); -} -#else -#define ubf_select 0 -#endif - -static void -native_sleep(rb_thread_t *th, struct timeval *tv) -{ - struct timespec ts; - struct timeval tvn; - - if (tv) { - gettimeofday(&tvn, NULL); - ts.tv_sec = tvn.tv_sec + tv->tv_sec; - ts.tv_nsec = (tvn.tv_usec + tv->tv_usec) * 1000; - if (ts.tv_nsec >= 1000000000){ - ts.tv_sec += 1; - ts.tv_nsec -= 1000000000; - } - } - - thread_debug("native_sleep %ld\n", tv ? tv->tv_sec : -1); - GVL_UNLOCK_BEGIN(); - { - pthread_mutex_lock(&th->interrupt_lock); - th->unblock.func = ubf_pthread_cond_signal; - th->unblock.arg = th; - - if (RUBY_VM_INTERRUPTED(th)) { - /* interrupted. return immediate */ - thread_debug("native_sleep: interrupted before sleep\n"); - } - else { - if (tv == 0 || ts.tv_sec < tvn.tv_sec /* overflow */ ) { - int r; - thread_debug("native_sleep: pthread_cond_wait start\n"); - r = pthread_cond_wait(&th->native_thread_data.sleep_cond, - &th->interrupt_lock); - if (r) rb_bug("pthread_cond_wait: %d", r); - thread_debug("native_sleep: pthread_cond_wait end\n"); - } - else { - int r; - thread_debug("native_sleep: pthread_cond_timedwait start (%ld, %ld)\n", - (unsigned long)ts.tv_sec, ts.tv_nsec); - r = pthread_cond_timedwait(&th->native_thread_data.sleep_cond, - &th->interrupt_lock, &ts); - if (r && r != ETIMEDOUT) rb_bug("pthread_cond_timedwait: %d", r); - - thread_debug("native_sleep: pthread_cond_timedwait end (%d)\n", r); - } - } - th->unblock.func = 0; - th->unblock.arg = 0; - - pthread_mutex_unlock(&th->interrupt_lock); - } - GVL_UNLOCK_END(); - - thread_debug("native_sleep done\n"); -} - -struct signal_thread_list { - rb_thread_t *th; - struct signal_thread_list *prev; - struct signal_thread_list *next; -}; - -#ifndef __CYGWIN__ -static struct signal_thread_list signal_thread_list_anchor = { - 0, 0, 0, -}; -#endif - -#define FGLOCK(lock, body) do { \ - native_mutex_lock(lock); \ - { \ - body; \ - } \ - native_mutex_unlock(lock); \ -} while (0) - -#if 0 /* for debug */ -static void -print_signal_list(char *str) -{ - struct signal_thread_list *list = - signal_thread_list_anchor.next; - thread_debug("list (%s)> ", str); - while(list){ - thread_debug("%p (%p), ", list->th, list->th->thread_id); - list = list->next; - } - thread_debug("\n"); -} -#endif - -#ifndef __CYGWIN__ -static void -add_signal_thread_list(rb_thread_t *th) -{ - if (!th->native_thread_data.signal_thread_list) { - FGLOCK(&signal_thread_list_lock, { - struct signal_thread_list *list = - malloc(sizeof(struct signal_thread_list)); - - if (list == 0) { - fprintf(stderr, "[FATAL] failed to allocate memory\n"); - exit(1); - } - - list->th = th; - - list->prev = &signal_thread_list_anchor; - list->next = signal_thread_list_anchor.next; - if (list->next) { - list->next->prev = list; - } - signal_thread_list_anchor.next = list; - th->native_thread_data.signal_thread_list = list; - }); - } -} -#endif - -static void -remove_signal_thread_list(rb_thread_t *th) -{ - if (th->native_thread_data.signal_thread_list) { - FGLOCK(&signal_thread_list_lock, { - struct signal_thread_list *list = - (struct signal_thread_list *) - th->native_thread_data.signal_thread_list; - - list->prev->next = list->next; - if (list->next) { - list->next->prev = list->prev; - } - th->native_thread_data.signal_thread_list = 0; - list->th = 0; - free(list); /* ok */ - }); - } - else { - /* */ - } -} - -static pthread_t timer_thread_id; - -static void * -thread_timer(void *dummy) -{ - while (system_working) { -#ifdef HAVE_NANOSLEEP - struct timespec req, rem; - req.tv_sec = 0; - req.tv_nsec = 10 * 1000 * 1000; /* 10 ms */ - nanosleep(&req, &rem); -#else - struct timeval tv; - tv.tv_sec = 0; - tv.tv_usec = 10000; /* 10 ms */ - select(0, NULL, NULL, NULL, &tv); -#endif -#ifndef __CYGWIN__ - if (signal_thread_list_anchor.next) { - FGLOCK(&signal_thread_list_lock, { - struct signal_thread_list *list; - list = signal_thread_list_anchor.next; - while (list) { - ubf_select_each(list->th); - list = list->next; - } - }); - } -#endif - timer_thread_function(dummy); - } - return NULL; -} - -static void -rb_thread_create_timer_thread(void) -{ - rb_enable_interrupt(); - - if (!timer_thread_id) { - pthread_attr_t attr; - int err; - - pthread_attr_init(&attr); -#ifdef PTHREAD_STACK_MIN - pthread_attr_setstacksize(&attr, - PTHREAD_STACK_MIN + (THREAD_DEBUG ? BUFSIZ : 0)); -#endif - err = pthread_create(&timer_thread_id, &attr, thread_timer, GET_VM()); - if (err != 0) { - rb_bug("rb_thread_create_timer_thread: return non-zero (%d)", err); - } - } - rb_disable_interrupt(); /* only timer thread recieve signal */ -} - -#endif /* THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION */ |