diff options
author | yugui <yugui@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2008-08-25 15:02:05 +0000 |
---|---|---|
committer | yugui <yugui@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2008-08-25 15:02:05 +0000 |
commit | 0dc342de848a642ecce8db697b8fecd83a63e117 (patch) | |
tree | 2b7ed4724aff1f86073e4740134bda9c4aac1a39 /trunk/thread_pthread.c | |
parent | ef70cf7138ab8034b5b806f466e4b484b24f0f88 (diff) |
added tag v1_9_0_4
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_9_0_4@18845 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'trunk/thread_pthread.c')
-rw-r--r-- | trunk/thread_pthread.c | 705 |
1 files changed, 705 insertions, 0 deletions
diff --git a/trunk/thread_pthread.c b/trunk/thread_pthread.c new file mode 100644 index 0000000000..0f8214416a --- /dev/null +++ b/trunk/thread_pthread.c @@ -0,0 +1,705 @@ +/* -*-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 */ |