From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/thread_win32.c | 802 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 802 insertions(+) create mode 100644 jni/ruby/thread_win32.c (limited to 'jni/ruby/thread_win32.c') diff --git a/jni/ruby/thread_win32.c b/jni/ruby/thread_win32.c new file mode 100644 index 0000000..74e45b5 --- /dev/null +++ b/jni/ruby/thread_win32.c @@ -0,0 +1,802 @@ +/* -*-c-*- */ +/********************************************************************** + + thread_win32.c - + + $Author: akr $ + + Copyright (C) 2004-2007 Koichi Sasada + +**********************************************************************/ + +#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION + +#include + +#define TIME_QUANTUM_USEC (10 * 1000) +#define RB_CONDATTR_CLOCK_MONOTONIC 1 /* no effect */ + +#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 int w32_wait_events(HANDLE *events, int count, DWORD timeout, rb_thread_t *th); +static int native_mutex_lock(rb_nativethread_lock_t *lock); +static int native_mutex_unlock(rb_nativethread_lock_t *lock); + +static void +w32_error(const char *func) +{ + LPVOID lpMsgBuf; + DWORD err = GetLastError(); + if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + err, + MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), + (LPTSTR) & lpMsgBuf, 0, NULL) == 0) + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + err, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), + (LPTSTR) & lpMsgBuf, 0, NULL); + rb_bug("%s: %s", func, (char*)lpMsgBuf); +} + +static int +w32_mutex_lock(HANDLE lock) +{ + 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 (%ld)", result); + break; + } + } + return 0; +} + +static HANDLE +w32_mutex_create(void) +{ + HANDLE lock = CreateMutex(NULL, FALSE, NULL); + if (lock == NULL) { + w32_error("native_mutex_initialize"); + } + return lock; +} + +#define GVL_DEBUG 0 + +static void +gvl_acquire(rb_vm_t *vm, rb_thread_t *th) +{ + w32_mutex_lock(vm->gvl.lock); + if (GVL_DEBUG) fprintf(stderr, "gvl acquire (%p): acquire\n", th); +} + +static void +gvl_release(rb_vm_t *vm) +{ + ReleaseMutex(vm->gvl.lock); +} + +static void +gvl_yield(rb_vm_t *vm, rb_thread_t *th) +{ + gvl_release(th->vm); + native_thread_yield(); + gvl_acquire(vm, th); +} + + +static void +gvl_atfork(rb_vm_t *vm) +{ + rb_bug("gvl_atfork() is called on win32"); +} + +static void +gvl_init(rb_vm_t *vm) +{ + if (GVL_DEBUG) fprintf(stderr, "gvl init\n"); + vm->gvl.lock = w32_mutex_create(); +} + +static void +gvl_destroy(rb_vm_t *vm) +{ + if (GVL_DEBUG) fprintf(stderr, "gvl destroy\n"); + CloseHandle(vm->gvl.lock); +} + +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); +} + +void +Init_native_thread(void) +{ + rb_thread_t *th = GET_THREAD(); + + ruby_native_thread_key = TlsAlloc(); + ruby_thread_set_native(th); + 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_set_event(HANDLE handle) +{ + if (SetEvent(handle) == 0) { + w32_error("w32_set_event"); + } +} + +static void +w32_reset_event(HANDLE handle) +{ + if (ResetEvent(handle) == 0) { + w32_error("w32_reset_event"); + } +} + +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)) { + gvl_acquire(th->vm, th); + if (intr == th->native_thread_data.interrupt_event) { + w32_reset_event(intr); + if (RUBY_VM_INTERRUPTED(th)) { + 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); + } + gvl_release(th->vm); + } + + thread_debug(" WaitForMultipleObjects start (count: %d)\n", count); + ret = WaitForMultipleObjects(count, targets, FALSE, timeout); + thread_debug(" WaitForMultipleObjects end (ret: %lu)\n", ret); + + if (ret == (DWORD)(WAIT_OBJECT_0 + count - 1) && th) { + errno = EINTR; + } + if (ret == WAIT_FAILED && 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, ruby_thread_from_native()); +} + +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, ruby_thread_from_native(), FALSE); + return ret; +} + +static void +w32_close_handle(HANDLE handle) +{ + if (CloseHandle(handle) == 0) { + w32_error("w32_close_handle"); + } +} + +static void +w32_resume_thread(HANDLE handle) +{ + if (ResumeThread(handle) == (DWORD)-1) { + w32_error("w32_resume_thread"); + } +} + +#ifdef _MSC_VER +#define HAVE__BEGINTHREADEX 1 +#else +#undef HAVE__BEGINTHREADEX +#endif + +#ifdef HAVE__BEGINTHREADEX +#define start_thread (HANDLE)_beginthreadex +#define thread_errno errno +typedef unsigned long (__stdcall *w32_thread_start_func)(void*); +#else +#define start_thread CreateThread +#define thread_errno rb_w32_map_errno(GetLastError()) +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, ruby_thread_from_native()); +} + +int WINAPI +rb_w32_Sleep(unsigned long msec) +{ + int ret; + + BLOCKING_REGION(ret = rb_w32_sleep(msec), + ubf_handle, ruby_thread_from_native(), FALSE); + return ret; +} + +static void +native_sleep(rb_thread_t *th, struct timeval *tv) +{ + const volatile DWORD msec = (tv) ? + (DWORD)(tv->tv_sec * 1000 + tv->tv_usec / 1000) : INFINITE; + + GVL_UNLOCK_BEGIN(); + { + DWORD ret; + + native_mutex_lock(&th->interrupt_lock); + th->unblock.func = ubf_handle; + th->unblock.arg = th; + native_mutex_unlock(&th->interrupt_lock); + + if (RUBY_VM_INTERRUPTED(th)) { + /* interrupted. return immediate */ + } + else { + thread_debug("native_sleep start (%lu)\n", msec); + ret = w32_wait_events(0, 0, msec, th); + thread_debug("native_sleep done (%lu)\n", ret); + } + + native_mutex_lock(&th->interrupt_lock); + th->unblock.func = 0; + th->unblock.arg = 0; + native_mutex_unlock(&th->interrupt_lock); + } + GVL_UNLOCK_END(); +} + +static int +native_mutex_lock(rb_nativethread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + w32_mutex_lock(lock->mutex); +#else + EnterCriticalSection(&lock->crit); +#endif + return 0; +} + +static int +native_mutex_unlock(rb_nativethread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + thread_debug("release mutex: %p\n", lock->mutex); + return ReleaseMutex(lock->mutex); +#else + LeaveCriticalSection(&lock->crit); + return 0; +#endif +} + +static int +native_mutex_trylock(rb_nativethread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + int result; + thread_debug("native_mutex_trylock: %p\n", lock->mutex); + result = w32_wait_events(&lock->mutex, 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->crit) == 0; +#endif +} + +static void +native_mutex_initialize(rb_nativethread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + lock->mutex = w32_mutex_create(); + /* thread_debug("initialize mutex: %p\n", lock->mutex); */ +#else + InitializeCriticalSection(&lock->crit); +#endif +} + +static void +native_mutex_destroy(rb_nativethread_lock_t *lock) +{ +#if USE_WIN32_MUTEX + w32_close_handle(lock->mutex); +#else + DeleteCriticalSection(&lock->crit); +#endif +} + +struct cond_event_entry { + struct cond_event_entry* next; + struct cond_event_entry* prev; + HANDLE event; +}; + +static void +native_cond_signal(rb_nativethread_cond_t *cond) +{ + /* cond is guarded by mutex */ + struct cond_event_entry *e = cond->next; + struct cond_event_entry *head = (struct cond_event_entry*)cond; + + if (e != head) { + struct cond_event_entry *next = e->next; + struct cond_event_entry *prev = e->prev; + + prev->next = next; + next->prev = prev; + e->next = e->prev = e; + + SetEvent(e->event); + } +} + +static void +native_cond_broadcast(rb_nativethread_cond_t *cond) +{ + /* cond is guarded by mutex */ + struct cond_event_entry *e = cond->next; + struct cond_event_entry *head = (struct cond_event_entry*)cond; + + while (e != head) { + struct cond_event_entry *next = e->next; + struct cond_event_entry *prev = e->prev; + + SetEvent(e->event); + + prev->next = next; + next->prev = prev; + e->next = e->prev = e; + + e = next; + } +} + + +static int +native_cond_timedwait_ms(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex, unsigned long msec) +{ + DWORD r; + struct cond_event_entry entry; + struct cond_event_entry *head = (struct cond_event_entry*)cond; + + entry.event = CreateEvent(0, FALSE, FALSE, 0); + + /* cond is guarded by mutex */ + entry.next = head; + entry.prev = head->prev; + head->prev->next = &entry; + head->prev = &entry; + + native_mutex_unlock(mutex); + { + r = WaitForSingleObject(entry.event, msec); + if ((r != WAIT_OBJECT_0) && (r != WAIT_TIMEOUT)) { + rb_bug("native_cond_wait: WaitForSingleObject returns %lu", r); + } + } + native_mutex_lock(mutex); + + entry.prev->next = entry.next; + entry.next->prev = entry.prev; + + w32_close_handle(entry.event); + return (r == WAIT_OBJECT_0) ? 0 : ETIMEDOUT; +} + +static int +native_cond_wait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex) +{ + return native_cond_timedwait_ms(cond, mutex, INFINITE); +} + +static unsigned long +abs_timespec_to_timeout_ms(const struct timespec *ts) +{ + struct timeval tv; + struct timeval now; + + gettimeofday(&now, NULL); + tv.tv_sec = ts->tv_sec; + tv.tv_usec = ts->tv_nsec / 1000; + + if (!rb_w32_time_subtract(&tv, &now)) + return 0; + + return (tv.tv_sec * 1000) + (tv.tv_usec / 1000); +} + +static int +native_cond_timedwait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex, const struct timespec *ts) +{ + unsigned long timeout_ms; + + timeout_ms = abs_timespec_to_timeout_ms(ts); + if (!timeout_ms) + return ETIMEDOUT; + + return native_cond_timedwait_ms(cond, mutex, timeout_ms); +} + +static struct timespec +native_cond_timeout(rb_nativethread_cond_t *cond, struct timespec timeout_rel) +{ + int ret; + struct timeval tv; + struct timespec timeout; + struct timespec now; + + ret = gettimeofday(&tv, 0); + if (ret != 0) + rb_sys_fail(0); + now.tv_sec = tv.tv_sec; + now.tv_nsec = tv.tv_usec * 1000; + + timeout.tv_sec = now.tv_sec; + timeout.tv_nsec = now.tv_nsec; + timeout.tv_sec += timeout_rel.tv_sec; + timeout.tv_nsec += timeout_rel.tv_nsec; + + if (timeout.tv_nsec >= 1000*1000*1000) { + timeout.tv_sec++; + timeout.tv_nsec -= 1000*1000*1000; + } + + if (timeout.tv_sec < now.tv_sec) + timeout.tv_sec = TIMET_MAX; + + return timeout; +} + +static void +native_cond_initialize(rb_nativethread_cond_t *cond, int flags) +{ + cond->next = (struct cond_event_entry *)cond; + cond->prev = (struct cond_event_entry *)cond; +} + +static void +native_cond_destroy(rb_nativethread_cond_t *cond) +{ + /* */ +} + +void +ruby_init_stack(volatile VALUE *addr) +{ +} + +#define CHECK_ERR(expr) \ + {if (!(expr)) {rb_bug("err: %lu - %s", GetLastError(), #expr);}} + +static void +native_thread_init_stack(rb_thread_t *th) +{ + MEMORY_BASIC_INFORMATION mi; + char *base, *end; + DWORD size, space; + + CHECK_ERR(VirtualQuery(&mi, &mi, sizeof(mi))); + base = mi.AllocationBase; + end = mi.BaseAddress; + end += mi.RegionSize; + size = end - base; + space = size / 5; + if (space > 1024*1024) space = 1024*1024; + th->machine.stack_start = (VALUE *)end - 1; + th->machine.stack_maxsize = size - space; +} + +#ifndef InterlockedExchangePointer +#define InterlockedExchangePointer(t, v) \ + (void *)InterlockedExchange((long *)(t), (long)(v)) +#endif +static void +native_thread_destroy(rb_thread_t *th) +{ + HANDLE intr = InterlockedExchangePointer(&th->native_thread_data.interrupt_event, 0); + thread_debug("close handle - intr: %p, thid: %p\n", intr, th->thread_id); + w32_close_handle(intr); +} + +static unsigned long __stdcall +thread_start_func_1(void *th_ptr) +{ + rb_thread_t *th = th_ptr; + volatile HANDLE thread_id = th->thread_id; + + native_thread_init_stack(th); + 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, th->machine.stack_start, rb_ia64_bsp()); + + w32_close_handle(thread_id); + thread_debug("thread deleted (th: %p)\n", th); + return 0; +} + +static int +native_thread_create(rb_thread_t *th) +{ + size_t stack_size = 4 * 1024; /* 4KB is the minimum commit size */ + th->thread_id = w32_create_thread(stack_size, thread_start_func_1, th); + + if ((th->thread_id) == 0) { + return thread_errno; + } + + w32_resume_thread(th->thread_id); + + if (THREAD_DEBUG) { + Sleep(0); + thread_debug("create: (th: %p, thid: %p, intr: %p), stack size: %"PRIdSIZE"\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, INFINITE, 0); +} + +#if USE_NATIVE_THREAD_PRIORITY + +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); +} + +#endif /* USE_NATIVE_THREAD_PRIORITY */ + +int rb_w32_select_with_thread(int, fd_set *, fd_set *, fd_set *, struct timeval *, void *); /* @internal */ + +static int +native_fd_select(int n, rb_fdset_t *readfds, rb_fdset_t *writefds, rb_fdset_t *exceptfds, struct timeval *timeout, rb_thread_t *th) +{ + fd_set *r = NULL, *w = NULL, *e = NULL; + if (readfds) { + rb_fd_resize(n - 1, readfds); + r = rb_fd_ptr(readfds); + } + if (writefds) { + rb_fd_resize(n - 1, writefds); + w = rb_fd_ptr(writefds); + } + if (exceptfds) { + rb_fd_resize(n - 1, exceptfds); + e = rb_fd_ptr(exceptfds); + } + return rb_w32_select_with_thread(n, r, w, e, timeout, th); +} + +/* @internal */ +int +rb_w32_check_interrupt(rb_thread_t *th) +{ + return w32_wait_events(0, 0, 0, th); +} + +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 struct { + HANDLE id; + HANDLE lock; +} timer_thread; +#define TIMER_THREAD_CREATED_P() (timer_thread.id != 0) + +static unsigned long __stdcall +timer_thread_func(void *dummy) +{ + thread_debug("timer_thread\n"); + while (WaitForSingleObject(timer_thread.lock, TIME_QUANTUM_USEC/1000) == + WAIT_TIMEOUT) { + timer_thread_function(dummy); + } + thread_debug("timer killed\n"); + return 0; +} + +void +rb_thread_wakeup_timer_thread(void) +{ + /* do nothing */ +} + +static void +rb_thread_create_timer_thread(void) +{ + if (timer_thread.id == 0) { + if (!timer_thread.lock) { + timer_thread.lock = CreateEvent(0, TRUE, FALSE, 0); + } + timer_thread.id = w32_create_thread(1024 + (THREAD_DEBUG ? BUFSIZ : 0), + timer_thread_func, 0); + w32_resume_thread(timer_thread.id); + } +} + +static int +native_stop_timer_thread(int close_anyway) +{ + int stopped = --system_working <= 0; + if (stopped) { + SetEvent(timer_thread.lock); + native_thread_join(timer_thread.id); + CloseHandle(timer_thread.lock); + timer_thread.lock = 0; + } + return stopped; +} + +static void +native_reset_timer_thread(void) +{ + if (timer_thread.id) { + CloseHandle(timer_thread.id); + timer_thread.id = 0; + } +} + +int +ruby_stack_overflowed_p(const rb_thread_t *th, const void *addr) +{ + return rb_thread_raised_p(th, RAISED_STACKOVERFLOW); +} + +#if defined(__MINGW32__) +LONG WINAPI +rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *exception) +{ + if (exception->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW) { + rb_thread_raised_set(GET_THREAD(), RAISED_STACKOVERFLOW); + raise(SIGSEGV); + } + return EXCEPTION_CONTINUE_SEARCH; +} +#endif + +#ifdef RUBY_ALLOCA_CHKSTK +void +ruby_alloca_chkstk(size_t len, void *sp) +{ + if (ruby_stack_length(NULL) * sizeof(VALUE) >= len) { + rb_thread_t *th = GET_THREAD(); + if (!rb_thread_raised_p(th, RAISED_STACKOVERFLOW)) { + rb_thread_raised_set(th, RAISED_STACKOVERFLOW); + rb_exc_raise(sysstack_error); + } + } +} +#endif +int +rb_reserved_fd_p(int fd) +{ + return 0; +} + +rb_nativethread_id_t +rb_nativethread_self(void) +{ + return GetCurrentThread(); +} + +static void +native_set_thread_name(rb_thread_t *th) +{ +} + +#endif /* THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION */ -- cgit v1.2.3