12#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
16#define TIME_QUANTUM_USEC (10 * 1000)
17#define RB_CONDATTR_CLOCK_MONOTONIC 1
21#define native_thread_yield() Sleep(0)
22#define unregister_ubf_list(th)
23#define ubf_wakeup_all_threads() do {} while (0)
24#define ubf_threads_empty() (1)
25#define ubf_timer_disarm() do {} while (0)
26#define ubf_list_atfork() do {} while (0)
28static volatile DWORD ruby_native_thread_key = TLS_OUT_OF_INDEXES;
33w32_error(
const char *func)
37 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
38 FORMAT_MESSAGE_FROM_SYSTEM |
39 FORMAT_MESSAGE_IGNORE_INSERTS,
42 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
43 (LPTSTR) & lpMsgBuf, 0,
NULL) == 0)
44 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
45 FORMAT_MESSAGE_FROM_SYSTEM |
46 FORMAT_MESSAGE_IGNORE_INSERTS,
49 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
50 (LPTSTR) & lpMsgBuf, 0,
NULL);
51 rb_bug(
"%s: %s", func, (
char*)lpMsgBuf);
55w32_mutex_lock(HANDLE lock,
bool try)
60 result = w32_wait_events(&lock, 1,
try ? 0 : INFINITE, 0);
66 case WAIT_OBJECT_0 + 1:
75 rb_bug(
"win32_mutex_lock: WAIT_ABANDONED");
78 rb_bug(
"win32_mutex_lock: unknown result (%ld)", result);
90 w32_error(
"rb_native_mutex_initialize");
100 w32_mutex_lock(gvl->
lock,
false);
101 if (GVL_DEBUG) fprintf(stderr,
"gvl acquire (%p): acquire\n", th);
107 ReleaseMutex(gvl->
lock);
114 native_thread_yield();
115 gvl_acquire(gvl, th);
121 if (GVL_DEBUG) fprintf(stderr,
"gvl init\n");
122 gvl->
lock = w32_mutex_create();
128 if (GVL_DEBUG) fprintf(stderr,
"gvl destroy\n");
129 CloseHandle(gvl->
lock);
133ruby_thread_from_native(
void)
135 return TlsGetValue(ruby_native_thread_key);
142 rb_ractor_set_current_ec(th->
ractor, th->
ec);
144 return TlsSetValue(ruby_native_thread_key, th);
151 rb_bug(
"TlsAlloc() for ruby_current_ec_key fails");
153 if ((ruby_native_thread_key = TlsAlloc()) == TLS_OUT_OF_INDEXES) {
154 rb_bug(
"TlsAlloc() for ruby_native_thread_key fails");
156 ruby_thread_set_native(th);
157 DuplicateHandle(GetCurrentProcess(),
164 thread_debug(
"initial thread (th: %p, thid: %p, event: %p)\n",
165 th, GET_THREAD()->thread_id,
172 HANDLE *targets = events;
174 const int initcount =
count;
177 thread_debug(
" w32_wait_events events:%p, count:%d, timeout:%ld, th:%p\n",
178 events,
count, timeout, th);
184 targets[
count++] = intr;
188 w32_error(
"w32_wait_events");
193 ret = WaitForMultipleObjects(
count, targets,
FALSE, timeout);
194 thread_debug(
" WaitForMultipleObjects end (ret: %lu)\n", ret);
196 if (ret == (
DWORD)(WAIT_OBJECT_0 + initcount) && th) {
202 for (i = 0; i <
count; i++) {
204 GetHandleInformation(targets[i], &dmy) ?
"OK" :
"NG");
210static void ubf_handle(
void *
ptr);
211#define ubf_select ubf_handle
216 return w32_wait_events(events,
num, timeout, ruby_thread_from_native());
226 ubf_handle, ruby_thread_from_native(),
FALSE);
231w32_close_handle(HANDLE handle)
233 if (CloseHandle(handle) == 0) {
234 w32_error(
"w32_close_handle");
239w32_resume_thread(HANDLE handle)
241 if (ResumeThread(handle) == (
DWORD)-1) {
242 w32_error(
"w32_resume_thread");
247#define HAVE__BEGINTHREADEX 1
249#undef HAVE__BEGINTHREADEX
252#ifdef HAVE__BEGINTHREADEX
253#define start_thread (HANDLE)_beginthreadex
254#define thread_errno errno
255typedef unsigned long (__stdcall *w32_thread_start_func)(
void*);
257#define start_thread CreateThread
258#define thread_errno rb_w32_map_errno(GetLastError())
259typedef LPTHREAD_START_ROUTINE w32_thread_start_func;
263w32_create_thread(
DWORD stack_size, w32_thread_start_func func,
void *val)
265 return start_thread(0, stack_size, func, val, CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, 0);
271 return w32_wait_events(0, 0, msec, ruby_thread_from_native());
281 ubf_handle, ruby_thread_from_native(),
FALSE);
294 const volatile DWORD msec = rel ? hrtime2msec(*rel) : INFINITE;
310 ret = w32_wait_events(0, 0, msec, th);
326 w32_mutex_lock(lock->mutex,
false);
328 EnterCriticalSection(&lock->crit);
336 return w32_mutex_lock(lock->mutex,
true);
347 ReleaseMutex(lock->mutex);
349 LeaveCriticalSection(&lock->crit);
357 lock->mutex = w32_mutex_create();
360 InitializeCriticalSection(&lock->crit);
368 w32_close_handle(lock->mutex);
370 DeleteCriticalSection(&lock->crit);
374struct cond_event_entry {
375 struct cond_event_entry* next;
376 struct cond_event_entry* prev;
384 struct cond_event_entry *e = cond->
next;
385 struct cond_event_entry *head = (
struct cond_event_entry*)cond;
388 struct cond_event_entry *next = e->next;
389 struct cond_event_entry *prev = e->prev;
393 e->next = e->prev = e;
403 struct cond_event_entry *e = cond->
next;
404 struct cond_event_entry *head = (
struct cond_event_entry*)cond;
407 struct cond_event_entry *next = e->next;
408 struct cond_event_entry *prev = e->prev;
414 e->next = e->prev = e;
424 struct cond_event_entry entry;
425 struct cond_event_entry *head = (
struct cond_event_entry*)cond;
427 entry.event = CreateEvent(0,
FALSE,
FALSE, 0);
431 entry.prev = head->prev;
432 head->prev->next = &entry;
437 r = WaitForSingleObject(entry.event, msec);
438 if ((r != WAIT_OBJECT_0) && (r != WAIT_TIMEOUT)) {
439 rb_bug(
"rb_native_cond_wait: WaitForSingleObject returns %lu", r);
444 entry.prev->next = entry.next;
445 entry.next->prev = entry.prev;
447 w32_close_handle(entry.event);
448 return (r == WAIT_OBJECT_0) ? 0 :
ETIMEDOUT;
454 native_cond_timedwait_ms(cond, mutex, INFINITE);
458abs_timespec_to_timeout_ms(
const struct timespec *ts)
465 tv.tv_usec = ts->
tv_nsec / 1000;
470 return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
476 unsigned long timeout_ms;
478 timeout_ms = abs_timespec_to_timeout_ms(ts);
482 return native_cond_timedwait_ms(cond, mutex, timeout_ms);
492 .tv_nsec = (msec % 1000) * 1000 * 1000,
494 struct timespec ts = native_cond_timeout(cond, rel);
495 native_cond_timedwait(cond, mutex, &ts);
509 now.tv_sec = tv.tv_sec;
510 now.tv_nsec = tv.tv_usec * 1000;
512 timeout.tv_sec = now.tv_sec;
513 timeout.tv_nsec = now.tv_nsec;
514 timeout.tv_sec += timeout_rel.tv_sec;
515 timeout.tv_nsec += timeout_rel.tv_nsec;
517 if (timeout.tv_nsec >= 1000*1000*1000) {
519 timeout.tv_nsec -= 1000*1000*1000;
522 if (timeout.tv_sec < now.tv_sec)
523 timeout.tv_sec = TIMET_MAX;
531 cond->
next = (
struct cond_event_entry *)cond;
532 cond->
prev = (
struct cond_event_entry *)cond;
546#define CHECK_ERR(expr) \
547 {if (!(expr)) {rb_bug("err: %lu - %s", GetLastError(), #expr);}}
552 MEMORY_BASIC_INFORMATION mi;
556 CHECK_ERR(VirtualQuery(&mi, &mi,
sizeof(mi)));
557 base = mi.AllocationBase;
558 end = mi.BaseAddress;
559 end += mi.RegionSize;
562 if (space > 1024*1024) space = 1024*1024;
567#ifndef InterlockedExchangePointer
568#define InterlockedExchangePointer(t, v) \
569 (void *)InterlockedExchange((long *)(t), (long)(v))
576 w32_close_handle(intr);
579static unsigned long __stdcall
580thread_start_func_1(
void *th_ptr)
583 volatile HANDLE thread_id = th->
thread_id;
585 native_thread_init_stack(th);
589 thread_debug(
"thread created (th: %p, thid: %p, event: %p)\n", th,
594 w32_close_handle(thread_id);
603 th->
thread_id = w32_create_thread(stack_size, thread_start_func_1, th);
621native_thread_join(HANDLE th)
623 w32_wait_events(&th, 1, INFINITE, 0);
626#if USE_NATIVE_THREAD_PRIORITY
633 priority = THREAD_PRIORITY_ABOVE_NORMAL;
636 priority = THREAD_PRIORITY_BELOW_NORMAL;
639 priority = THREAD_PRIORITY_NORMAL;
642 SetThreadPriority(th->
thread_id, priority);
655 r = rb_fd_ptr(readfds);
659 w = rb_fd_ptr(writefds);
663 e = rb_fd_ptr(exceptfds);
672 return w32_wait_events(0, 0, 0, th);
682 w32_error(
"ubf_handle");
688#define native_set_another_thread_name rb_w32_set_thread_description_str
694#define TIMER_THREAD_CREATED_P() (timer_thread.id != 0)
696static unsigned long __stdcall
697timer_thread_func(
void *dummy)
702 while (WaitForSingleObject(timer_thread.lock,
703 TIME_QUANTUM_USEC/1000) == WAIT_TIMEOUT) {
719rb_thread_start_unblock_thread(
void)
725rb_thread_create_timer_thread(
void)
727 if (timer_thread.id == 0) {
728 if (!timer_thread.lock) {
729 timer_thread.lock = CreateEvent(0,
TRUE,
FALSE, 0);
731 timer_thread.id = w32_create_thread(1024 + (
THREAD_DEBUG ? BUFSIZ : 0),
732 timer_thread_func, 0);
733 w32_resume_thread(timer_thread.id);
738native_stop_timer_thread(
void)
740 int stopped = --system_working <= 0;
742 SetEvent(timer_thread.lock);
743 native_thread_join(timer_thread.id);
744 CloseHandle(timer_thread.lock);
745 timer_thread.lock = 0;
751native_reset_timer_thread(
void)
753 if (timer_thread.id) {
754 CloseHandle(timer_thread.id);
760ruby_stack_overflowed_p(
const rb_thread_t *th,
const void *addr)
765#if defined(__MINGW32__)
767rb_w32_stack_overflow_handler(
struct _EXCEPTION_POINTERS *exception)
769 if (exception->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW) {
773 return EXCEPTION_CONTINUE_SEARCH;
777#ifdef RUBY_ALLOCA_CHKSTK
779ruby_alloca_chkstk(
size_t len,
void *sp)
806 rb_bug(
"not implemented, should not be called");
813 rb_bug(
"not implemented, should not be called");
819 return GetCurrentThread();
828static unsigned long __stdcall
831 void (*worker_func)(void) = arg;
839rb_thread_create_mjit_thread(
void (*worker_func)(
void))
841 size_t stack_size = 4 * 1024;
842 HANDLE thread_id = w32_create_thread(stack_size,
mjit_worker, worker_func);
843 if (thread_id == 0) {
847 w32_resume_thread(thread_id);
#define rb_ec_raised_p(ec, f)
#define rb_ec_raised_set(ec, f)
void ruby_init_stack(volatile VALUE *)
size_t ruby_stack_length(VALUE **p)
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
void rb_sys_fail(const char *mesg)
#define RB_HRTIME_PER_MSEC
int rb_reserved_fd_p(int fd)
typedef long(ZCALLBACK *tell_file_func) OF((voidpf opaque
#define ALLOCA_N(type, n)
void rb_sigwait_fd_put(const rb_thread_t *, int fd)
int rb_sigwait_fd_get(const rb_thread_t *)
void rb_sigwait_sleep(const rb_thread_t *, int fd, const rb_hrtime_t *)
void rb_gvl_init(rb_global_vm_lock_t *gvl)
#define rb_fd_resize(n, f)
void ruby_sigchld_handler(rb_vm_t *vm)
struct rb_execution_context_struct::@200 machine
rb_nativethread_lock_t lock
struct cond_event_entry * next
struct cond_event_entry * prev
rb_execution_context_t * ec
struct rb_unblock_callback unblock
native_thread_data_t native_thread_data
rb_nativethread_id_t thread_id
rb_nativethread_lock_t interrupt_lock
rb_unblock_function_t * func
struct rb_vm_struct::@194 ractor
struct rb_thread_struct * main_thread
struct rb_vm_struct::@196 default_params
size_t thread_vm_stack_size
size_t thread_machine_stack_size
void rb_threadptr_check_signal(rb_thread_t *mth)
#define GVL_UNLOCK_BEGIN(th)
#define BLOCKING_REGION(th, exec, ubf, ubfarg, fail_if_interrupted)
#define GVL_UNLOCK_END(th)
rb_nativethread_id_t rb_nativethread_self()
void rb_native_mutex_lock(rb_nativethread_lock_t *lock)
void rb_native_cond_initialize(rb_nativethread_cond_t *cond)
int rb_native_mutex_trylock(rb_nativethread_lock_t *lock)
void rb_native_cond_broadcast(rb_nativethread_cond_t *cond)
void rb_native_mutex_initialize(rb_nativethread_lock_t *lock)
void rb_native_mutex_unlock(rb_nativethread_lock_t *lock)
void rb_native_mutex_destroy(rb_nativethread_lock_t *lock)
void rb_native_cond_destroy(rb_nativethread_cond_t *cond)
void rb_native_cond_signal(rb_nativethread_cond_t *cond)
void rb_native_cond_wait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex)
void rb_native_cond_timedwait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex, unsigned long msec)
native_tls_key_t ruby_current_ec_key
WINBASEAPI BOOL WINAPI TryEnterCriticalSection(IN OUT LPCRITICAL_SECTION lpCriticalSection)
#define RUBY_VM_INTERRUPTED(ec)
void Init_native_thread(rb_thread_t *th)
void rb_thread_wakeup_timer_thread(int)
int rb_w32_select_with_thread(int nfds, fd_set *rd, fd_set *wr, fd_set *ex, struct timeval *timeout, void *th)
int rb_w32_check_interrupt(void *)
int rb_w32_set_thread_description(HANDLE th, const WCHAR *name)
int rb_w32_set_thread_description_str(HANDLE th, VALUE name)
int rb_w32_wait_events(HANDLE *events, int num, DWORD timeout)
int gettimeofday(struct timeval *, struct timezone *)
int rb_w32_wait_events_blocking(HANDLE *events, int num, DWORD timeout)
int rb_w32_sleep(unsigned long msec)
int rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait)
int WINAPI rb_w32_Sleep(unsigned long msec)