diff options
Diffstat (limited to 'thread_win32.c')
| -rw-r--r-- | thread_win32.c | 508 |
1 files changed, 508 insertions, 0 deletions
diff --git a/thread_win32.c b/thread_win32.c new file mode 100644 index 0000000000..d8b33e23e0 --- /dev/null +++ b/thread_win32.c @@ -0,0 +1,508 @@ +/* -*-c-*- */ +/********************************************************************** + + thread_win32.c - + + $Author$ + $Date$ + + Copyright (C) 2004-2007 Koichi Sasada + +**********************************************************************/ + +#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION + +#include <process.h> + +#define WIN32_WAIT_TIMEOUT 10 /* 10 ms */ +#undef Sleep + +#define native_thread_yield() Sleep(0) +#define remove_signal_thread_list(th) + +static volatile DWORD ruby_native_thread_key = TLS_OUT_OF_INDEXES; + +static rb_thread_t * +ruby_thread_from_native(void) +{ + return TlsGetValue(ruby_native_thread_key); +} + +static int +ruby_thread_set_native(rb_thread_t *th) +{ + return TlsSetValue(ruby_native_thread_key, th); +} + +static void +Init_native_thread(void) +{ + rb_thread_t *th = GET_THREAD(); + + ruby_native_thread_key = TlsAlloc(); + DuplicateHandle(GetCurrentProcess(), + GetCurrentThread(), + GetCurrentProcess(), + &th->thread_id, 0, FALSE, DUPLICATE_SAME_ACCESS); + + th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0); + + thread_debug("initial thread (th: %p, thid: %p, event: %p)\n", + th, GET_THREAD()->thread_id, + th->native_thread_data.interrupt_event); +} + +static void +w32_error(void) +{ + LPVOID lpMsgBuf; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPTSTR) & lpMsgBuf, 0, NULL); + rb_bug("%s", lpMsgBuf); +} + +static void +w32_set_event(HANDLE handle) +{ + if (SetEvent(handle) == 0) { + w32_error(); + } +} + +static void +w32_reset_event(HANDLE handle) +{ + if (ResetEvent(handle) == 0) { + w32_error(); + } +} + +static int +w32_wait_events(HANDLE *events, int count, DWORD timeout, rb_thread_t *th) +{ + HANDLE *targets = events; + HANDLE intr; + DWORD ret; + + thread_debug(" w32_wait_events events:%p, count:%d, timeout:%ld, th:%p\n", + events, count, timeout, th); + if (th && (intr = th->native_thread_data.interrupt_event)) { + w32_reset_event(intr); + if (th->interrupt_flag) { + w32_set_event(intr); + } + + targets = ALLOCA_N(HANDLE, count + 1); + memcpy(targets, events, sizeof(HANDLE) * count); + + targets[count++] = intr; + thread_debug(" * handle: %p (count: %d, intr)\n", intr, count); + } + + thread_debug(" WaitForMultipleObjects start (count: %d)\n", count); + ret = WaitForMultipleObjects(count, targets, FALSE, timeout); + thread_debug(" WaitForMultipleObjects end (ret: %d)\n", ret); + + if (ret == WAIT_OBJECT_0 + count - 1 && th) { + errno = EINTR; + } + if (ret == -1 && THREAD_DEBUG) { + int i; + DWORD dmy; + for (i = 0; i < count; i++) { + thread_debug(" * error handle %d - %s\n", i, + GetHandleInformation(targets[i], &dmy) ? "OK" : "NG"); + } + } + return ret; +} + +static void ubf_handle(void *ptr); +#define ubf_select ubf_handle + +int +rb_w32_wait_events_blocking(HANDLE *events, int num, DWORD timeout) +{ + return w32_wait_events(events, num, timeout, GET_THREAD()); +} + +int +rb_w32_wait_events(HANDLE *events, int num, DWORD timeout) +{ + int ret; + + BLOCKING_REGION(ret = rb_w32_wait_events_blocking(events, num, timeout), + ubf_handle, GET_THREAD()); + return ret; +} + +static void +w32_close_handle(HANDLE handle) +{ + if (CloseHandle(handle) == 0) { + w32_error(); + } +} + +static void +w32_resume_thread(HANDLE handle) +{ + if (ResumeThread(handle) == -1) { + w32_error(); + } +} + +#ifdef _MSC_VER +#define HAVE__BEGINTHREADEX 1 +#else +#undef HAVE__BEGINTHREADEX +#endif + +#ifdef HAVE__BEGINTHREADEX +#define start_thread (HANDLE)_beginthreadex +typedef unsigned long (_stdcall *w32_thread_start_func)(void*); +#else +#define start_thread CreateThread +typedef LPTHREAD_START_ROUTINE w32_thread_start_func; +#endif + +static HANDLE +w32_create_thread(DWORD stack_size, w32_thread_start_func func, void *val) +{ + return start_thread(0, stack_size, func, val, CREATE_SUSPENDED, 0); +} + +int +rb_w32_sleep(unsigned long msec) +{ + return w32_wait_events(0, 0, msec, GET_THREAD()); +} + +int WINAPI +rb_w32_Sleep(unsigned long msec) +{ + int ret; + + BLOCKING_REGION(ret = rb_w32_sleep(msec), + ubf_handle, GET_THREAD()); + return ret; +} + +static void +native_sleep(rb_thread_t *th, struct timeval *tv) +{ + DWORD msec; + if (tv) { + msec = tv->tv_sec * 1000 + tv->tv_usec / 1000; + } + else { + msec = INFINITE; + } + + GVL_UNLOCK_BEGIN(); + { + DWORD ret; + int status = th->status; + th->status = THREAD_STOPPED; + th->unblock_function = ubf_handle; + th->unblock_function_arg = th; + thread_debug("native_sleep start (%d)\n", (int)msec); + ret = w32_wait_events(0, 0, msec, th); + thread_debug("native_sleep done (%d)\n", ret); + th->unblock_function = 0; + th->unblock_function_arg = 0; + th->status = status; + } + GVL_UNLOCK_END(); +} + +int +native_mutex_lock(rb_thread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + DWORD result; + while (1) { + thread_debug("native_mutex_lock: %p\n", *lock); + result = w32_wait_events(&*lock, 1, INFINITE, 0); + switch (result) { + case WAIT_OBJECT_0: + /* get mutex object */ + thread_debug("acquire mutex: %p\n", *lock); + return 0; + case WAIT_OBJECT_0 + 1: + /* interrupt */ + errno = EINTR; + thread_debug("acquire mutex interrupted: %p\n", *lock); + return 0; + case WAIT_TIMEOUT: + thread_debug("timeout mutex: %p\n", *lock); + break; + case WAIT_ABANDONED: + rb_bug("win32_mutex_lock: WAIT_ABANDONED"); + break; + default: + rb_bug("win32_mutex_lock: unknown result (%d)", result); + break; + } + } + return 0; +#else + EnterCriticalSection(lock); + return 0; +#endif +} + +int +native_mutex_unlock(rb_thread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + thread_debug("release mutex: %p\n", *lock); + return ReleaseMutex(*lock); +#else + LeaveCriticalSection(lock); + return 0; +#endif +} + +int +native_mutex_trylock(rb_thread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + int result; + thread_debug("native_mutex_trylock: %p\n", *lock); + result = w32_wait_events(&*lock, 1, 1, 0); + thread_debug("native_mutex_trylock result: %d\n", result); + switch (result) { + case WAIT_OBJECT_0: + return 0; + case WAIT_TIMEOUT: + return EBUSY; + } + return EINVAL; +#else + return TryEnterCriticalSection(lock) == 0; +#endif +} + +void +native_mutex_initialize(rb_thread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + *lock = CreateMutex(NULL, FALSE, NULL); + if (*lock == NULL) { + w32_error(); + } + /* thread_debug("initialize mutex: %p\n", *lock); */ +#else + InitializeCriticalSection(lock); +#endif +} + +void +native_mutex_destroy(rb_thread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + w32_close_handle(lock); +#else + DeleteCriticalSection(lock); +#endif +} + +struct cond_event_entry { + struct cond_event_entry* next; + HANDLE event; +}; + +struct rb_thread_cond_struct { + struct cond_event_entry *next; + struct cond_event_entry *last; +}; + +void +native_cond_signal(rb_thread_cond_t *cond) +{ + /* cond is guarded by mutex */ + struct cond_event_entry *e = cond->next; + + if (e) { + cond->next = e->next; + SetEvent(e->event); + } + else { + rb_bug("native_cond_signal: no pending threads"); + } +} + +void +native_cond_broadcast(rb_thread_cond_t *cond) +{ + /* cond is guarded by mutex */ + struct cond_event_entry *e = cond->next; + cond->next = 0; + + while (e) { + SetEvent(e->event); + e = e->next; + } +} + +void +native_cond_wait(rb_thread_cond_t *cond, rb_thread_lock_t *mutex) +{ + DWORD r; + struct cond_event_entry entry; + + entry.next = 0; + entry.event = CreateEvent(0, FALSE, FALSE, 0); + + /* cond is guarded by mutex */ + if (cond->next) { + cond->last->next = &entry; + cond->last = &entry; + } + else { + cond->next = &entry; + cond->last = &entry; + } + + native_mutex_unlock(mutex); + { + r = WaitForSingleObject(entry.event, INFINITE); + if (r != WAIT_OBJECT_0) { + rb_bug("native_cond_wait: WaitForSingleObject returns %d", r); + } + } + native_mutex_lock(mutex); + + w32_close_handle(entry.event); +} + +void +native_cond_initialize(rb_thread_cond_t *cond) +{ + cond->next = 0; + cond->last = 0; +} + +void +native_cond_destroy(rb_thread_cond_t *cond) +{ + /* */ +} + +static void +native_thread_destroy(rb_thread_t *th) +{ + HANDLE intr = th->native_thread_data.interrupt_event; + thread_debug("close handle - intr: %p, thid: %p\n", intr, th->thread_id); + th->native_thread_data.interrupt_event = 0; + w32_close_handle(intr); +} + +static unsigned long _stdcall +thread_start_func_1(void *th_ptr) +{ + rb_thread_t *th = th_ptr; + VALUE stack_start; + volatile HANDLE thread_id = th->thread_id; + + th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0); + + /* run */ + thread_debug("thread created (th: %p, thid: %p, event: %p)\n", th, + th->thread_id, th->native_thread_data.interrupt_event); + thread_start_func_2(th, &stack_start, 0); + + w32_close_handle(thread_id); + thread_debug("thread deleted (th: %p)\n", th); + return 0; +} + +extern size_t rb_gc_stack_maxsize; + +static int +native_thread_create(rb_thread_t *th) +{ + size_t stack_size = 4 * 1024; /* 4KB */ + th->thread_id = w32_create_thread(stack_size, thread_start_func_1, th); + + th->machine_stack_maxsize = rb_gc_stack_maxsize; /* not tested. */ + + if ((th->thread_id) == 0) { + st_delete_wrap(th->vm->living_threads, th->self); + rb_raise(rb_eThreadError, "can't create Thread (%d)", errno); + } + + w32_resume_thread(th->thread_id); + + if (THREAD_DEBUG) { + Sleep(0); + thread_debug("create: (th: %p, thid: %p, intr: %p), stack size: %d\n", + th, th->thread_id, + th->native_thread_data.interrupt_event, stack_size); + } + return 0; +} + +static void +native_thread_join(HANDLE th) +{ + w32_wait_events(&th, 1, 0, 0); +} + +static void +native_thread_apply_priority(rb_thread_t *th) +{ + int priority = th->priority; + if (th->priority > 0) { + priority = THREAD_PRIORITY_ABOVE_NORMAL; + } + else if (th->priority < 0) { + priority = THREAD_PRIORITY_BELOW_NORMAL; + } + else { + priority = THREAD_PRIORITY_NORMAL; + } + + SetThreadPriority(th->thread_id, priority); +} + +static void +ubf_handle(void *ptr) +{ + rb_thread_t *th = (rb_thread_t *)ptr; + thread_debug("ubf_handle: %p\n", th); + w32_set_event(th->native_thread_data.interrupt_event); +} + +static void timer_thread_function(void); + +static HANDLE timer_thread_id = 0; + +static unsigned long _stdcall +timer_thread_func(void *dummy) +{ + thread_debug("timer_thread\n"); + while (system_working) { + Sleep(WIN32_WAIT_TIMEOUT); + timer_thread_function(); + } + thread_debug("timer killed\n"); + return 0; +} + +void +rb_thread_create_timer_thread(void) +{ + if (timer_thread_id == 0) { + timer_thread_id = w32_create_thread(1024, timer_thread_func, 0); + w32_resume_thread(timer_thread_id); + } +} + +#endif /* THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION */ |